CRIUS

Compare · Architecture

Robinhood Chain RPC vs indexed API

Use an RPC to send transactions and read raw chain state; use an indexed API when you need prices, trades, holders or history across many blocks. An RPC answers one block or contract at a time, while an indexer has already read every block, decoded it and stored the answers. Here is what each gives you and what building the second yourself involves.

What an RPC gives you

eth_getLogs
Raw event logs by address and topic, in block ranges the provider caps.
eth_call
Read contract state (balances, reserves, slot0) at the latest or, on archive nodes, any past block.
eth_getBlockByNumber / receipts
Blocks, transactions, gas and status, one block or receipt at a time.
debug_trace* / trace_*
Internal calls and value transfers, where the provider exposes trace APIs.
eth_subscribe
New heads and logs over WebSocket, with no replay if you disconnect.
eth_sendRawTransaction
Writing to the chain. Only an RPC does this.

What you build on top for market data

Decoding
Swap, Mint, Burn, Transfer and launchpad events across Uniswap v2, v3 and v4 and each launchpad's contracts, each with its own ABI.
Pricing
Turning every swap into a USD price: routing through WETH and stablecoins, choosing the pool to trust, filtering thin-pool spikes.
Attribution
Finding the real trader behind routers, solvers and ERC-4337 bundlers, not the contract that emitted the event.
State over time
Holder balances at any block, cohorts, PnL with cost basis, liquidity history: aggregates you maintain as every block lands.
Reorgs and finality
Rolling back and replaying events when the chain reorganises, and telling clients what is final.
Storage and serving
Hundreds of millions of rows, indexes for every query shape, caches, rate limiting and a stable API.

The same question, two ways

"Show me recent WETH trades with USD prices."

Raw RPC

curl -s https://rpc.mainnet.chain.robinhood.com \
  -H "content-type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{
        "fromBlock":"0x5a995c0","toBlock":"0x5a99688",
        "topics":["0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67"]
      }]}'
# → raw Uniswap v3 Swap logs: int256 amounts, sqrtPriceX96, no token, no price.
# Next: map pool → tokens (eth_call), decimals, a USD route, the real sender,
# then repeat for v2, v4 and every launchpad, store it, and handle reorgs.

Indexed API (Crius)

curl "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=50"
# → decoded trades: side, amounts, USD price and value, real trader,
#   pool and DEX, block, timestamp and finality. History back to block 0.

See the DEX trades API for the full response.

What indexing Robinhood Chain took us

Measured on our own archive nodes, before any decoding, pricing or aggregation.

  • ~96M

    blocks on Robinhood Chain so far (~100 ms block time)

  • ~10 h

    to fetch every receipt once, at 2,200–2,900 blocks/s from our own archive nodes

  • ~88 h

    to trace every block once, at 227–388 blocks/s

  • 450M+

    decoded DEX trades in the Crius index

  • 28.9M

    addresses with balances or activity tracked

A shared RPC endpoint is much slower than a local node and caps eth_getLogs ranges, so a full backfill over one can take weeks. After the backfill, the index has to keep up with ~10 blocks a second, forever.

Use an RPC when…

  • You send transactions or simulate them.
  • You need current state of a few specific contracts.
  • You index your own contracts' events that no API models.

Providers: Alchemy, QuickNode, Goldsky Edge, or Robinhood's public RPC for testing.

Use an indexed API when…

  • You show prices, charts, trades or holders in an app.
  • You need history across millions of blocks, or state at a past block.
  • You want analytics (PnL, bundles, honeypots) without running a data pipeline.
Crius Robinhood Chain APICompare providers

RPC vs indexer: questions

What is the difference between a Robinhood Chain RPC and an indexer?

An RPC node answers questions about raw chain data: a block, a log, a contract's state. An indexer reads every block once, decodes and aggregates it, and stores the result so questions like "price history of this token" or "holders at block N" are a single query instead of millions of RPC calls.

Do I still need an RPC if I use Crius?

Only if your app writes to the chain or needs raw data that no index models. Crius is read-only. Many apps use an RPC provider for transactions and Crius for market data.

Is an indexed API less fresh than an RPC?

Slightly: an indexer has to decode a block before serving it. Crius streams events as each block is decoded and stamps every response with the block it reflects, its lag and its finality.

Can I build a token price API on the public RPC?

For a prototype, yes. For production you'll hit rate limits and block-range caps on eth_getLogs, and you'll need pricing, attribution, storage and reorg handling. RPC providers describe Robinhood's public RPC as shared and meant for testing and wallet connectivity.

How long does it take to index Robinhood Chain from scratch?

On dedicated archive nodes, reading every receipt once took us about 10 hours and tracing every block about 88 hours, before decoding, pricing and building aggregates. Shared RPC endpoints are far slower than a local node.

Further reading