Robinhood Chain RPC: Chain ID 4663, eth_getLogs and WebSocket

Robinhood RPC

With Dwellir, you get access to our global Robinhood network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Get your API key

Robinhood RPC plans and rate limits

• Free plan: 20 responses per second, up to 100,000 responses a day.
• Plans: $49/mo, $299/mo, $999/mo with 25M, 150M, and 500M included responses. Overages billed at $5/$3/$2 per million responses respectively.
• Paid rate limits: 100 to 5,000 responses per second (bursts from 500 to 10,000), no daily limit.
• Billing: 1 response = 1 API credit on every shared plan, over HTTPS or WebSocket (WSS) where Robinhood supports it.

Details: Pricing · Rate limits · Authentication · Archive nodes

Robinhood Chain endpoints and chain facts

Every Dwellir endpoint needs an API key. There is no keyless Dwellir endpoint for Robinhood Chain.

The cheapest plan with eth_getLogs and WebSocket is Developer at $49/month. It allows 500 blocks per eth_getLogs request, about 50 seconds of Robinhood Chain blocks. Growth at $299/month raises the range to 10,000 blocks. The Free plan (20 responses per second, 100,000 responses a day) includes HTTPS and WebSocket access but not eth_getLogs. The plans section above lists the remaining limits, and rate limits has the block-range table for every plan.

Provider pricing for Robinhood Chain is compared in best Robinhood Chain RPC providers. For swaps, pool state and Stock Token data, see how to get Robinhood Chain data for DeFi strategies.

Why Build on Robinhood Chain?

Robinhood Chain is an Ethereum-compatible Layer 2 built with Arbitrum Nitro. It is designed for tokenized real-world assets and other onchain financial applications while retaining the standard EVM development model.

Ethereum-Compatible Development

• Standard EVM tooling - Use ethers, viem, web3.js, Hardhat, Foundry, and Solidity without a chain-specific SDK.
• ETH-denominated fees - ETH is the native currency for execution and L1 data costs.
• Arbitrum Nitro - Applications use familiar Ethereum JSON-RPC methods and Nitro's execution model.

Fast Application Feedback

• Sub-second soft confirmations - The sequencer gives applications a fast view of accepted transactions.
• WebSocket subscriptions - Stream new heads and logs instead of polling the HTTPS endpoint.
• Ethereum settlement - L2 activity is ultimately settled through the underlying Arbitrum rollup on Ethereum.

Archive and Debug Access

• Historical state - Query balances, contract state, calls, and logs at earlier block heights.
• Execution traces - Use Nitro's debug_* methods to inspect transaction and block execution.
• Production routing - Use the same authenticated Dwellir endpoint format as other supported EVM networks.

Sequencer feed

Stream ordered Nitro messages through Dwellir's Robinhood sequencer feed. The WebSocket endpoint has a three-day trial and an optional $100 monthly add-on, plus usage.

The feed starts sending messages when you connect. Use a raw WebSocket client and a Nitro payload decoder.

Quick Start with Robinhood Chain

Connect to Robinhood Chain mainnet through Dwellir's archive-enabled HTTPS and WebSocket endpoints:

Robinhood RPC Endpoints

HTTPShttps://api-robinhood-mainnet-archive.n.dwellir.com/<your-api-key>

WSSwss://api-robinhood-mainnet-archive.n.dwellir.com/<your-api-key>

curlJavaScriptPythonGo

curl -sS -X POST https://api-robinhood-mainnet-archive.n.dwellir.com/<your-api-key> \  -H 'Content-Type: application/json' \  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Installation and Setup

Network Specifications

API Reference

The reference covers the Ethereum JSON-RPC and Nitro debug methods enabled on Dwellir's Robinhood Chain deployment. Parity-style trace_* methods are not enabled; use the corresponding debug_trace* methods for execution analysis.

RPC Capabilities and Limitations

Common Integration Patterns

Verify the Network Before Sending Transactions

