Robinhood Chain RPC URL: mainnet and testnet

Building on testnet? Start with the testnet starter or get test ETH from the faucet.

Robinhood Chain mainnet uses chain ID 4663, and its keyless public RPC URL is https://api.blockvectra.com/v1/robinhood_mainnet/public (3 requests per second per IP). The testnet uses chain ID 46630. Developers and AI agents use the same endpoints; Public methods are limited by public.methods; anonymous eth_getLogs is available only where listed and subject to public.logs. Check each network separately. WebSocket and the Data API need a key.

Choose an RPC provider.

The RPC endpoints in this guide are provided by BlockVectra; Robinhood's own public RPC endpoints and network parameters are listed in its official connection documentation.

curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/public" -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

Checked 2026-11-12. Public endpoints serve HTTP JSON-RPC reads without an API key; the testnet endpoint is https://api.blockvectra.com/v1/robinhood_testnet/public. Keep mainnet and testnet requests separate.

• First step: Read mainnet without a key with the three commands, or connect with viem or ethers if you want to save network.mjs and a client example first.
• Done when: The TypeScript keyless read confirms mainnet chain ID 4663 and prints the latest block number; the Python example confirms chain identity with chain ID 4663. A custom client confirms that the RPC chain ID matches the catalog's chain_id and prints the latest block number without an RPC chain ID mismatch error.

Mainnet parameters and access options.

Read mainnet without a key

For a ready-to-run TypeScript example, use the BlockVectra agent-quickstart repository. With Node.js 22 (>=22.18) or Node.js >=24.12, and Git, run the native TypeScript entry without installing dependencies. It reads Robinhood mainnet by default: it reads the chain directory, confirms chain ID 4663, then reads the latest block number. That command makes at most 3 HTTP requests, including 2 JSON-RPC calls, and needs no wallet, sign-up or API key.

git clone https://github.com/blockvectra/agent-quickstart.git
cd agent-quickstart
node src/public-read-cli.ts

For other Node.js versions (Node.js >=18), run these commands from the cloned repository:

npm ci --ignore-scripts
npm run read:public

Done when the output shows chain ID 4663 and the latest mainnet block number. The repository's npm start is a separate full sign-up flow, not part of this keyless read.

For a Python 3.10+ alternative, run this from the cloned repository. It uses only the standard library, needs no packages, and succeeds by confirming chain ID 4663; it does not read a block height. It makes at most 2 HTTP requests, including 1 RPC call.

python3 examples/public_chain.py

For your own viem or ethers client, the section below still works. It starts on testnet by default; set BLOCKVECTRA_CHAIN=robinhood_mainnet to read mainnet.

Tasks this guide helps you complete

• Probe Robinhood Chain RPC with a public read using viem or ethers, then use a key for authenticated methods.
• Check the testnet RPC connection by reading eth_chainId before running testnet operations.
• Query tokenized stock activity with the mainnet Data API after checking dataset support; the metrics describe on-chain activity, not stock prices.

BlockVectra MCP or Robinhood Trading MCP

Use the BlockVectra MCP server when an agent needs on-chain RPC calls or Data API results for Robinhood Chain. Use Robinhood's official Trading MCP, set up through its onboarding guide, when an agent needs to work with brokerage accounts, holdings or orders.

A BlockVectra service account authenticates requests to BlockVectra's RPC and data endpoints. A Robinhood brokerage account is a separate account held at Robinhood. Robinhood Chain does not connect to it, and a BlockVectra service account does not give access to it.

RPC and WebSocket access

• Public RPC URL: Find the no-key endpoint, supported public methods, and rate limits on the Robinhood Chain mainnet page or testnet page.
• JSON-RPC with an API key: Use the endpoints and curl examples below. For logs, see the eth_getLogs method reference and block range limit guide.
• WebSocket with an API key: Use the WebSocket endpoints below and follow the WebSocket subscriptions guide for newHeads and logs. Public RPC access is HTTP JSON-RPC; WebSocket connections require a key.

Network information and endpoints

Every request to Robinhood Chain identifies its target network explicitly in the URL path using the slug robinhood_mainnet. JSON-RPC supports both path-based key authentication and request header authentication (x-api-key), while the Data API serves REST endpoints under /v1/data/robinhood_mainnet/.

