# Robinhood Chain RPC & WebSocket

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

[\[ START IN PORTAL \]](https://stg.portal.supanode.xyz/)[Explore the interface](https://supanode.xyz/services/robinhood/rpc#fit)

YOUR BACKEND ONE TOKEN

HTTPS JSON-RPC**Request → Response**`eth_call · eth_sendRawTransaction`

WEBSOCKET**Subscribe → Receive**`newHeads · logs`

ROBINHOOD CHAIN NODE

## 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 applications**Contract 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.

| Task | Included interface | Keep in mind |
| --- | --- | --- |
| Read & send | `eth_call`, balances, blocks, receipts, fee estimates and `eth_sendRawTransaction` | Sign transactions in your own application. The node holds no keys. |
| Subscribe to events | `eth_subscribe`: `newHeads` and `logs` | Filter logs by address and topics. Subscriptions require WSS. |
| Inspect execution | `debug_traceTransaction`, `debug_traceCall`, block traces; `callTracer` and `prestateTracer` | Historical traces require state within the retention window. |
| Retrieve raw history | Blocks, transactions, receipts and logs since genesis | Historical 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](https://supanode.xyz/services/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 \]](https://stg.portal.supanode.xyz/)[Documentation](https://supanode.xyz/docs/robinhood/rpc/overview)

[Full Robinhood pricing ↗](https://supanode.xyz/pricing/robinhood). 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 portal**Sign in with a Solana wallet and request Robinhood Chain RPC & WebSocket access.
2.  **Confirm your workload**Agree throughput, history requirements and the subscription setup with the team.
3.  **Connect with your token**Use 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 application**Backend client / server

**x-token header**Supanode authentication

**Robinhood Chain node**HTTPS 8545 / WSS 8546

**HTTPS JSON-RPC**`https://ny01.rh.supanode.xyz:8545`

**WEBSOCKET**`wss://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 · curlCopy request

```
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 ↗](https://supanode.xyz/docs/robinhood/rpc/examples)

## 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](https://supanode.xyz/docs/robinhood/rpc/whats-available).

### 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.

---
Source: https://supanode.xyz/services/robinhood/rpc