Check the chain ID when your application starts so a misconfigured provider cannot sign or submit transactions to the wrong network:

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider(
  'https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

const network = await provider.getNetwork();
if (network.chainId !== 4663n) {
  throw new Error(`Expected Robinhood Chain (4663), received ${network.chainId}`);
}

Query Historical State

The archive endpoint accepts fixed block numbers for state reads. This is useful for accounting, indexers, audits, and point-in-time portfolio views:

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider(
  'https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);
const address = '0x0000000000000000000000000000000000000000';
const historicalBlock = 1_000_000;

const [balance, code] = await Promise.all([
  provider.getBalance(address, historicalBlock),
  provider.getCode(address, historicalBlock),
]);

console.log({ balance, code });

For large log ranges, split eth_getLogs queries into bounded block windows and checkpoint the last completed block. This keeps retries small and makes an indexer resumable.

Trace Transaction Execution

Use the debug namespace when you need internal call frames or execution diagnostics:

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider(
  'https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

async function traceTransaction(transactionHash) {
  return provider.send('debug_traceTransaction', [
    transactionHash,
    {
      tracer: 'callTracer',
      tracerConfig: { onlyTopCall: false },
    },
  ]);
}

const trace = await traceTransaction('0xTRANSACTION_HASH');
console.log(trace);

debug_traceBlockByNumber and debug_traceBlockByHash are available for block-level analysis. Trace requests can be computationally expensive, so cache immutable results and avoid tracing the same finalized transaction repeatedly.

Subscribe to New Blocks over WebSocket

Use one long-lived WSS connection for real-time events. The subscription remains attached to that connection until it is closed or explicitly unsubscribed:

import WebSocket from 'ws';

const ws = new WebSocket(
  'wss://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'eth_subscribe',
    params: ['newHeads'],
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data.toString());
  if (message.method === 'eth_subscription') {
    console.log(message.params.result);
  }
});

Pending transactions and the sequencer feed

Robinhood Chain uses Arbitrum Nitro. Dwellir's follower nodes do not expose the sequencer's private transaction queue before ordering.

eth_newPendingTransactionFilter can return a filter ID, and eth_subscribe("newPendingTransactions") can return a subscription ID. Neither provides a public pending transaction feed on this endpoint. Empty results do not mean the chain has stopped processing transactions.

For block and event updates, use eth_subscribe("newHeads") or eth_subscribe("logs"). These report activity after sequencing and execution, before Ethereum settlement.

Robinhood publishes a public Nitro sequencer feed at wss://feed.mainnet.chain.robinhood.com. It streams ordered messages, rather than exposing the private queue before ordering. This is Robinhood's upstream service. It uses the Nitro feed protocol, not JSON-RPC eth_subscribe.

For authenticated access through Dwellir, see the sequencer feed guide. It covers access, usage billing, and a Node.js consumer example.

See Robinhood's public endpoint list and full-node guide. The Nitro whitepaper describes the feed's ordering guarantees.

Keep stateful filters on one backend

Filter IDs belong to the backend that created them. Create, poll, and uninstall a filter over one persistent WebSocket connection.

For HTTP, preserve the DWSESSION cookie between requests. HTTP connection reuse alone does not keep requests on one backend. If the backend changes or a filter expires, recreate the filter. Backfill missed logs with eth_getLogs from the last processed block.

Gas and Finality

Robinhood Chain fees contain an L2 execution component and an L1 data component for publishing transaction data to Ethereum. Both are paid in ETH.

Robinhood Chain uses first-come, first-served transaction ordering. eth_maxPriorityFeePerGas currently returns zero; raising the priority tip does not buy earlier ordering. Gas tracker execution-cost estimates do not include the variable Nitro L1 data fee.

Confirmation Stages

Transaction Submission Checklist

1. Verify the connected chain ID is 4663 (0x1237).
2. Estimate execution gas immediately before signing.
3. Leave enough ETH for both L2 execution and the variable L1 data component.
4. Submit the signed transaction with eth_sendRawTransaction.
5. Treat the sequencer receipt as a soft confirmation and apply the finality threshold appropriate for your application.

Troubleshooting

method not found for trace_*

Robinhood Chain exposes Nitro's debug_* namespace, not the Parity-style trace_* namespace. Use debug_traceTransaction, debug_traceBlockByNumber, or debug_traceBlockByHash.

filter not found after reconnecting

The filter was created on a previous backend connection. Create a new filter and resume from the last block your application persisted. Use a WebSocket subscription when continuous real-time delivery is a better fit.

Chain ID mismatch

Confirm the provider URL points to Robinhood Chain and that eth_chainId returns 0x1237. Do not submit a transaction until the configured chain and wallet network both report Chain ID 4663.

Official Resources

• Robinhood Chain documentation
• Connect to Robinhood Chain
• Gas and fees
• Transaction finality
• Robinhood Chain explorer
• Arbitrum bridge for Robinhood Chain
• Robinhood Chain status