The parameters and endpoints below reflect active network parameters:

Connect with viem or ethers

Developers and AI Agents can use the same server-side settings. Use Node.js 24 or later, viem 2 or ethers 6, and start with public reads. Set BLOCKVECTRA_API_KEY securely in the environment for keyed methods and WebSocket. Keep keys and RPC URLs containing keys out of browser code, logs and version control.

Save this as network.mjs. Start on testnet; set BLOCKVECTRA_CHAIN=robinhood_mainnet to move to mainnet. It reads chain_id and method policy from GET /v1/chains. For keyless reads, use the catalog’s public.url and only methods listed in public.methods; public HTTP availability does not imply WebSocket access.

const chainSlug = process.env.BLOCKVECTRA_CHAIN ?? 'robinhood_testnet';
const key = process.env.BLOCKVECTRA_API_KEY;
const catalogUrl = 'https://api.blockvectra.com/v1/chains';
const response = await fetch(catalogUrl, { signal: AbortSignal.timeout(15_000) });
if (!response.ok) throw new Error(`Chains HTTP ${response.status}`);
const catalog = await response.json();
export const chainInfo = catalog.chains.find(item => item.chain === chainSlug);
if (!chainInfo || !Number.isSafeInteger(chainInfo.chain_id) || chainInfo.chain_id <= 0) {
  throw new Error('Missing chain or chain_id');
}
export function allows(method) {
  const matches = pattern => pattern.endsWith('*')
    ? method.startsWith(pattern.slice(0, -1)) : pattern === method;
  if (!key) return (chainInfo.public?.methods ?? []).some(matches);
  return (chainInfo.methods?.allow ?? []).some(matches)
    && !(chainInfo.methods?.deny ?? []).some(matches);
}
if (!allows('eth_chainId')) throw new Error('eth_chainId is unavailable');
export const rpcUrl = key
  ? new URL(`./${chainSlug}/${encodeURIComponent(key)}`, catalogUrl).href
  : chainInfo.public?.url;
if (!rpcUrl) throw new Error('Public RPC is unavailable; set BLOCKVECTRA_API_KEY');

Save as viem-client.mjs, install with npm install viem@2, then run node viem-client.mjs.

import { createPublicClient, defineChain, http } from 'viem';
import { chainInfo, rpcUrl } from './network.mjs';

export const chain = defineChain({
  id: chainInfo.chain_id,
  name: chainInfo.name,
  nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
  rpcUrls: { default: { http: [rpcUrl] } },
});
export const client = createPublicClient({ chain, transport: http(rpcUrl) });
if (await client.getChainId() !== chain.id) throw new Error('RPC chain ID mismatch');
console.log(await client.getBlockNumber());

To read mainnet with this client:

BLOCKVECTRA_CHAIN=robinhood_mainnet node viem-client.mjs

For ethers, save as ethers-client.mjs, install with npm install ethers@6, then run node ethers-client.mjs.

import { JsonRpcProvider } from 'ethers';
import { chainInfo, rpcUrl } from './network.mjs';

const provider = new JsonRpcProvider(rpcUrl, chainInfo.chain_id, { batchMaxCount: 1 });
const network = await provider.getNetwork();
if (network.chainId !== BigInt(chainInfo.chain_id)) throw new Error('RPC chain ID mismatch');
console.log(await provider.getBlockNumber());
provider.destroy();

To read mainnet with this client:

BLOCKVECTRA_CHAIN=robinhood_mainnet node ethers-client.mjs

Route through eRPC

If you already run eRPC as a local RPC proxy, add BlockVectra as two explicit upstreams. eRPC does not discover these chains on its own, so every upstream below sets its endpoint and chain ID. This file was checked against eRPC 0.5.0 (install that release first); the reference Gist has the files to reproduce it. This needs your own API key; the keyless public endpoint is not a substitute.

Save as erpc.blockvectra.yaml. The key is read from the environment, so it never appears in the file:

logLevel: error
server:
  listenV4: true
  httpHostV4: 127.0.0.1
  httpPortV4: 4000
  listenV6: false
