Free Robinhood Chain API: What Can You Build Without Paying?

Yes, there is a free Robinhood Chain API: Crius serves prices, token profiles, pools, trades, OHLCV candles, token lists, search, chain stats and basic security checks with no API key at 2 requests per second, and a free account adds 1,000,000 credits a month, 10 requests per second, holders, launch data and one real-time WebSocket. That is enough for a price ticker, a new-launch radar and a whale-alert bot, all built below with tested code.

This post lists exactly what is free, what each call costs, and how far a free budget goes, then builds three small projects end to end. Every number comes from the live API in October 2026.

What’s free, exactly

There are two free tiers: no key at all, and the free plan (sign up with an email, no card).

Which endpoints each tier can call, and what they cost (from the plans and limits reference):

Two details make the free tiers more useful than they look. First, history is not cut off: a no-key trades call can walk a token back to its first block. Second, batch endpoints count as one call: one /prices request prices up to 100 tokens for 1 credit.

Every response tells you where you stand:

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

Over the limit, you get 429 with a Retry-After header. Handle that and you can run indefinitely on the free tiers.

Project 1: a live price ticker (no key)

A terminal ticker for a handful of tokens: one batch request every 5 seconds. TSLA here is Tesla’s tokenized stock on Robinhood Chain, priced from on-chain pools only.

// Live price ticker: three tokens, one request every 5 seconds (no API key needed).
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 console.log("rate limited, retry in", res.headers.get("retry-after"), "s");
  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 ?? 0).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 (Node.js 20+, no packages):

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%)
block 96714705 (3 ms behind)   TSLA $371.633 (-0.97%)  WETH $2366.55 (-1.06%)  CHARGE $0.00000550206 (9.22%)

Budget. One call every 5 seconds is 0.2 requests per second, a tenth of the no-key limit. Add up to 100 tokens before it costs anything more. If you later move it onto a free key, it uses about 518,000 credits a month (17,280 calls a day), half the free quota, leaving room for the other two projects. Each price also comes with liquidity_usd and a confidence field, so you can hide prices from pools too thin to trust (token price API).

Extend it: swap /prices for /token/{address}/candles?interval=1m and draw a sparkline, or follow the chart example for a full TradingView chart.

Project 2: a launch radar with risk checks (no key)

On a typical day, launchpads on Robinhood Chain create about 2,650 tokens (in our last 24-hour window: 1,345 on Pons, 1,272 on Flap.sh, 35 on Bankr). This script watches the new-token list and runs a quick security check on each launchpad token, still without a key:

"""Launch radar: new Robinhood Chain tokens with a quick risk check. Runs without an API key."""
import time

import requests

API = "https://api.crius.sh/v1/robinhood"
s = requests.Session()


def get(path, **params):
    while True:
        r = s.get(f"{API}{path}", params=params, timeout=15)
        if r.status_code == 429:  # no-key limit: 2 requests per second
            time.sleep(int(r.headers.get("retry-after", "1")))
            continue
        r.raise_for_status()
        return r.json()


since = int(time.time() * 1000) - 15 * 60_000
while True:
    for t in sorted(get("/tokens", list="new", created_after_ts=since, limit=20)["data"], key=lambda t: t["created_ts"]):
        since = max(since, t["created_ts"])
        if not t["launchpad_name"]:
            continue  # only launchpad tokens
        sec = get(f"/token/{t['address']}/security")["data"]
        tax = sec["tax"]
        print(f'{t["symbol"]:<12} {t["launchpad_name"]:<8} risk={sec["risk"]:<6} score={sec["score"]:<3} '
              f'tax buy/sell={tax["buy_pct"]}/{tax["sell_pct"]}  honeypot={sec["honeypot"]["is_honeypot"]}  {t["address"]}')
        time.sleep(0.5)
    time.sleep(10)

SPACEX       Flap.sh  risk=low    score=85  tax buy/sell=0/None     honeypot=False  0xfbc6e28eba2d6f8b4273919835ac67de24c97777
OMILHOOD     Pons     risk=low    score=95  tax buy/sell=None/None  honeypot=False  0x76de572be4ca150537c4e1d70a45d5038660026e
HOODLOX      Pons     risk=low    score=95  tax buy/sell=0/0        honeypot=False  0xdb5ab2cc47e0c0b06f4c4e4dc13046926ab5d5ef
XTEN         Pons     risk=low    score=95  tax buy/sell=0/0        honeypot=False  0x580f91ba91769d92b69f31461d282ac8019a384b

A None tax means the token hasn’t traded enough yet to measure; the check reports realized tax from real trades, so it fills in as people buy and sell. The full security response also covers contract permissions (mintable, pausable, blacklist, upgradeable), LP lock status and, for Uniswap v4 tokens, what the pool’s hook is allowed to do. The token security API page explains the checks, and honeypot and tax detection explains how they work.

Budget. The list call every 10 seconds plus one security check per launchpad token is about 11,300 calls a day. That’s comfortably inside the no-key rate, or about 340,000 credits a month on a free key.

