The Graph vs Goldsky vs Envio vs Ponder: Choosing a Blockchain Indexer
We operate indexers in The Graph network and build custom ones in production, so here is how The Graph, Goldsky, Envio, and Ponder actually compare in 2026.
For most dapps, a subgraph is still the safe default: run it on The Graph's decentralized network, or self-host graph-node, or use a managed provider like Goldsky. If backfill speed or indexing cost is your bottleneck, Envio is the fastest engine and can be self-hosted, though The Graph's Substreams closes much of that gap. If you want full control in TypeScript and can run the infrastructure, Ponder is the developer favorite. The Graph's old hosted service is gone, so it is no longer the default path.
Protofire operates indexers in The Graph network (a top-3 indexer since 2019) and maintains the open-source subgraph-toolkit. We also build custom indexers on Ponder and in Rust, and we are not affiliated with Goldsky or Envio. The sections below name where each option beats The Graph, and the throughput comparison comes from an independent Sentio benchmark. See our other decision guides, including rollup stacks.
At a glance
| 01The Graph | 02Goldsky | 03Envio | 04Ponder | |
|---|---|---|---|---|
| Hosting model | Network, provider, or self-hosted | Fully managed | Managed or self-hosted | Self-hosted only |
| Query interface | GraphQL | GraphQL, REST, SQL | GraphQL (SQL on paid tiers) | GraphQL, SQL |
| Handler language | AssemblyScript (Rust for Substreams) | AssemblyScript; SQL for Mirror | TypeScript, JS, ReScript | TypeScript |
| Chain coverage | Many EVM and non-EVM | 150+ | 80+ native, any EVM via RPC | Any EVM via RPC |
| Backfill speed | Subgraph baseline; Substreams narrows it | Subgraph-class plus streaming | Fastest in the Sentio benchmark | RPC-bound unless boosted |
| Graph-compatible | It is The Graph | Yes, drop-in | No, different framework | No, different framework |
| Runs your infra | Optional (self-host graph-node) | No | Optional | Yes, required |
The backfill-speed gap, in one benchmark
Time to index the Uniswap V2 Factory in an independent Sentio benchmark (April 2025, later forked and promoted by Envio). Lower is better, shown on a log scale. Read it as directional, not a universal law: it measures historical backfill of one contract, Sentio is itself an indexer, and The Graph's Substreams path (not the plain subgraph benchmarked here) narrows the gap. Goldsky was not in this run (it is subgraph-class).
The four indexers
The Graph
- +Largest ecosystem of existing public subgraphs and third-party tooling
- +Decentralized network, no single provider to depend on
- +Substreams and Firehose offer a high-throughput path beyond plain subgraphs
- −Its old free hosted service is gone; you now use the network, a provider, or self-hosted graph-node
- −Plain-subgraph mappings are in AssemblyScript, a learning curve for TypeScript teams
- −Network query volume has been declining, not growing
The Graph made subgraphs the default way to index on-chain data: you define a schema and write mapping logic that turns contract events into entities, then query over GraphQL. It has by far the largest ecosystem of public subgraphs and tooling. Its free hosted service was fully sunset, so today you index with The Graph in one of three ways: publish to its decentralized network (indexers serve queries, paid via a gateway), use a managed Graph-compatible provider, or self-host the open-source graph-node yourself.
Two nuances matter for any speed comparison. First, plain subgraphs run on AssemblyScript mappings, but The Graph's high-throughput path, Substreams and Substreams-powered subgraphs (built on StreamingFast's Firehose), is a parallelized, Rust-based streaming architecture, the direct analog of Envio's engine, and it narrows most of the backfill gap shown in benchmarks of naive subgraphs. Second, network-wide query volume has trended down (a Q2 2025 peak near 6.5B fell to roughly 5.0B in Q4 2025, per Messari), which mainly matters if you are relying on the network's long-term health. This is the ecosystem we know most deeply, and it is still the right default for a large share of dapps.
Goldsky
- +Drop-in for existing subgraphs (Graph-compatible)
- +Mirror streams on-chain data straight into your own database
- +Fully managed, no infrastructure to run
- −Paid managed service, so a vendor dependency
- −Mirror's event-extraction can push reorg and state handling onto you
- −Not self-hostable
Goldsky is a fully managed indexing platform with two products. Its Subgraphs are Graph-compatible, so an existing subgraph deploys with little or no change, which made it a common landing spot for teams leaving The Graph's hosted service. Its Mirror product streams on-chain (and some off-chain) data directly into your own database or warehouse (Postgres, ClickHouse, and similar) using declarative pipelines and SQL transforms rather than hand-written handlers.
It supports 150+ chains and exposes GraphQL, REST, and SQL. The appeal is operational: subgraph or streaming indexing without running the infrastructure. The trade-offs are a paid vendor dependency and that Mirror's event-extraction model can push reorg handling and state reconstruction onto you for some pipelines, which you should check against your correctness needs.
Envio (HyperIndex)
- +Fastest historical backfill in the public benchmark, via its HyperSync Rust engine
- +Managed or self-hostable via Docker
- +TypeScript, JavaScript, or ReScript handlers, no AssemblyScript
- −HyperSync covers a large but finite chain set; others fall back to standard RPC speed
- −Younger ecosystem, fewer existing public subgraphs to build on
- −Its headline benchmark is run by Sentio, itself an indexer, and Envio maintains and promotes it
Envio's HyperIndex is built around HyperSync, a Rust data layer that reads historical chain data far faster than standard JSON-RPC. You write handlers in TypeScript, JavaScript, or ReScript, get an auto-generated GraphQL API (SQL on higher tiers), and can run it managed or self-hosted via Docker. HyperSync natively covers 80+ chains, including the non-EVM Fuel network, with any other EVM chain reachable over normal RPC.
On speed: an independent Sentio benchmark (Uniswap V2 Factory, April 2025) put HyperIndex at about 8 seconds versus roughly 2 minutes for the next engine and about 19 minutes for a plain subgraph. Two caveats: Sentio is itself an indexing vendor and Envio forked and now promotes that benchmark, so treat the exact multiples as directional; and it measures historical backfill, at the chain head every engine is latency-bound and the gap shrinks. The advantage, reading history from a purpose-built engine instead of block-by-block RPC, is real, but The Graph's Substreams uses the same idea, so it is not a category of one.
Ponder
- +Pure TypeScript end to end, no separate mapping language
- +Full control; the indexer lives beside your backend, in the same repo
- +Open-source, no vendor lock-in
- −Self-hosted only, you run and scale it yourself
- −RPC-bound ingestion unless paired with a faster data source
- −No official managed or hosted service
Ponder is an open-source, self-hosted framework where you write the entire indexer in TypeScript, no AssemblyScript, and it exposes a GraphQL and SQL API. The indexer lives beside your application backend, in the same language and repo, so for a team already in a TypeScript and Node stack the developer experience is the main draw: no separate mapping language, and testing and local development feel like the rest of your backend. We run production Ponder indexers ourselves (for example a Ponder-based indexer for on-chain auctions).
The trade-offs are operational: there is no official hosted service, so you own running and scaling it, and ingestion moves at standard RPC speed unless you pair it with a faster data source. It suits teams with real DevOps capability, and it is the wrong choice for a team that wanted a managed service.
Which should you use?
you are comfortable with subgraphs, want the largest ecosystem, and value a decentralized network or the option to self-host graph-node.
you want subgraphs without operating infrastructure, a drop-in home after the hosted-service sunset, or data streamed into your own database.
historical backfill time or indexing cost is the bottleneck and your chains are HyperSync-supported; you also want the option to self-host.
your team lives in TypeScript, you want the indexer beside your backend, and you can run the infrastructure yourself.
Beyond the four indexers
- SQD (formerly Subsquid): a decentralized data-lake indexer, strong at fast historical backfills (it placed second in the benchmark above). Note it was acquired by Rezolve AI in October 2025 and is mid-rebrand, so weigh its roadmap.
- Sentio and Ormi: full indexers in their own right (Sentio adds SQL and non-EVM chains; Ormi is a real-time, Graph-compatible platform), both credible 2026 options beyond the four above.
- Data platforms and APIs (Chainbase, Alchemy, Moralis, Covalent): Chainbase is a full index-and-SQL platform, not just an API; the others are ready-made data APIs. If you only need standard token, NFT, or transaction data, one of these can be simpler than running any indexer.
FAQ
How much does blockchain indexing cost?
Is The Graph's hosted service still available?
What is the fastest blockchain indexer?
Do I need a subgraph, or a custom indexer like Ponder?
Can I move an existing subgraph to a different provider?
How do you keep indexed data correct during chain reorgs?
Reviewed by Luis Medeiros, Field CTO at Protofire. Last updated: July 2026.
We operate indexers in The Graph network and build custom ones on Ponder and in Rust, including the subgraphs, backfill strategy, reorg handling, and monitoring behind them.
blockchain data indexing →