metrics:
  enabled: false
projects:
  - id: blockvectra
    upstreams:
      - id: blockvectra-rh-mainnet
        endpoint: https://api.blockvectra.com/v1/robinhood_mainnet
        evm:
          chainId: 4663
        jsonRpc:
          headers:
            x-api-key: "${BLOCKVECTRA_API_KEY}"
      - id: blockvectra-rh-testnet
        endpoint: https://api.blockvectra.com/v1/robinhood_testnet
        evm:
          chainId: 46630
        jsonRpc:
          headers:
            x-api-key: "${BLOCKVECTRA_API_KEY}"

An unset variable expands to an empty header, so stop before starting if the key is missing, then validate and run:

: "${BLOCKVECTRA_API_KEY:?Set BLOCKVECTRA_API_KEY first}"
erpc --config erpc.blockvectra.yaml --require-config validate
erpc --config erpc.blockvectra.yaml --require-config

The proxy listens on 127.0.0.1:4000 only. From another terminal, read the chain ID through the local route and check that it matches:

curl -s "http://127.0.0.1:4000/blockvectra/evm/4663" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

The result should be the hex form of 4663. For testnet, use /blockvectra/evm/46630 and expect the hex form of 46630.

Notes:

• validate only checks the local file. Methods, log ranges and state history still come from GET /v1/chains.
• On startup eRPC contacts the upstreams for bootstrap and health checks, and those background requests count toward your CU and request budget along with your own calls.
• Do not print the config or request headers in logs; they carry your key.

Deploy with Foundry or Hardhat

Fund the deployer with test ETH via the testnet faucet first; mainnet transactions need mainnet ETH. The official network and deployment guide lists the mainnet and testnet chain IDs (accessed: 2026-10-07). The endpoint tables on this page use /v1/chains.

Export the selected URL and chain ID from network.mjs. Check eth_sendRawTransaction against methods.allow and methods.deny before broadcasting.

export RPC_URL="$(node --input-type=module -e "import { rpcUrl, allows } from './network.mjs'; if (!allows('eth_sendRawTransaction')) throw new Error('Broadcast unavailable'); console.log(rpcUrl)")"
export CHAIN_ID="$(node --input-type=module -e "import { chainInfo } from './network.mjs'; console.log(chainInfo.chain_id)")"

Continue with the shared Foundry or Hardhat deployment tutorial for Hello.sol, tool settings, broadcasting and receipt checks.

Listen to contract events over WebSocket

Save as watch-logs.mjs and set LOG_ADDRESS to the deployed contract or token contract you watch. Run node watch-logs.mjs. The code checks ws and subscriptions from /v1/chains before subscribing to logs.

import { createPublicClient, webSocket, isAddress } from 'viem';
import { chain } from './viem-client.mjs';
import { chainInfo, rpcUrl } from './network.mjs';

if (!process.env.BLOCKVECTRA_API_KEY) throw new Error('WebSocket requires BLOCKVECTRA_API_KEY');
const address = process.env.LOG_ADDRESS;
if (!chainInfo.ws || !chainInfo.subscriptions?.includes('logs')) {
  throw new Error('WebSocket logs are unavailable; use HTTP backfill or webhook push');
}
if (!address || !isAddress(address)) throw new Error('Set LOG_ADDRESS');
const wsUrl = new URL(rpcUrl);
wsUrl.protocol = 'wss:';
const client = createPublicClient({ chain, transport: webSocket(wsUrl.href) });
const unwatch = client.watchEvent({
  address, poll: false,
  onLogs: logs => console.log(logs),
  onError: error => console.error(error),
});
process.once('SIGINT', () => { unwatch(); process.exit(0); });

After the listener starts, send a ping() transaction from another terminal using the same exported deployment variables:

cast send "$CONTRACT_ADDRESS" "ping()" --rpc-url "$RPC_URL" \
  --private-key "$DEPLOYER_PRIVATE_KEY"

Persist the last processed block and deduplicate by (blockHash, transactionHash, logIndex). After reconnecting, backfill missed blocks with bounded eth_getLogs requests; reconcile logs marked removed on a reorg. See WebSocket subscriptions and block range limits.