Extend it: with a free key, add /token/{address}/launch to show bonding-curve progress, or subscribe to launches:all and graduations:all on the stream instead of polling. The launchpad API covers Pons, Flap.sh, Bankr, Long.xyz and King of the Markets.

Project 3: whale alerts over WebSocket (free key)

Polling misses things and wastes calls. With a free key you get one WebSocket connection with up to 10 subscriptions, and messages aren’t metered: opening the connection costs 1 credit. This bot streams every trade of a token and prints the large ones:

// Whale alerts: stream every trade of a token and print the big ones (free API key, one WebSocket).
const TOKEN = "0x322f0929c4625ed5bad873c95208d54e1c003b2d"; // TSLA (tokenized stock)
const MIN_USD = Number(process.env.MIN_USD ?? 1000);
const url = `wss://api.crius.sh/v1/robinhood/stream?api_key=${process.env.CRIUS_API_KEY}`;

function connect() {
  const ws = new WebSocket(url); // Node 22+ ships a WebSocket client
  ws.onopen = () => ws.send(JSON.stringify({ op: "subscribe", channels: [`trades:${TOKEN}`] }));
  ws.onmessage = (ev) => {
    const msg = JSON.parse(ev.data);
    if (!msg.ch?.startsWith("trades:")) return; // hello, subscribed, heartbeat, finality
    const t = msg.data;
    if (t.value_usd >= MIN_USD) {
      console.log(`${t.type.toUpperCase().padEnd(4)} $${t.value_usd.toFixed(0).padStart(7)} @ $${t.price_usd} by ${t.trader} (block ${t.block})`);
    }
  };
  ws.onclose = () => setTimeout(connect, 2000); // reconnect; resume replays missed messages
}
connect();

On connect, the server sends hello (with your subscription limit), confirms with subscribed, sends a heartbeat every 15 seconds and then one message per trade:

{
  "ch": "trades:0xe01ada02fb4d1951cdb8cbb761d509db2ff02c94",
  "seq": 1673,
  "block": 96726525,
  "data": {
    "id": "96726525-1-2",
    "type": "buy",
    "symbol": "UHI",
    "dex": "uniswap_v4",
    "amount_base": 990.3484599344802,
    "amount_quote": 0.01,
    "price_usd": 0.0238883,
    "value_usd": 23.6577,
    "trader": "0x970dd206e4ae0839389d37154c9489fd85b8f35c",
    "signer": "0x970dd206e4ae0839389d37154c9489fd85b8f35c",
    "tax_pct": 0,
    "ts": 1792840961000
  }
}

seq numbers messages per channel, which is what resume uses after a reconnect. Each trade’s trader is the attributed wallet, so a whale buying through an aggregator shows up as the whale, not the aggregator. To watch more tokens, add up to 10 channels to the same subscribe message; to watch a wallet across all tokens, subscribe to wallet:<address>. The WebSocket API page lists every channel, and building a trading bot with WebSocket streams covers resume and reorg handling.

Budget. One connection, about 30 credits a month if it reconnects daily.

How far does the free plan go?

All three projects together, on one free key:

That leaves about 140,000 credits for ad-hoc queries. Ways to stretch it further:

• Batch. /prices and /tokens/batch take 100 tokens per call.
• Stream instead of polling. One WebSocket replaces thousands of polls.
• Cache by block. Every response has meta.block; if it hasn’t changed, neither has the answer.

The dashboard shows usage per day and per endpoint, and you get an email at 50%, 80%, 90% and 100% of your monthly credits.

When free stops being enough

You’ll want a paid plan when you need:

• Wallet analytics: profiles, PnL and full wallet trade histories (wallet analytics API);
• Forensics: bundles, sniper detection, connected wallets and bubble maps;
• Fresh simulations: an on-demand buy, transfer and sell through the real pool;
• More throughput: more than 10 requests per second or more WebSocket connections.

Starter is $19/month (10M credits, 25 requests/s, 3 WebSockets) and Pro $79/month (50M credits, 75 requests/s, 10 WebSockets), with 10% off for 6 months and 20% off for 12, paid on-chain in USDG, ETH or WETH (pricing).

FAQ

Is there really a free Robinhood Chain API with no signup? Yes. Core endpoints, including prices, token profiles, pools, trades, candles, token lists, search, stats and cached security checks, work without a key at 2 requests per second per IP.

Does the free tier limit history? No. Trades, candles and (with a free key) holder snapshots go back to each token’s first block.

Can I use the free plan commercially? The free plan has the same terms as paid plans; only the limits differ. See the terms for details.

What happens when I run out of credits? Requests return 429 quota_exceeded until the next UTC month or until you upgrade. No-key requests are never metered, only rate-limited.

Is the free API fast enough for a trading bot? For alerts and research, yes: data is typically tens of milliseconds behind the chain head, and the free WebSocket pushes trades as blocks are decoded. For high-frequency strategies across many tokens, you’ll want more connections and requests per second.

Get started

Try every no-key call in the API playground, read the quickstart, or create a free key for holders and streaming. For the bigger picture, see the complete Robinhood Chain API guide and our comparison of Robinhood Chain data APIs.