Robinhood Chain API: The Complete Developer Guide for 2026

A Robinhood Chain API gives you indexed, decoded on-chain data (token prices, candles, trades, holders, pools and launches) over plain HTTP and WebSocket, so you don’t have to run an archive node or write your own indexer. The Crius API covers the whole chain from block 0, serves most requests in tens of milliseconds behind the chain head, and lets you call its core endpoints without a key.

This guide covers what Robinhood Chain data looks like, which endpoint answers which question, how authentication, limits and pagination work, and how to stream data in real time. Every code sample was run against the live API while writing (October 2026), and the responses shown are real, trimmed for length.

What is Robinhood Chain, from a data point of view?

Robinhood Chain (chain id 4663) is an Ethereum Layer 2 built on Arbitrum’s Orbit stack (now called Arbitrum Dedicated Blockchains). It uses ETH for gas and orders transactions first-come, first-served at the sequencer. For anyone building on its data, a few numbers matter more than the architecture. At time of writing, over a 24-hour window:

That is roughly ten blocks a second, every second. A dashboard that polls a public RPC node and decodes logs in the browser will fall behind within minutes, which is why most production apps on the chain read from an indexed data API instead. The comparison of REST API vs RPC vs indexed data goes deeper into that choice.

Three properties of the chain shape what a good API has to get right:

• Three generations of Uniswap at once. Liquidity sits in Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 pools, which all live inside one singleton contract and can attach hooks. Uniswap v4 alone handled about $287 million of the 24-hour volume above. A token’s price has to come from the right pool, using only in-range liquidity for v3 and v4. See Uniswap v4 on Robinhood Chain.
• Launchpad tokens change venue. Tokens launched on Pons, Flap.sh, Bankr and other launchpads first trade on a bonding curve, then graduate into a Uniswap pool. Charts and stats should follow a token across that move. See the launchpad API.
• The transaction sender is often not the trader. Routers, aggregators, Relay solvers, ERC-4337 bundlers and bot contracts sit between users and pools. Counting tx.from as the trader makes holder and trader statistics wrong; the API attributes every swap to the wallet that actually received or paid the tokens (how attribution works).

The Crius Robinhood Chain API at a glance

The base URL is https://api.crius.sh/v1/robinhood. Every endpoint returns JSON in the same envelope: a data field with the answer and a meta field that says which block the answer reflects.

The full list, with parameters and example responses, is in the API reference.

Your first request

Prices, profiles, trades and candles work without an API key, at 2 requests per second per IP. This is the fastest call in the API:

curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price"

{
  "data": {
    "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8",
    "symbol": "CHARGE",
    "usd": 5.50044e-06,
    "eth": 2.32493e-09,
    "dex": "uniswap_v4",
    "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913",
    "liquidity_usd": 6679.58,
    "confidence": "medium",
    "thin_liquidity": false
  },
  "meta": {
    "block": 96713051,
    "lag_ms": 2,
    "safe_block": 96707359,
    "finalized_block": 96703786
  }
}

Two fields are worth noticing. confidence and thin_liquidity tell you how far to trust the price: a price from a pool with $40 of liquidity is technically correct and practically useless. And meta.lag_ms tells you how far behind the chain head the answer is, here 2 milliseconds.

Authentication and limits

For holders, launches, security checks and streaming, create a free account at dashboard.crius.sh and send the key in the x-api-key header:

export CRIUS_API_KEY="crs_live_…"
curl -H "x-api-key: $CRIUS_API_KEY" \
  "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=10"

Each call costs credits: 1 for most core calls, 2 for trades and candles, 5–10 for heavier analytics. Every response tells you where you stand:

x-ratelimit-limit: 2
x-ratelimit-remaining: 3
x-credits-cost: 1

When you go over the rate limit, the API answers 429 with a Retry-After header, so a client only needs a sleep-and-retry loop. Details are on the plans and limits page; what the free tier is good for is covered in Free Robinhood Chain API: what can you build without paying?.

Prices for a whole portfolio in one call

/prices takes up to 100 tokens and returns a map keyed by address. This Node.js script (Node 20+, no dependencies) prints a live ticker without a key:

const API = "https://api.crius.sh/v1/robinhood";
const TOKENS = {
  TSLA: "0x322f0929c4625ed5bad873c95208d54e1c003b2d",
  WETH: "0x0bd7d308f8e1639fab988df18a8011f41eacad73",
  CHARGE: "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8",
};

async function tick() {
  const res = await fetch(`${API}/prices?tokens=${Object.values(TOKENS).join(",")}`);
  if (res.status === 429) return; // try again on the next tick
  const { data, meta } = await res.json(); // data is keyed by token address
  const line = Object.entries(TOKENS)
    .map(([sym, addr]) => `${sym} $${Number(data[addr].usd).toPrecision(6)} (${data[addr].change_24h_pct.toFixed(2)}%)`)
    .join("  ");
  console.log(`block ${meta.block} (${meta.lag_ms} ms behind)  ${line}`);
}

await tick();
setInterval(tick, 5000);

Output while writing this guide:

block 96714600 (19 ms behind)  TSLA $371.633 (-0.97%)  WETH $2366.55 (-0.92%)  CHARGE $0.00000550206 (9.22%)
block 96714656 (5 ms behind)   TSLA $371.633 (-0.97%)  WETH $2366.55 (-1.05%)  CHARGE $0.00000550206 (9.22%)

TSLA here is Tesla’s tokenized stock, priced from on-chain pools only. More on price sources in real-time token prices on Robinhood Chain and on the token price API page.

