> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chainstack.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Robinhood Chain API reference: Arbitrum Orbit JSON-RPC quickstart

> Use the Robinhood Chain JSON-RPC API on Chainstack to deploy nodes, send transactions, and build on the Arbitrum Orbit L2 for tokenized stocks and real-world assets. Chain ID 4663, ETH gas, full and archive with debug and trace on mainnet and testnet.

The Robinhood Chain API gives developers programmatic access to Robinhood Chain — an Arbitrum Orbit layer-2 built on Ethereum for tokenized stocks and real-world assets (RWAs). It speaks the standard Ethereum JSON-RPC interface, so the accounts, contracts, logs, and transactions you already know from Ethereum work unchanged. Chainstack serves it through a single node endpoint.

## Robinhood Chain API at a glance

| Property             | Value                                                              |
| -------------------- | ------------------------------------------------------------------ |
| Chain                | Robinhood Chain — Arbitrum Orbit layer-2 on Ethereum               |
| Mainnet chain ID     | `4663`                                                             |
| Testnet chain ID     | `46630`                                                            |
| Native gas token     | ETH                                                                |
| Confirmation latency | \~100 ms target via preconfirmations (Arbitrum Nitro)              |
| Execution            | JSON-RPC — `eth`, `net`, `web3`, and `debug` namespaces            |
| Node types           | Global Node and Dedicated Node, in full and archive modes          |
| Debug & trace        | `debug_*` namespace on a paid plan and a Global Node               |
| Real-time data       | WebSocket `eth_subscribe` — newHeads, logs, newPendingTransactions |
| Networks             | Mainnet and Testnet                                                |
| Request units        | 1 RU per full request, 2 RUs per archive request                   |
| Block explorer       | [robinscan.io](https://robinscan.io/)                              |

## What is Robinhood Chain

Robinhood Chain is a layer-2 network built with the Arbitrum platform (Arbitrum Orbit, Nitro client) and launched on mainnet on July 1, 2026. It targets tokenized real-world assets — tokenized U.S. stocks, ETPs, and other regulated financial instruments — with customized infrastructure tuned for the performance, security, and regulatory requirements of financial services.

As an Arbitrum Orbit chain, Robinhood Chain inherits the Ethereum Virtual Machine (EVM) and the Ethereum JSON-RPC specification, and it settles to Ethereum. ETH is the native gas token, so you pay transaction fees in ETH and need no separate chain token to start building. Contract bytecode, tooling, and JSON-RPC calls that target Ethereum or Arbitrum carry over with minimal changes.

## What is the Robinhood Chain API

The Robinhood Chain API lets developers build decentralized applications, analytics tools, wallets, and indexers. To read data from and send transactions to Robinhood Chain, an application connects to a Robinhood Chain node endpoint and calls the JSON-RPC method it needs.

The JSON-RPC specification is a communication protocol that lets you make remote calls and execute them as if they were local — querying balances, blocks, logs, and receipts, calling and deploying smart contracts, and submitting signed transactions. A Chainstack Robinhood Chain node serves execution-layer JSON-RPC over HTTPS, WebSocket subscriptions for real-time data, and the `debug_*` tracing namespace.

## Methods

Robinhood Chain serves the standard Ethereum JSON-RPC namespaces plus Geth-style debug and trace:

| Namespace | Purpose                                                                                                 |
| --------- | ------------------------------------------------------------------------------------------------------- |
| `eth_*`   | Accounts, blocks, logs, gas, contract calls, transactions, and subscriptions                            |
| `net_*`   | Network listening status and peer count                                                                 |
| `web3_*`  | Client version and Keccak-256 hashing                                                                   |
| `debug_*` | Transaction and block tracing — `debug_traceTransaction`, `debug_traceBlockByNumber`, `debug_traceCall` |

<Note>
  Debug and trace methods require a [paid plan](https://chainstack.com/pricing/) and a node deployed as a [Global Node](/docs/global-elastic-node). See [Debug and trace APIs](/docs/debug-and-trace-apis#robinhood-chain) for details.
</Note>

### What you can build

With a Chainstack Robinhood Chain endpoint you can:

* Query chain state — balances, blocks, logs, receipts, storage, and gas — through the standard `eth_*` JSON-RPC interface, compatible with ethers, viem, and web3.py.
* Deploy and call Solidity contracts with Hardhat, Foundry, and Remix, using `eth_call`, `eth_estimateGas`, and `eth_sendRawTransaction`.
* Debug and trace transactions with `debug_traceTransaction`, `debug_traceBlockByNumber`, and `debug_traceCall` on a paid Global Node.
* Stream real-time data over WebSocket with `eth_subscribe` for `newHeads`, `logs`, and `newPendingTransactions`.
* Index historical state at any block height — balances, contract storage, and traces — against an archive node.

## How to start using the Robinhood Chain API

You need access to a Robinhood Chain node endpoint to use the API. Follow these steps to sign up, deploy a node, and find your credentials:

<Steps>
  <Step>
    [Sign up with Chainstack](https://console.chainstack.com/user/account/create).
  </Step>

  <Step>
    [Deploy a node](/docs/manage-your-networks).
  </Step>

  <Step>
    [View node access and credentials](/docs/manage-your-node#view-node-access-and-credentials).
  </Step>
</Steps>

Now you are ready to connect to Robinhood Chain and use the API to build.

## SDKs and tooling

You can call the API directly over HTTP and WebSocket, or use a maintained EVM library:

* JavaScript and TypeScript — [ethers.js](https://github.com/ethers-io/ethers.js) and [viem](https://github.com/wevm/viem).
* Python — [web3.py](https://github.com/ethereum/web3.py).

For smart contract development, point [Foundry](https://github.com/foundry-rs/foundry), [Hardhat](https://github.com/NomicFoundation/hardhat), or Remix at your Chainstack endpoint and set the chain ID. See [Robinhood Chain tooling](/docs/robinhood-tooling) for wallet, IDE, library, and framework setup.

## Networks

Chainstack supports Robinhood Chain mainnet and testnet, with full and archive node modes, WebSocket connections, and debug and trace APIs.

| Feature            | Mainnet | Testnet |
| ------------------ | ------- | ------- |
| Chain ID           | `4663`  | `46630` |
| Full nodes         | Yes     | Yes     |
| Archive nodes      | Yes     | Yes     |
| WebSocket          | Yes     | Yes     |
| Debug & trace APIs | Yes     | Yes     |

<Note>
  A full node keeps recent state — the latest 128 blocks — while an archive node holds all historical state from genesis. Use an archive node for historical balances, contract storage at past blocks, and `debug_*` traces of older transactions. See [Networks](/docs/protocols-networks) for the full deployment matrix.
</Note>

## Frequently asked questions

### What is the Robinhood Chain chain ID?

Robinhood Chain mainnet is chain ID `4663` and the testnet is chain ID `46630`. Set the chain ID in your wallet, SDK, or framework config alongside your Chainstack RPC endpoint.

### What is the native gas token on Robinhood Chain?

ETH. Robinhood Chain is an Arbitrum Orbit layer-2 that uses ETH as its native gas token, so you pay transaction fees in ETH and do not need a separate chain token to get started.

### What is the difference between a full node and an archive node?

A full node keeps recent state — the latest 128 blocks — which covers most live application reads and transaction submission. An archive node retains all historical state from genesis, so you can query balances and contract storage at any past block and trace older transactions. Chainstack offers both modes on Robinhood Chain mainnet and testnet.

### Does Robinhood Chain support debug and trace methods?

Yes. Chainstack Robinhood Chain nodes serve the Geth-style `debug_*` namespace — including `debug_traceTransaction`, `debug_traceBlockByNumber`, and `debug_traceCall` — for transaction tracing and smart contract debugging. Debug and trace require a paid plan and a node deployed as a Global Node. See [Debug and trace APIs](/docs/debug-and-trace-apis#robinhood-chain).

### Which SDKs work with the Robinhood Chain API?

Any standard Ethereum library works against a Chainstack endpoint: ethers.js and viem for JavaScript and TypeScript, and web3.py for Python. For contracts, use Foundry, Hardhat, or Remix. See [Robinhood Chain tooling](/docs/robinhood-tooling).

### How are Robinhood Chain requests priced?

Pricing is 1 request unit (RU) per full request and 2 RUs per archive request. For which EVM methods bill as full versus archive, see [Request units — EVM methods affected by block age](/docs/request-units#evm-methods-affected-by-block-age).

## Related Robinhood Chain resources

* [Robinhood Chain tooling](/docs/robinhood-tooling) — wallets, IDEs, libraries, and frameworks
* [Debug and trace APIs](/docs/debug-and-trace-apis#robinhood-chain) — enabling the `debug_*` namespace
* [Networks](/docs/protocols-networks) — the full protocol and node deployment matrix
* [Request units](/docs/request-units) — how full and archive requests are priced