Skip to content

Robinhood Chain RPC & WebSocket

Read chain state, send signed transactions and follow onchain events.

[ START IN PORTAL ]Explore the interface

A backend for your EVM application.

Use standard Ethereum JSON-RPC and WebSocket with your existing backend stack. Connect contract integrations, event listeners and transaction submission, or inspect recent execution.

Arbitrum L2Chain ID 4663ETH for gasUS East (New York)

A fit for backend applicationsContract integrations, event listeners, transaction submission and recent execution debugging.

Need decoded analytics?Explore the Robinhood Indexer for decoded SQL datasets. Confirm your history and access requirements with the team.

Request state. Follow changes.

HTTPS JSON-RPC

Request balances, contract calls, transactions, blocks and debug traces. Your application signs transactions; the node holds no keys.

WebSocket

Subscribe to newHeads and filtered logs without repeatedly polling for events. WebSocket also accepts regular JSON-RPC calls.

One backend subscription covers both transports. Send the same x-token header with HTTPS requests and in the WSS handshake.

Methods for your backend.

HTTPS handles requests; WSS adds live subscriptions. Filter logs by address and topics, and check the retained state before requesting historical traces.

TaskIncluded interfaceKeep in mind
Read & sendeth_call, balances, blocks, receipts, fee estimates and eth_sendRawTransactionSign transactions in your own application. The node holds no keys.
Subscribe to eventseth_subscribe: newHeads and logsFilter logs by address and topics. Subscriptions require WSS.
Inspect executiondebug_traceTransaction, debug_traceCall, block traces; callTracer and prestateTracerHistorical traces require state within the retention window.
Retrieve raw historyBlocks, transactions, receipts and logs since genesisHistorical state and traces reach back about five days.

Full chain records. A recent state window.

Blocks, transactions, receipts & logs

GENESISLATEST

Retrieve blocks, transactions, receipts and event logs from the first block onward.

Past state & historical traces

OLDER STATE~5 DAYS

eth_call, eth_getBalance, eth_getStorageAt and historical traces reach back about five days. Older state can return a pruning error.

This is a full node. Confirm historical-state requirements before subscribing. For decoded historical activity, explore the Robinhood Indexer.

Price & access.

Robinhood Chain

RPC & WebSocket

One backend subscription

One token for HTTPS JSON-RPC and WebSocket subscriptions.

  • Blocks, transactions, receipts and logs since genesis
  • Recent state and historical debug tracing: about 5 days
  • Throughput and capacity set per subscription
  • Crypto-only, monthly and prepaid
$389
/ month

Free trial up to 24 hours on request, no card. Our team confirms availability and provisions access after your request in the portal.

[ START IN PORTAL ]Documentation

Full Robinhood pricing ↗. Confirm throughput, history requirements and subscription setup with the team before connecting.

Connect from your backend.

Open the Supanode portal and request access. The team confirms your workload and supplies the token.

  1. Open the Supanode portalSign in with a Solana wallet and request Robinhood Chain RPC & WebSocket access.
  2. Confirm your workloadAgree throughput, history requirements and the subscription setup with the team.
  3. Connect with your tokenUse x-token on HTTPS and WSS from your backend.

Send x-token with every HTTPS request and in the WebSocket handshake. The same token covers both endpoints. Keep the required port in each URL.

Your applicationBackend client / server
x-token headerSupanode authentication
Robinhood Chain nodeHTTPS 8545 / WSS 8546
HTTPS JSON-RPChttps://ny01.rh.supanode.xyz:8545
WEBSOCKETwss://ny01.rh.supanode.xyz:8546

Backend only: browsers cannot add x-token to a native WebSocket handshake, and the HTTPS endpoint does not answer CORS preflight requests. Keep credentials on your server and connect your frontend through it.

Illustrative request · curl
curl -s https://ny01.rh.supanode.xyz:8545 \
  -H "x-token: YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
Illustrative response{"jsonrpc":"2.0","id":1,"result":"0x1237"}0x1237 = chain ID 4663

Authenticate with x-token.

URL tokens, Authorization: Bearer and x-api-key are not supported. HTTPS also requires Content-Type: application/json.

401
Missing x-token. Add the header; other auth formats do not substitute for it.
403
Invalid x-token. Check the token supplied for your subscription.
415
Missing or incorrect content type. Send application/json.
Up to 1,000 calls / batch

Batch size is a hard limit. Throughput is set per subscription; confirm capacity with the team.

About 30 seconds / request

Server timeout. Filter log queries and page through 2,000-5,000 block ranges.

Reuse connections

Use HTTP keep-alive and a long-lived WSS connection with reconnect handling.

Client examples: ethers, viem, web3.py & wscat ↗

Before you connect.

Is WebSocket a separate subscription?

The $389/month plan includes HTTPS RPC and WebSocket with one token.

Will ethers, viem or web3.py work?

Yes, from your backend with the required headers. HTTPS examples are available for all three. For WSS, use a client that supports handshake headers. The documented viem WebSocket transport needs an additional Node-side workaround.

Can I read state at any historical block?

Blocks, transactions, receipts and logs go back to genesis. Historical state and traces reach back about five days; check that window against your use case.

Can I subscribe to pending transactions?

Use newHeads and logs subscriptions for live chain events. The documented newPendingTransactions subscription returns an ID but stays silent.

Are trace_* methods supported?

Use the documented debug_trace* methods. The endpoint does not support trace_*, arbtrace_*, txpool_* or admin_*. Check the full method reference.

How is throughput set?

Throughput is set per subscription. Confirm your workload and limits with the team before connecting, and keep requests within the batch and timeout limits.