OHLCV candles for charts

Candles come back as columnar arrays, which map directly onto charting libraries:

curl "https://api.crius.sh/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/candles?interval=15m&limit=96&fill=true"

{
  "data": {
    "interval": "15m",
    "currency": "usd",
    "t": [1792754100000, 1792755000000, "…"],
    "o": [375.633, 375.141, "…"],
    "h": [377.607, 377.268, "…"],
    "l": [374.988, 374.824, "…"],
    "c": [375.141, 375.999, "…"],
    "v": [3395.45, 14939.8, "…"]
  }
}

Intervals run from 1s to 1d. By default, USD candles merge every real market of the token (pools with at least $1,000 or 2% of its liquidity), so one thin side pool can’t draw a fake wick, and launchpad tokens include their bonding-curve period. fill=true adds flat candles for minutes with no trades so the time axis is even. The OHLCV candles API page and the live chart example show a full TradingView integration.

Trades and pagination

The trade tape returns up to 500 trades per page, newest first, with a cursor for the next page. In Python:

import requests

API = "https://api.crius.sh/v1/robinhood"
token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"

cursor, rows = None, []
while True:
    params = {"limit": 500, **({"cursor": cursor} if cursor else {})}
    body = requests.get(f"{API}/token/{token}/trades", params=params, timeout=30).json()
    rows += body["data"]
    cursor = body["meta"].get("next_cursor")
    if not cursor:
        break
print(len(rows), "trades")

Run without a key, this walked the full history of CHARGE (5,104 trades since launch) in about 21 seconds. Each trade carries the attributed trader, the transaction signer, USD and ETH value at trade time, gas, realized token tax and its finality. Filters (side, trader, min_usd, from_ts, to_ts) narrow the walk. For bulk exports across tokens and wallets, see how to get all Robinhood Chain transactions without running a node and the DEX trades API.

Holders, liquidity and safety

With a free key you can answer the questions traders ask before they buy:

• /token/{address}/holders: the live holder list, with pools, lockers, burn addresses and the developer labelled, so “top 10 hold 80%” isn’t inflated by an LP contract. Past holder lists at any block, timestamp or market cap come from /holders/snapshot (token holders API).
• /token/{address}/liquidity: whether the LP is burned, locked (and until when) or held by a wallet (liquidity API).
• /token/{address}/security: buy and sell tax measured from real trades, a simulated buy, transfer and sell, and contract flags (token security API).

Real time without polling

For bots and live dashboards, open one WebSocket and subscribe to channels: trades:<token>, price:<token>, candles:<token>:<interval>, launches:all, graduations:all, pools:new, wallet:<address> and more.

const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${process.env.CRIUS_API_KEY}`);
ws.onopen = () =>
  ws.send(JSON.stringify({ op: "subscribe", channels: ["trades:0x322f0929c4625ed5bad873c95208d54e1c003b2d"] }));
ws.onmessage = (ev) => {
  const msg = JSON.parse(ev.data);
  if (msg.ch?.startsWith("trades:")) console.log(msg.data.type, msg.data.value_usd, msg.data.trader);
};

The server first sends hello (with your subscription limit), then subscribed, a heartbeat every 15 seconds and the events themselves. Each message has a sequence number per channel; after a reconnect, {"op": "resume", "seqs": {"<channel>": <last seq>}} replays what you missed from a 60-second buffer. If a reorg removes blocks, you get a reorg message followed by the removed events marked "removed": true. The WebSocket API page and the streaming reference cover the protocol.

Freshness and finality

Every response’s meta block reports three heights:

• block: the latest block the answer includes (soft-confirmed by the sequencer);
• safe_block: blocks whose batch is posted to Ethereum and safe there;
• finalized_block: blocks whose batch is in a finalized Ethereum block.

At time of writing, safe_block trailed the head by about 5,400 blocks (around 9 minutes) and finalized_block by about 9,000 (around 16 minutes). For a chart, use the latest data. For payouts, accounting or anything that moves money, read the finality field on trades and wait for safe or finalized. Background in finality and reorgs.

Choosing a Robinhood Chain API

Several providers now cover the chain: node providers for raw RPC, multi-chain indexers and market-data APIs. They differ in what’s decoded, how far back history goes and how they price real-time access. The comparison of Robinhood Chain data APIs lays them side by side, and the Robinhood Chain API page summarizes what Crius covers.

FAQ

Is there a free Robinhood Chain API? Yes. Crius’s core endpoints (prices, token profiles, pools, trades, candles, search, stats) work without a key at 2 requests per second, and a free account adds 1,000,000 credits a month, holders, launches, security checks and one WebSocket connection.

How far back does Robinhood Chain history go? The Crius index covers every block from 0 to the head, so trades, transfers, holders and candles are available from each token’s first block.

How fresh is the data? Blocks are decoded as they arrive. meta.lag_ms on every response shows the delay behind the chain head, typically single-digit to low hundreds of milliseconds.

Do I need to run a node? No. You need a node (or an RPC provider) to send transactions. For reading prices, trades, holders and history, an indexed API is faster and avoids running a multi-terabyte archive node.

Which tokens are covered? Every ERC-20 on the chain: launchpad tokens, tokenized stocks, stablecoins and everything deployed directly, across Uniswap v2, v3 and v4 and launchpad bonding curves.

Next steps

Try any call in the API playground, follow the five-minute quickstart, or create a free API key. Questions go to support@crius.sh.