OBIB: An Open Blockchain Indexer Benchmark — Workloads, Methodology, and Initial Results
A growing number of platforms — Sentio, Envio HyperIndex, Ponder, Subsquid, The Graph, and others — offer indexing infrastructure for on-chain data, differing in execution model, API surface, supported data categories, and completeness guarantees. Yet there is no shared methodology for comparing them: existing benchmarks measure a single workload (commonly Uniswap swap events), run on different infrastructure, and rarely verify data completeness.
This article introduces OBIB (Open Blockchain Indexer Benchmark): standardized workloads spanning events, RPC-augmented events, blocks, transactions, traces, and factory templates, each verified against expected record counts and executed against a unified RPC endpoint. Methodology, configurations, and data are open on GitHub. We report initial results on six platforms below, and invite the community to extend OBIB to additional platforms, workloads, and chains.
The Problem With Existing Benchmarks
Envio's 2023 benchmark showed 9.67-minute sync times for Uniswap V3 events — 2x faster than Subsquid, 80x faster than Ponder, 100x faster than The Graph. Subsquid has their own numbers claiming 200x faster than The Graph. Ponder claims 10x faster than Graph Node. Ormi Labs published rankings with Ormi at number one.
Every vendor wins their own benchmark. The problems are always the same:
- One test case. Usually event processing. Nobody tests blocks, transactions, or traces.
- No completeness checks. Nobody asks "did you get all the data?"
- Mixed infrastructure. Cloud vs local, different RPC providers, different hardware. Impossible to compare across studies.
When Envio forked our earlier benchmark repo to add their results, they mixed HyperSync (a raw data extraction engine) times with full indexer times — comparing a data dump tool against platforms that parse, transform, store, and serve data through APIs. That comparison made it into their marketing materials.
What We Tested
Six cases on Ethereum mainnet. Each one isolates a different capability.
| Case | Data Type | Block Range | Expected Records | What It Tests |
|---|---|---|---|---|
| Case 1 | Events | 0 → 22,200,000 | 294,278 | LBTC transfers. No RPC calls. Write-only. |
| Case 2 | Events + RPC | 22,400,000 → 22,500,000 | 7,634 | Events with RPC calls and read-after-write. |
| Case 3 | Blocks | 0 → 100,000 | 100,001 | Raw block data. Metadata extraction. |
| Case 4 | Transactions | 22,280,000 → 22,290,000 | 1,696,641 | Gas usage across ~1.7M transactions. |
| Case 5 | Traces | 22,200,000 → 22,290,000 | 50,191 | Internal call traces. Hardest to get right. |
| Case 6 | Templates | 19,000,000 → 19,010,000 | 35,039 | Uniswap V2 factory pattern. Dynamic contract registration. |
Six platforms:
- Sentio — cloud-hosted, native indexing with SQL and cross-chain support (SDK 3.1.0)
- Envio HyperIndex — local, Docker-based indexing framework with GraphQL (v2.32.3)
- Ponder — local, Node.js framework for blockchain data APIs (v0.16.1)
- Subsquid (SQD) — local, batch-processing framework with decentralized data network (v1.27.3)
- Subgraph (The Graph Studio) — cloud-hosted on Graph Studio infrastructure (graph-cli v0.97.0)
- Sentio Subgraph — same Subgraph runtime, Sentio's infrastructure. Same code, different infra. Included to isolate the infrastructure variable.
Methodology
All local platforms used Sentio's RPC service. This is the biggest methodological improvement over previous benchmarks — everyone gets the same RPC.
Local tests ran on a MacBook Air M3 (24 GB RAM). Cloud platforms (Sentio, Subgraph, Sentio Subgraph) ran on their own infrastructure. This means cloud platforms pay network latency that local platforms don't. We kept it this way because that's how people actually use these tools — nobody self-hosts The Graph Studio, nobody deploys Ponder to a cloud.
72-hour timeout per test. Sentio ran 5 iterations per case with anomaly exclusion. Other platforms ran single iterations.
Event Indexing (Cases 1 and 2)
Case 1 is the test every benchmark runs. Case 2 is the test that actually matters — events plus RPC calls plus read-after-write, which is what production indexers do.
Case 1: Events Only
| Platform | Time (min) | Records |
|---|---|---|
| Envio HyperIndex | 6.94 | 294,278 |
| Sentio | 11.02 | 294,278 |
| Sentio Subgraph | 14.90 | 294,278 |
| Ponder | 34.80 | 294,278 |
| Subsquid | 40.94 | 294,278 |
| Subgraph | 188.79 | 294,278 |
Envio wins. All platforms returned correct data. Not much to say here — this is table stakes.
Case 2: Events + RPC Calls
| Platform | Time (min) | Records |
|---|---|---|
| Sentio | 7.78 | 7,634 |
| Envio HyperIndex | 8.54 | 7,634 |
| Sentio Subgraph | 29.23 | 7,634 |
| Subsquid | 46.85 | 7,634 |
| Ponder | 64.86 | 7,634 |
| Subgraph | 66.41 | 7,634 |
Add RPC calls and the rankings change. Sentio edges ahead at 7.78 minutes, Envio close behind at 8.54. Everyone else is 29 minutes or more.
This is the more useful test. In production you're almost always fetching balances, computing derived values, or reading contract state while processing events. Pure event throughput is a different skill than handling that full workload.
All platforms returned correct data for both cases.
Beyond Events (Cases 3, 4, and 5)
Most indexers were built for events. Here's what happens when you need something else.
Case 3: Blocks
| Platform | Time (min) | Records | Completeness |
|---|---|---|---|
| Subsquid | 0.17 | 100,001 | 100% |
| Sentio | 2.51 | 100,001 | 100% |
| Sentio Subgraph | 2.67 | 100,001 | 100% |
| Ponder | 9.63 | 100,001 | 100% |
| Subgraph | 50.58 | 100,001 | 100% |
| Envio HyperIndex | N/A | — | Not supported |
Subsquid: 10 seconds, complete data. Clearly the fastest here. Everyone who supports blocks got 100%.
One thing we learned the hard way: Subsquid's .addTransaction() method silently skips blocks with no transactions. Early Ethereum (blocks 0–46,000) is mostly empty blocks, so using the wrong API call drops ~87% of the range without any warning. The correct method is .includeAllBlocks(). We burned time debugging this before figuring it out — worth knowing if you're writing a Subsquid block indexer.
Envio HyperIndex can't do blocks natively. HyperSync can (see below), but you'd be building the pipeline yourself.
Case 4: Transactions
| Platform | Time (min) | Records | Completeness |
|---|---|---|---|
| Subsquid | 1.25 | 1,696,641 | 100% |
| Sentio | 22.12 | 1,696,641 | 100% |
| Ponder | Timeout | — | 2.5% after 2 hours |
| Envio HyperIndex | N/A | — | Not supported |
| Subgraph | N/A | — | Not supported |
| Sentio Subgraph | N/A | — | Not supported |
Two platforms finished. Subsquid handled 1.7 million transactions in 1.25 minutes — genuinely impressive for a local setup. Sentio took 22 minutes from the cloud. Ponder made it to 2.5% in two hours and we stopped it. Three platforms can't process transactions at all.
Case 5: Traces
This is where it gets interesting.
| Platform | Time (min) | Records | Completeness |
|---|---|---|---|
| Sentio Subgraph | 2.17 | 45,895 | 91% |
| Sentio | 2.54 | 50,191 | 100% |
| Subsquid | 7.42 | 50,191 | 100% |
| Subgraph | 17.81 | 29,058 | 58% |
| Ponder | 74.71 | 44,400 | 88% |
| Envio HyperIndex | N/A | — | Not supported |
Expected: 50,191 traces. Sentio and Subsquid got all of them. Sentio Subgraph got 91%. Ponder got 88%. Subgraph got 58%.
That Subgraph number deserves an explanation. Subgraph uses callHandlers, which only see direct calls to a contract. When a user wallet calls the Uniswap V2 Router, Subgraph sees it. When an aggregator or MEV bot calls the router through an intermediary contract — an internal transaction — Subgraph doesn't. About 40% of V2 swaps happen that way. This also breaks sender identification: Subgraph found ~427 unique senders where trace-based indexers found ~1,200, because call.from returns the calling contract, not the original wallet. This isn't a config issue — it's how the Subgraph runtime works.
A note on Envio HyperSync
Envio offers HyperSync, a raw data extraction engine. No schema management, no database, no GraphQL — just raw blockchain data. It's fast:
| Case | HyperSync Time | Records |
|---|---|---|
| Case 3 (blocks) | 3.19 s | 100,001 |
| Case 4 (transactions) | 128.64 s | 1,696,423 |
| Case 5 (traces) | 33.84 s | 50,191 |
But comparing these to indexer times is apples to oranges. HyperSync gives you raw data. You still need to decode it, transform it, store it, and serve it. That's the part that takes time.
Templates and the Counting Problem (Case 6)
Uniswap V2, SushiSwap, most AMMs — they all use factory contracts that deploy pair contracts dynamically. Indexers need to detect new contracts on the fly and start tracking them.
| Platform | Time (min) | Records | vs Expected: 35,039 |
|---|---|---|---|
| Envio HyperIndex | 1.92 | 35,039 | ✓ |
| Sentio Subgraph | 4.26 | 75,951 | 2.2x |
| Subsquid | 5.34 | 33,972 | 97% |
| Ponder | 6.44 | 182,767 | 5.2x |
| Sentio | 14.36 | 75,951 | 2.2x |
| Subgraph | 16.83 | 35,039 | ✓ |
Envio is fastest. But the record counts are all over the place.
Expected: 35,039. Envio and Subgraph match. Subsquid is close at 33,972. Then Sentio reports 75,951 and Ponder reports 182,767. Same contracts, same block range, wildly different counts.
This isn't a bug in any platform. There's simply no standard for what "count the template events" means. Some platforms count only events from dynamically created contracts. Others include factory events. Others count differently when one transaction fires events across multiple related contracts. Until the industry agrees on a methodology, these numbers aren't directly comparable.
One operational note: Subsquid's template support requires you to manually update config at fixed block numbers when new contracts are created. Fine for a handful of contracts. Not practical if your factory creates thousands.
Feature Support
The feature matrix matters more than any speed number. If a platform can't do what you need, it doesn't matter how fast it is.
| Feature | Sentio | Envio | Ponder | Subsquid | Subgraph |
|---|---|---|---|---|---|
| Event Handler | Yes | Yes | Yes | Yes | Yes |
| Block Handler | Yes | Limited | Yes | Yes | Yes |
| Transaction Handler | Yes | Limited | Yes | Yes | No |
| Trace Handler | Yes | Limited | No | Limited | Limited |
| Native RPC Calls | Yes | Limited | No | No | No |
| SQL Querying | Yes | Yes | Yes | Yes | No |
| GraphQL API | Yes | Yes | Yes | No | Yes |
| Factory Templates | Yes | Yes | Yes | Limited | Yes |
| Batch RPC (Multicall) | Yes | Yes | Yes | Yes | No |
"Limited" means:
- Envio: Blocks/transactions/traces require HyperSync + manual decoding + client-side reorg handling. Not native to HyperIndex.
- Subsquid: Traces come as raw bytes. You decode them yourself.
- Subsquid: Templates need manual config updates at fixed blocks.
- Subgraph: Traces only capture direct contract calls. Internal transactions are invisible (~58% capture rate, broken sender identification).
Chain Support
| Chain | Sentio | Envio | Ponder | Subsquid | Subgraph |
|---|---|---|---|---|---|
| EVM | Yes | Yes | Yes | Yes | Yes |
| Sui | Yes | — | — | — | — |
| Aptos | Yes | — | — | — | — |
| Fuel | Yes | Yes | — | Yes | — |
| Solana | Limited | — | — | Yes | Limited |
| Bitcoin | Limited | — | — | — | Yes |
Sentio has the widest coverage. Subsquid and Subgraph each cover a few non-EVM chains. Envio and Ponder are EVM-only.
What Should You Use?
Depends on what you're building.
- Event indexing, speed matters most: Envio. Fastest in Case 1 by a clear margin. Requires Docker locally.
- Events with RPC calls and complex logic: Sentio and Envio are within a minute of each other in Case 2. Pick based on other factors — chain support, infrastructure preference, whether you want managed or self-hosted.
- Blocks, transactions, or traces: Sentio is the only platform that handles all three natively with complete data. Subsquid is strong on blocks and transactions but traces require manual decoding. Subgraph has a 58% capture rate on traces — if your app needs trace data, that's a dealbreaker.
- Multi-chain: Sentio. Nobody else covers EVM + Sui + Aptos + Fuel.
- Biggest ecosystem: The Graph. Thousands of existing subgraphs, mature tooling, large developer community. The Subgraph standard is the closest thing this space has to an industry standard. Slower sync, but the ecosystem has real value.
- Self-hosted with minimal setup: Ponder. Plain Node.js, no Docker. The team joined Monad in February 2026, so the project's future direction may tilt toward Monad-specific work.
- Already on Subgraph, want it faster: Sentio Subgraph. Same runtime, different infrastructure. Case 1 went from 188 minutes to 14 minutes. No code changes.
The Point
We need better benchmarks. Not just faster-than-thou blog posts with one test case and a bar chart.
We're publishing everything — methodology, data, source code — so anyone can verify or challenge these results. The code and data is on GitHub.
If we got a configuration wrong, open a PR. If you can make one of these platforms perform better, show us. That's how this should work.
Benchmark data collected January 2026. Source code and data at github.com/sentioxyz/open-blockchain-indexer-benchmark.