For address events delivered to your HTTPS receiver, GET /v1/push/chains lists supported chains and confirmation settings; use an x-api-key header. Follow the webhook push guide for subscriptions, signature verification, deduplication and replay. For mainnet stock-token activity queries, continue with the stocks guide.

Direct curl examples

You can make JSON-RPC calls immediately using standard HTTP clients. Replace {api_key} with your BlockVectra API key:

curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H "Content-Type: application/json" \
  -H "x-api-key: {api_key}" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

Response structure

Responses follow the JSON-RPC 2.0 specification:

• Success: Returns an envelope with jsonrpc: "2.0", the same id, and a result string containing the hexadecimal-encoded quantity (eth_chainId returns the hex-encoded chain ID; eth_blockNumber returns the latest block height).
• Disallowed methods: Requesting a method outside the network's allowed methods returns JSON-RPC error code -32601 (method not available, not billed).
• Out-of-window queries: Historical state requests earlier than the state retention window return JSON-RPC error code -32011 (not billed).
• Invalid parameters: Malformed or unallowed request parameters return JSON-RPC error code -32602 (not billed).

Capability and method policy

Available JSON-RPC methods, log block range limits, and historical state retention on Robinhood Chain are published dynamically via GET /v1/chains. Execution tracing (debug_trace*, including debug_traceTransaction) is governed by the chain's method policy:

Testnet

To obtain test ETH for transactions, see the Robinhood Chain testnet faucet guide.

Robinhood Chain Testnet (chain ID: 46630) uses the same API key as mainnet at endpoint https://api.blockvectra.com/v1/robinhood_testnet, authenticated via the x-api-key request header.

Testnet requests use the same CU weights as mainnet and draw from the same balance and free credits. Available JSON-RPC methods and historical state retention on Robinhood Chain Testnet are published dynamically via GET /v1/chains.

For a runnable three-step starter that reads the testnet without a key, streams logs over WebSocket, and then moves the same key to mainnet, see the Robinhood Chain Testnet starter guide.

curl -s "https://api.blockvectra.com/v1/robinhood_testnet" \
  -H "Content-Type: application/json" \
  -H "x-api-key: {api_key}" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

Expected response:

{"jsonrpc":"2.0","id":1,"result":"0xb626"}

Tokenized stock data

On Robinhood Chain, the BlockVectra Data API provides daily on-chain metrics and metadata for tokenized stocks across two endpoints:

• Daily leaderboard (GET /v1/data/robinhood_mainnet/stocks): Daily activity leaderboard of tokenized stocks for a specified UTC date, ordered by transfer activity descending.
• Get one tokenized stock (GET /v1/data/robinhood_mainnet/stocks/{token}): Token contract metadata and up to 30 days of recent daily metrics by token address.

For detailed request parameters, response envelopes (StockDailyListEnvelope and StockTokenEnvelope), pagination notes, and CU consumption estimates, see the Tokenized stocks guide.

Complete starter template: blockvectra/robinhood-stock-tokens

Getting started and API keys

You can try the keyless public endpoint https://api.blockvectra.com/v1/robinhood_mainnet/public first (wallet JSON-RPC methods only, Data API requires a key; methods and limits are subject to /v1/chains); sign up for an account if you need a higher rate limit.

• Web console: Sign up via Ethereum wallet signature, and generate an API key in the Console. See the Quickstart guide for setup details.
• Programmatic sign-up: Autonomous AI agents, automated scripts, and CI pipelines can sign in and provision API keys using Ethereum wallet signatures (EIP-191) without a browser. Follow the Programmatic sign-up guide.
• AI agents: Autonomous AI agents can discover Robinhood Chain capabilities using the BlockVectra Model Context Protocol (MCP) server. See Connecting AI Agents to BlockVectra.
• Upgrading limits: After topping up, the account-wide calls-per-second limit is removed; each key remains subject to Compute Unit (CU) rate and burst limits. For current rates and billing units, see the Pricing page.

Next steps

• Browse the datasets directory to see every dataset BlockVectra indexes.
• See the free plan and pricing to check what your account includes.
• Log in to the console to create an API key.