How to Get All Robinhood Chain Transactions Without Running a Node

To get every Robinhood Chain transaction for a token or a wallet without running a node, page through an indexed API with a cursor: the /trades, /transactions and /wallet/{address}/trades endpoints return decoded, attributed events from block 0, 500 at a time. A complete token history of a few thousand events downloads in under 30 seconds, with no archive node, no log decoding and no reorg handling on your side.

This tutorial shows what “all transactions” means on Robinhood Chain, why doing it from a node is a multi-day, multi-terabyte project, and then gives working scripts for the three common jobs: a token’s full trade history, everything that ever happened to a token, and a wallet’s complete trading history. All scripts were run against the live API in October 2026; the outputs shown are real.

What “all transactions” means here

Robinhood Chain (chain id 4663) produces a block about every 105 ms. At time of writing, a 24-hour window holds about 2.4 million transactions, 1.65 million DEX trades and activity from 185,000 wallets. Nobody needs all of that raw. What people usually mean is one of these:

Why not just use a node?

You can reconstruct all of this from JSON-RPC, and for some teams that is the right call. It helps to know the size of the job first. These are the figures from indexing Robinhood Chain ourselves:

• Storage. A Nitro archive node for the chain used about 2.8 TB of disk at block ~96.7 million. The decoded index built from it (blocks, transfers, trades, pools, holders) is a further 190 GB compressed in ClickHouse: about 12 billion rows, including 1.8 billion token transfers and 450 million trades.
• Backfill time. Fetching every block’s receipts with eth_getBlockReceipts ran at 2,200–2,900 blocks per second with 32 parallel workers against a local node, about 10 hours for the full history. Tracing every block with debug_traceBlockByNumber (needed for internal ETH transfers) ran at 227–388 blocks per second, about 88 hours.
• Decoding. Swaps come from Uniswap v2 pairs, v3 pools, the v4 singleton (one contract, millions of pools, optional hooks) and launchpad bonding curves, each with different events and price math. Every trade needs a USD price at its block, through the right quote token.
• Attribution. The from of a swap transaction is often a router, aggregator, solver or ERC-4337 bundler, not the person trading. Finding the real trader means following the token flow inside the transaction.
• Reorgs and finality. Recent blocks are soft-confirmed by the sequencer and only become final once their batch is finalized on Ethereum, roughly 15 minutes later.

Public and hosted RPC endpoints help with the node, not with the rest. Robinhood’s public RPC accepts eth_getLogs over at most 10 million blocks per request, which is generous, but you still decode, price and attribute everything yourself. The trade-offs are covered in REST API vs RPC vs indexed data API.

Setup

You need Python 3.9+ with requests, or Node.js 20+ (no packages). Trade history works without a key at 2 requests per second. Token activity needs a free key, wallet history a Starter key; create one at dashboard.crius.sh and export it:

export CRIUS_API_KEY="crs_live_…"

All list endpoints share the same pagination: pass limit (up to 500), read meta.next_cursor from the response, and send it back as cursor until it’s missing. Cursors are stable positions in the chain (<block>-<log index>), so new blocks arriving while you page don’t shift or duplicate results.

1. Every trade of a token, to CSV

This script walks a token’s whole trade history, newest first, and writes it to a CSV. It retries politely on 429 (rate limit) and short 502/503/504 responses.

"""Export every trade of a Robinhood Chain token to CSV by walking the cursor."""
import csv
import os
import sys
import time

import requests

API = "https://api.crius.sh/v1/robinhood"
token = sys.argv[1]
headers = {"x-api-key": os.environ["CRIUS_API_KEY"]} if os.environ.get("CRIUS_API_KEY") else {}

fields = ["block", "ts", "tx", "type", "trader", "amount_base", "amount_quote",
          "price_usd", "value_usd", "dex", "pool"]
cursor, total = None, 0
with open(f"{token}.csv", "w", newline="") as f:
    out = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
    out.writeheader()
    while True:
        params = {"limit": 500, **({"cursor": cursor} if cursor else {})}
        r = requests.get(f"{API}/token/{token}/trades", params=params, headers=headers, timeout=30)
        if r.status_code in (429, 502, 503, 504):
            time.sleep(int(r.headers.get("retry-after", "2")))
            continue
        r.raise_for_status()
        body = r.json()
        out.writerows(body["data"])
        total += len(body["data"])
        cursor = body["meta"].get("next_cursor")
        if not cursor:
            break
