# Robinhood Chain RPC, chain ID 4663 and network settings > Robinhood Chain network settings: chain ID 4663 (0x1237), public RPC URLs, ETH gas, the block explorer, an eth_chainId check and what an indexed API adds. Source: https://docs.crius.sh/guides/robinhood-chain-rpc-and-chain-id/ · Updated 2026-10-28 Short answer Robinhood Chain is an Arbitrum Orbit L2 with chain ID `4663` (`0x1237`) and ETH as its gas token. The official public RPC is `https://rpc.mainnet.chain.robinhood.com` (fallback `https://robinhood-rpc.publicnode.com`) and the block explorer is `https://robin.etherscan.io`. For prices, trades, holders and launches, `GET /v1/robinhood/stats` and the rest of the Crius API answer without an RPC. [GET `/v1/chains`](https://docs.crius.sh/reference/chain/supported-chains/) [GET `/stats`](https://docs.crius.sh/reference/chain/chain-stats/) [GET `/v1/status`](https://docs.crius.sh/reference/chain/service-status/) Robinhood Chain is an Ethereum layer-2 network built on **Arbitrum Orbit**, with chain ID **4663** (`0x1237` in hex) and **ETH** as its gas token. To connect a wallet or a script you need four things: the chain ID, an RPC URL (`https://rpc.mainnet.chain.robinhood.com`), the currency symbol ETH and the block explorer (`https://robin.etherscan.io`). The chain’s main assets are WETH, the **USDG** dollar stablecoin and **tokenized stocks** such as NVDA and TSLA; the [Robinhood Chain concept page](https://docs.crius.sh/concepts/robinhood-chain/) lists the WETH and USDG addresses. ## Network settings: add Robinhood Chain to a wallet Enter these values in a wallet’s “add network” form, or in your app’s chain config. | Setting | Value | | --- | --- | | Network name | Robinhood Chain | | RPC URL | `https://rpc.mainnet.chain.robinhood.com` | | Fallback RPC URL | `https://robinhood-rpc.publicnode.com` | | Chain ID | `4663` (hex `0x1237`) | | Currency symbol | ETH (18 decimals) | | Block explorer | `https://robin.etherscan.io` (alternative: [Hoodscan](https://hoodscan.co)) | From a dapp, the same settings go into the standard `wallet_addEthereumChain` request (EIP-3085), which takes the chain ID in hex: ```js await window.ethereum.request({ method: "wallet_addEthereumChain", params: [{ chainId: "0x1237", // 4663 chainName: "Robinhood Chain", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }, rpcUrls: ["https://rpc.mainnet.chain.robinhood.com", "https://robinhood-rpc.publicnode.com"], blockExplorerUrls: ["https://robin.etherscan.io"], }], }); ``` ## Check the chain ID over RPC Any JSON-RPC client can confirm it is talking to Robinhood Chain. `eth_chainId` takes no parameters: Terminal window ```bash curl -s -X POST https://rpc.mainnet.chain.robinhood.com \ -H 'content-type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId"}' # {"jsonrpc":"2.0","id":1,"result":"0x1237"} ``` `0x1237` is 4663. The fallback RPC returns the same result, and `net_version` returns the decimal string `"4663"`. `eth_blockNumber` gives the latest L2 block in hex; Robinhood Chain had passed block 100 million when these docs were written. ## Block time, gas and finality in one call An RPC tells you about one block at a time. The Crius chain stats endpoint sums up the network over a window, from Crius’s own archive nodes, without an API key. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/chain/chain-stats/) ### Robinhood Chain over 24 hours: 101 ms blocks, 2-cent swaps How fast are Robinhood Chain blocks, what does gas cost, and how far behind the head are the safe and finalized blocks? GET/v1/robinhood/stats?window=24h **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/stats?window=24h" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/stats?window=24h"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/stats?window=24h", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 100 lines (arrays trimmed)** ```json { "data": { "blocks": { "active_wallets": 194641, "avg_block_time_ms": 101, "tps_1m": 44.6833, "txs": 2430221 }, "chain": "robinhood", "chain_id": 4663, "dex": { "by_dex": { "launch_curve": 114839, "pons_curve": 6920073, "uniswap_v2": 6992610, "uniswap_v3": 235116790, "uniswap_v4": 286137338 }, "traders": 148079, "trades": 1769098, "volume_usd": 535281650, "wash_volume_usd": 100833980 }, "eth_usd": 2355.49, "finalized_block": 100397649, "gas": { "avg_swap_cost_eth": 0.00000791235, "avg_swap_cost_usd": 0.0186374, "l1_base_fee_gwei": 0, "l2_gas_price_gwei": 0.021042 }, "head_block": 100406547, "l1_block": 26294099, "launchpads": [ { "graduated": 16, "launches": 1780, "launchpad": "pons", "launchpad_name": "Pons", "volume_usd": 25485280 }, { "graduated": 0, "launches": 508, "launchpad": "long", "launchpad_name": "Long.xyz", "volume_usd": 10784246 }, { "graduated": 0, "launches": 20, "launchpad": "bankr", "launchpad_name": "Bankr", "volume_usd": 595435 } ], "liquidity": { "locked_lp_usd": 44712347, "method": "2x quote side (ETH/WETH/USDG) of every pool; V3/V4 in-range", "tvl_usd": 322714989 }, "pools": { "by_dex": { "launch_curve": 1201, "pons_curve": 1780, "uniswap_v2": 1483, "uniswap_v3": 224, "uniswap_v4": 5457 }, "new": 10145 }, "reorgs": { "count": 0, "max_depth": 0 }, "safe_block": 100401329, "tokens": { "by_attribution": { "known_launchpad": 3527, "other": 4095 }, "new": 7622, "new_1h": 418 }, "window": "24h" }, "meta": { "block": 100406547, "block_age_ms": 1026, "block_ts": 1793225052000, "chain": "robinhood", "coverage": { "note": "aggregates cover blocks indexed since start_block until backfill completes", "since_block": 0 }, "finalized_block": 100397649, "lag_ms": 26, "safe_block": 100401329 } } ``` What this tells you - `chain_id: 4663` and `blocks.avg_block_time_ms: 101`: blocks arrived about every 100 ms over the window, with 2,430,221 transactions (`blocks.txs`) from 194,641 active wallets and 44.6833 transactions per second in the last minute (`tps_1m`). - `gas.l2_gas_price_gwei: 0.021042`: an average swap cost 0.00000791235 ETH, or $0.0186374 at `eth_usd: 2355.49`. - `head_block: 100406547`, `safe_block: 100401329` and `finalized_block: 100397649`: the safe block trails the head while batches wait to be posted to Ethereum, and finalized trails safe until Ethereum finalizes them ([Finality](https://docs.crius.sh/concepts/finality/)). - `l1_block: 26294099` is the Ethereum block at that time: inside a contract, `block.number` returns this L1 number, not the L2 block. - `reorgs.count: 0`: no blocks were reorganized in the 24 hours. [Chain stats reference](https://docs.crius.sh/reference/chain/chain-stats/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Robinhood%20Chain%20over%2024%20hours%3A%20101%20ms%20blocks%2C%202-cent%20swaps&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Frobinhood-chain-rpc-and-chain-id%2F%23stats%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fstats%3Fwindow%3D24h%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · free](https://docs.crius.sh/reference/chain/supported-chains/) ### The chain as the Crius API serves it Which chain ID, native token and block time does the Crius API report for Robinhood Chain? GET/v1/chains **cURL** ```bash curl "https://api.crius.sh/v1/chains" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/chains"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/chains", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 15 lines (arrays trimmed)** ```json { "data": [ { "block_time_ms": 100, "chain_id": 4663, "name": "Robinhood Chain", "native": "ETH", "regions": [ "rigel" ], "slug": "robinhood", "type": "arbitrum_orbit_l2" } ] } ``` What this tells you - `chain_id: 4663`, `name: "Robinhood Chain"`, `native: "ETH"` and `type: "arbitrum_orbit_l2"`: the same network settings as the table above. - `block_time_ms: 100` is the nominal block time; the measured average is in `/stats` (`blocks.avg_block_time_ms`). - `slug: "robinhood"` is the path segment in every endpoint (`/v1/robinhood/...`); the chain ID works too (`/v1/4663/...`). - `/v1/chains` and `/v1/status` are public: no key and no credits. [Supported chains reference](https://docs.crius.sh/reference/chain/supported-chains/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20chain%20as%20the%20Crius%20API%20serves%20it&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Frobinhood-chain-rpc-and-chain-id%2F%23chains%0ARequest%3A%20GET%20%2Fv1%2Fchains%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What an RPC gives you, and what an indexed API adds An RPC node answers questions about raw state: a balance, a contract call, the logs in a block range. It is also how you send transactions. An indexed API has already read every block and turned the logs into answers. | Question | Over RPC | With the Crius API | | --- | --- | --- | | Send a transaction, estimate gas, read a nonce | `eth_sendRawTransaction`, `eth_estimateGas`, `eth_getTransactionCount` | Not available: Crius is read-only. Keep an RPC for this. | | What is this token worth in USD? | Find its pools, read `slot0` or reserves, then convert the quote to USD | `/token/{address}/price` (anonymous) | | Who holds this token? | Replay every `Transfer` log since the token's first block | `/token/{address}/holders` (Free plan) | | Which tokens launched in the last minute, and on which launchpad? | Watch every factory you know about | `/tokens?list=new` with `launchpad` on each row (anonymous) | | Is this token a honeypot, and what tax does it charge? | Read the contract and simulate a buy and a sell | `/token/{address}/security` (anonymous) | | Is the data final? | Ask for `safe` and `finalized` blocks yourself | `meta.safe_block`, `meta.finalized_block` and `meta.lag_ms` on every response | The [RPC migration guide](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/) maps each RPC read to its Crius call, with before-and-after code. ## Use it in your app 1. **Pin the chain ID.** Check `eth_chainId` returns `0x1237` when your app connects, and refuse to sign for any other chain. 2. **Use the RPC for writes.** Transactions, gas estimates, nonces and calls to your own contracts go through an RPC: the public one for testing, a dedicated provider or your own node in production. 3. **Read market data from an index.** Prices, trades, candles, holders, launches and security checks come from the Crius API; most of it works without a key. 4. **Watch the index.** `/v1/status` reports `status` (`live`, `catching_up`, `stalled`, `starting`) and `lag_ms`; every response carries `meta.block`. ```js // Confirm the network over RPC, then read chain-wide numbers from Crius. const RPC = "https://rpc.mainnet.chain.robinhood.com"; const rpc = await fetch(RPC, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_chainId" }), }); const chainId = parseInt((await rpc.json()).result, 16); if (chainId !== 4663) throw new Error(`wrong chain: ${chainId}`); const { data } = await (await fetch("https://api.crius.sh/v1/robinhood/stats?window=1h")).json(); console.log(`block time ${data.blocks.avg_block_time_ms} ms, swap ≈ $${data.gas.avg_swap_cost_usd}, head ${data.head_block}`); ``` Public RPCs are shared The public endpoints are free and serve everyone, so expect rate limits under load. Scanning history over them is slow: at about 10 blocks a second, a full backfill of logs is weeks of `eth_getLogs` calls. That history is what the Crius API already indexes, from block 0. ## Frequently asked questions **What is the chain ID of Robinhood Chain?** `4663`, or `0x1237` in hex. `eth_chainId` on the public RPC returns `"0x1237"` and `net_version` returns `"4663"`. Wallets, signing libraries (EIP-155) and `wallet_addEthereumChain` use this number. **What is the Robinhood Chain RPC URL?** The official public RPC is `https://rpc.mainnet.chain.robinhood.com`. `https://robinhood-rpc.publicnode.com` is a public fallback that returns the same chain ID. Both are shared by everyone, so production apps usually use a dedicated RPC provider or their own node for writes, and an indexed API such as Crius for market data. **What is the gas token on Robinhood Chain?** ETH. It has 18 decimals, like on Ethereum, and is shown with the symbol ETH in wallets. Fees are low: in the 24-hour `stats` sample the L2 gas price was 0.021042 gwei and an average swap cost $0.0186374 (`gas.avg_swap_cost_usd`). **Which block explorer does Robinhood Chain use?** Robinhood Chain Etherscan at [robin.etherscan.io](https://robin.etherscan.io) is the explorer to put in wallet settings. [Hoodscan](https://hoodscan.co) is an alternative explorer for the same chain. **Can I use the chain ID in Crius API URLs?** Yes. The chain segment of every path takes the slug or the chain ID, so `/v1/4663/stats` and `/v1/robinhood/stats` return the same data. The examples in these docs use `robinhood`. ## Related [Concept **Robinhood Chain** What Robinhood Chain is (chain id 4663), its block times, gas, L1 settlement, native assets (ETH, WETH, USDG), tokenized stocks, and how Crius indexes it. Read](https://docs.crius.sh/concepts/robinhood-chain/) [Guide **Migrate from RPC** Replace eth\_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs. Read](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/) [Concept **Finality & reorgs** Finality levels on Robinhood Chain (latest, safe, finalized), how the Crius API marks them, and how chain reorganizations are handled in REST and WebSocket. Read](https://docs.crius.sh/concepts/finality/) [Guide **Chain stats dashboard** Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code. Read](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/) [API reference **Chain stats API** DEX volume and trades (per DEX), traders, TVL and locked liquidity, launches and graduations per launchpad, pools, gas costs and block times over a window (1h, 24h, 7d). Read](https://docs.crius.sh/reference/chain/chain-stats/) [Docs **Quickstart** Create a free Crius account, get an API key and make your first Robinhood Chain API request with cURL, JavaScript or Python in under five minutes. Read](https://docs.crius.sh/quickstart/)