print(f"{total} trades written to {token}.csv")

Run against Charge AI (CHARGE), a token that launched on Pons and graduated to a Uniswap v4 pool, with no API key:

$ python3 export_trades.py 0x7b8892cea949bc60d494681d1bc3ea96071ab0b8
5104 trades written to 0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.csv

real    0m21.340s

block,ts,tx,type,trader,amount_base,amount_quote,price_usd,value_usd,dex,pool
96404580,1792806984000,0x7deb83…85fa,sell,0x6034c5…5591,133448.2087111015,0.000310325791039145,5.53267e-06,0.738324,uniswap_v4,0x871b16…4913
96303852,1792796459000,0xbb164a…0ffb,sell,0x0e4cb9…4c3,300000,0.000698130344384762,5.50534e-06,1.6516,uniswap_v4,0x871b16…4913

Each row is already priced in USD at the trade’s block, and trader is the attributed wallet, not the router. The JSON has more than the CSV keeps: signer, the via path (routers, aggregators, bundlers), gas split into L2 and L1 cost, realized token tax, market cap at trade time and finality. Add filters to cut the walk down: side=buy, trader=0x…, min_usd=100, or a time range with from_ts and to_ts in milliseconds. For live trades rather than history, see the DEX trades API.

2. Everything that happened to a token since launch

Trades are only part of a token’s story. The /transactions feed adds liquidity changes, transfers, mints and burns, LP locks, fee claims, decoded owner actions, the launch itself and graduation. This Node.js script walks it from launch and tallies event types. It only counts events from blocks marked safe on Ethereum, so nothing it reads can still be reorganized away.

// Everything that happened to a token since launch: trades, liquidity, transfers, mints/burns, owner calls.
const API = "https://api.crius.sh/v1/robinhood";
const TOKEN = process.argv[2];
const headers = { "x-api-key": process.env.CRIUS_API_KEY };

const counts = {};
let cursor = null;
do {
  const qs = new URLSearchParams({ from: "launch", finality: "safe", limit: "500", ...(cursor && { cursor }) });
  const res = await fetch(`${API}/token/${TOKEN}/transactions?${qs}`, { headers });
  if ([429, 502, 503, 504].includes(res.status)) {
    await new Promise((r) => setTimeout(r, 1000 * Number(res.headers.get("retry-after") ?? 2)));
    continue;
  }
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const { data, meta } = await res.json();
  for (const ev of data) counts[ev.type] = (counts[ev.type] ?? 0) + 1;
  cursor = meta.next_cursor;
} while (cursor);
console.log(counts);

Output for the same token:

$ node token_activity.mjs 0x7b8892cea949bc60d494681d1bc3ea96071ab0b8
{ sell: 2221, buy: 2883, transfer: 89, remove_liquidity: 39, burn: 4, add_liquidity: 45,
  event: 4, lock: 2, graduation: 1, mint: 1, launch: 1 }

real    0m16.481s

The 5,104 buys and sells match the trade export above, and the feed adds 186 non-trade events: the launch, graduation, liquidity moves, two LP locks and the transfers between wallets. To fetch only some types, pass type=add_liquidity,remove_liquidity,lock. from and to take more than block numbers: block:N, ts:<ms>, mcap:<usd> (the first time the token crossed a market cap), launch or trading_open. For example, from=mcap:100000 gives you everything after the token first reached $100k.

3. A wallet’s complete trading history

For tax reports, copy-trading research or PnL, you want every swap a wallet made, across all tokens:

"""Every swap a wallet made on Robinhood Chain, across all tokens (Starter plan or above)."""
import os
import sys
import time
from collections import Counter

import requests

API = "https://api.crius.sh/v1/robinhood"
wallet = sys.argv[1]
headers = {"x-api-key": os.environ["CRIUS_API_KEY"]}

trades, cursor = [], None
while True:
    params = {"limit": 500, **({"cursor": cursor} if cursor else {})}
    r = requests.get(f"{API}/wallet/{wallet}/trades", params=params, headers=headers, timeout=30)
    if r.status_code in (429, 502, 503, 504):
        time.sleep(int(r.headers.get("retry-after", "2")))
        continue
    r.raise_for_status()
    body = r.json()
    trades += body["data"]
    cursor = body["meta"].get("next_cursor")
    if not cursor:
        break

volume = sum(t["value_usd"] or 0 for t in trades)
top = Counter(t["token"]["symbol"] or t["token"]["address"] for t in trades).most_common(3)
print(f"{len(trades)} trades, ${volume:,.0f} volume, most traded: {top}")

$ python3 wallet_history.py 0x6034c50c16c5d73589de7488e236df403a5c5591
751 trades, $15,996 volume, most traded: [('PCC', 81), ('AI', 39), ('WOOD', 28)]

real    0m3.971s

The wallet is matched as the attributed trader, so swaps it made through routers and aggregators are included. Each trade also carries a position object (the wallet’s balance of that token after the trade), and the wallet profile endpoint summarizes holdings and realized and unrealized PnL. Busy bots are a different scale: a market-making wallet can have hundreds of thousands of swaps. Page those by time window (from_ts, to_ts), or by token with token=0x…, so a long export can resume where it left off.

4. Everything new on the chain

To track the chain as a whole rather than one token or wallet, combine a list endpoint for catch-up with a stream for live data. This works without a key:

"""Print every new Robinhood Chain token as it appears (no API key needed)."""
import time
import requests

API = "https://api.crius.sh/v1/robinhood"
seen_after = int(time.time() * 1000) - 10 * 60_000  # start with the last 10 minutes

while True:
    r = requests.get(f"{API}/tokens", params={"list": "new", "created_after_ts": seen_after, "limit": 50}, timeout=10)
    if r.ok:
        for t in sorted(r.json()["data"], key=lambda t: t["created_ts"]):
            print(t["created_block"], t["symbol"], t["launchpad_name"] or "direct deploy", t["address"])
            seen_after = max(seen_after, t["created_ts"])
    time.sleep(10)

96710587  ZONE      Pons          0x4fda1b2ab3cc83bcb5525811d43018497a4f1f50
96711825  ORYNEX    Pons          0x921815ae78f106e000f462a929948f9ed06a6126
96711909  ORYNEX    Flap.sh       0x2da6dc8715a1ec0a9c2e70a8cd12b8ff53c37777
96712006  RESERVE   Flap.sh       0x62e5d3844cfe2da1df273ffb3ef0dfedaa1b7777

For true real time, subscribe to launches:all, graduations:all and pools:new on the WebSocket stream with a free key. Enterprise plans can also receive firehose:trades, every trade on the chain as it happens.

Storing what you export

A few habits make exports safe to re-run:

• Use id as the primary key. Trades and events have an id of the form <block>-<tx index>-<log index>, unique and stable. Upsert on it and re-running a job never creates duplicates.
• Keep finality. Events newer than the safe_block in meta can, in principle, still change. Either filter with finality=safe, or store them and refresh the last few thousand blocks on the next run.
• Resume from the cursor. Save the last cursor you processed; if a job stops, start from it instead of from the top.
• Mind the credits. Trades cost 2 credits per call and transactions 2, so a 500-row page costs at most 2 credits. The CHARGE exports above cost about 22 calls each. Limits per plan are on the plans and limits page.

FAQ

Can I get Robinhood Chain transaction history for free? Yes, for trades: the /trades endpoint works without a key at 2 requests per second, enough to export a typical token’s full history in under a minute. The full activity feed and holders need a free account (1,000,000 credits a month).

How far back does the history go? To block 0. The index was built by replaying the whole chain, so a token’s first trade and its launch are always included.

Do I get raw transactions or decoded events? Decoded events: swaps with price, USD value and the real trader; liquidity changes with amounts; transfers; launches and graduations. If you need raw calldata or full traces, use an archive RPC provider; see our comparison of Robinhood Chain data APIs.

What about internal ETH transfers? They come from call traces, not logs. Crius traces blocks and uses them for funding links and the wallet connection graph; the historical data page covers what is available.

How do I keep an export up to date? Store the newest id you have, then page from the top on each run until you reach it, or keep a WebSocket subscription open and backfill gaps with from_ts after a disconnect.

Related reading

• Robinhood Chain API: the complete developer guide
• Free Robinhood Chain API: what can you build without paying?
• Building a trading bot with WebSocket streams