Compare Indexers

An accurate, honest comparison of Envio against alternative indexers. Benchmarks you can run yourself, and every claim linked to its source.

Capability data checked 17 September 2026. Benchmark tables refresh automatically, last run 16 September 2026.

Kleros
KPK
Binance
Sky
Gauntlet
Ether.fi
World Liberty Financial
Aragon
Gnosis Pay
Beefy
Chronicle
Velodrome
Aerodrome
LI.FI
Caldera
dRPC
Pimlico
0xbow
Etherspot
Yield Basis
Limitless Exchange
Kleros
KPK
Binance
Sky
Gauntlet
Ether.fi
World Liberty Financial
Aragon
Gnosis Pay
Beefy
Chronicle
Velodrome
Aerodrome
LI.FI
Caldera
dRPC
Pimlico
0xbow
Etherspot
Yield Basis
Limitless Exchange
Powering Web3 industry leaders

Benchmark Comparisons

Indexing is not one workload, so one number cannot rank it. Pick a scenario to see what it tests and how each indexer did.

More coming soon
Envio Indexer
8,182.4 events/sec
HyperSync
Envio Subgraph
7,649.6 events/sec
(
1.1x slower
than the fastest)
HyperSync
Rindexer
947.2 events/sec
(
8.6x slower
than the fastest)
HyperSync
Squid SDK
556.1 events/sec
(
14.7x slower
than the fastest)
SQD Network
Envio Indexer
341.9 events/sec
(
23.9x slower
than the fastest)
RPC
Rindexer
322.8 events/sec
(
25.3x slower
than the fastest)
RPC
Envio Subgraph
241.1 events/sec
(
33.9x slower
than the fastest)
RPC
Ponder
62.0 events/sec
(
132.0x slower
than the fastest)
RPC
Subgraph (Graph Node)
31.4 events/sec
(
260.6x slower
than the fastest)
RPC
Substreams
28.7 events/sec
(
285.1x slower
than the fastest)
StreamingFast
SubQuery
25.3 events/sec
(
323.4x slower
than the fastest)
RPC
Missing 0.12% of the data: the verification range was not finished within 300s
Squid SDK
17.3 events/sec
(
473.0x slower
than the fastest)
RPC
Missing 32% of the data: the verification range was not finished within 300s
Events per second, higher is better. From the Open Indexer Benchmark, run in GitHub CI except where a row says otherwise. (source)

How well does a tool cope with data it has to read back? Every rETH transfer changes a balance, so each one means finding the row, updating it and saving it again.

How this is measured

The benchmark is maintained by Envio. Multipliers are worked out from the rates shown, so they can differ from the repository's own column by a rounding step. Every RPC row reads the same endpoint, Envio HyperRPC, and ground truth on the EVM scenarios is rebuilt from HyperSync logs. Envio Subgraph rows run each scenario's unmodified subgraph directory on a pinned subgraph build of envio from npm. External contract calls has no Substreams row, because the call would run on the Substreams server rather than against the endpoint the benchmark provides.

Run the whole suite the way CI does, then compare what you get with the table above.

git clone https://github.com/enviodev/open-indexer-benchmark && cd open-indexer-benchmark && ENVIO_API_TOKEN=your-token SQD_API_KEY=your-key node scripts/run-benchmarks.ts

Note: the repository asks for Node 23.6 or newer, Docker, an Envio API token and an SQD API key. Some numbers may differ from the table, since these runs happen on GitHub's standard CI machine and your hardware, your network and the rate limits on whichever endpoints and tokens you use are all your own.

Competitor Comparison

Open the tool you are weighing us against. Every cell links to the page it came from, and the benchmark tables are regenerated from the repository on every deploy. Anything we could not confirm from a public source says so.

Read the benchmarks
More coming soon

Envio vs The Graph

The Graph
Envio
Networks
Counted from each vendor's own list, not from their headline. Lists differ in whether they include testnets, so read each as that vendor publishes it. These move.
Multichain from one indexer
One indexer targets one chain family. EVM chains index together, and Solana and Fuel are each their own indexer.
How does Envio compare with The Graph?

A subgraph is deployed once per network, while one HyperIndex indexer can cover several EVM chains. The Envio Indexer on HyperSync leads Graph Node on every EVM scenario in the benchmark. Graph Node is MIT and Apache-2.0 licensed, and Envio's is a custom EULA. A subgraph's schema and manifest carry over to HyperIndex, with mappings ported from AssemblyScript to TypeScript.

Is Envio faster than The Graph?

On these workloads, yes. In the 16 September 2026 run of the Open Indexer Benchmark, the Envio Indexer reading HyperSync recorded 260.6 times the events per second of a subgraph on Graph Node reading RPC on state aggregation, and 581.2 times on the decoded event stream, the two scenarios Graph Node finished inside the 300 second cap. On external contract calls the Envio Indexer on HyperSync recorded 209.7 times Graph Node's rate, against a Graph Node run that did not finish the range.

Can I migrate a subgraph from The Graph to Envio?

Yes. The schema carries over with small changes, the manifest becomes a single config.yaml and AssemblyScript mappings are ported to TypeScript. There is a migration guide, Claude skills that guide an AI assistant through it, and a white-glove service that will do the migration for you.

When is The Graph the better choice?

When you want a decentralised, token-incentivised network rather than a single vendor, when you want to query the ecosystem of public subgraphs that already exist, or when an OSI licence is a requirement. Graph Node is MIT and Apache-2.0 licensed and can be self-hosted.

Migrate An Existing Indexer

A subgraph's schema carries over with small changes, the manifest becomes a single config.yaml and AssemblyScript mappings are ported to TypeScript.

Migrate From The Graph

The subgraph manifest becomes a single multichain config.yaml, the schema carries over with small changes and mappings are ported to TypeScript.

Migration Guide

Migrate From Alchemy

Alchemy sunset Subgraphs on 8 December 2025. Their subgraphs follow The Graph's model, so the same path applies.

Alchemy Guide

Subgraph Hosting

An AI-managed migration to HyperIndex with a subgraph-compatible GraphQL endpoint, so the apps querying it do not change.

Learn More

Migrate With AI

HyperIndex ships Claude skills that guide an AI assistant through the migration, from understanding the subgraph to converting its handlers.

Read The Guide

White Glove Support

Moving something large or unusual? Envio's team will migrate the subgraph to HyperIndex for you.

Learn More
See what changes in the code

The manifest becomes a config.yaml that can hold several chains, and the handler moves from AssemblyScript to TypeScript, with save replaced by a context set.

Before
The Graph, subgraph.yaml
- kind: ethereum/contract
  name: PositionManager
  network: mainnet
  source:
    abi: PositionManager
    address: "0xbD216513d74C8cf14cf4747E6AaA6420FF64ee9e"
    startBlock: 21689089
  mapping:
    language: wasm/assemblyscript
    eventHandlers:
      - event: Transfer(indexed address,indexed address,indexed uint256)
        handler: handleTransfer
After
HyperIndex, config.yaml
name: uni-v4-indexer
chains:
  - id: 1
    start_block: 21689089
    contracts:
      - name: PositionManager
        address: "0xbD216513d74C8cf14cf4747E6AaA6420FF64ee9e"
        events:
          - event: Transfer(address indexed from, address indexed to, uint256 indexed id)
Before
The Graph, AssemblyScript handler
export function handleSubscription(event: SubscriptionEvent): void {
  const subscription = new Subscribe(event.transaction.hash + event.logIndex);
  subscription.tokenId = event.params.tokenId;
  subscription.address = event.params.subscriber.toHexString();
  subscription.save();
}
After
HyperIndex, TypeScript handler
indexer.onEvent(
  { contract: "PoolManager", event: "Subscription" },
  async ({ event, context }) => {
    context.Subscription.set({
      id: event.transaction.hash + event.logIndex,
      tokenId: event.params.tokenId,
      address: event.params.subscriber,
    });
  },
);

Both examples are the Uniswap v4 pair from the migration guide, trimmed to the lines that change. Read the full guide

Envio Mythbusters

Things written about Envio that are not true today. Each is quoted from its live page, next to the Envio page that disproves it.

SQD

"manual account mapping; no automatic IDL/Anchor decoding"

Source: sqd.dev/compare/sqd-vs-envio, facts verified June 2026

HyperIndex decodes Solana instructions from an Anchor, Shank or Codama IDL. Discriminators, argument layouts and account names, including nested account groups, all come from the file. A layout is declared by hand only for a program with no IDL, or to override one.

Solana Decoding Docs
Ormi

Hosting model "Self-hosted", and "requires teams to manage infrastructure, scaling, monitoring, and reliability themselves"

Source: blog.ormilabs.com, Best Blockchain Indexers in 2026, last updated May 2026

HyperIndex can be self-hosted, and it can also run on Envio Cloud, a fully managed hosting service that provides the infrastructure, scaling and monitoring for you.

Envio Cloud Docs
Moralis

"HyperSync covers EVM chains exclusively."

Source: moralis.com/data-feeds-by-continuum

HyperSync is not EVM only. HyperIndex indexes Solana through HyperSync for Solana, the same data engine behind its EVM indexing, and Fuel through HyperFuel, its Fuel equivalent.

Solana Docs
The Indexing Company

"HyperIndex doesn't support Solana." and, in their table, "Non-EVM chains: Not supported"

Source: indexing.co/compare/envio

HyperIndex indexes Solana, and the Solana API is stable. It reads from HyperSync for Solana rather than an RPC node, and HyperIndex also covers Fuel.

Solana Docs
The Indexing Company

Pricing listed as "Not public (contact via Discord)"

Source: indexing.co/compare/envio

Envio publishes its prices. Hosting runs from a free Development plan to Production plans at $70, $300 and $800 a month, with Dedicated priced on request, and HyperSync has its own published plans.

Hosting Pricing
Moralis

"Reorgs in Envio require handler-level logic in application code."

Source: moralis.com/data-feeds-by-continuum

Reorg handling is built into HyperIndex and on by default. It rolls back every entity your handlers wrote, and detection is guaranteed when reading from HyperSync. Only side effects outside the database, such as calls to external APIs, are yours to handle.

Reorg Support Docs

Frequently Asked Questions

Who runs these benchmarks?

The Open Indexer Benchmark started in May 2025 as a fork of Sentio's research. Sentio later made their own repository private, and Envio has maintained the public fork since, so the whole repository is public and anyone can check or rerun it. In the four EVM scenarios shown here, each tool runs in GitHub CI, one job per tool per data source, started the way its own documentation recommends for production. Each tool's output is checked against ground truth rebuilt from HyperSync logs, and every RPC row reads the same endpoint, Envio HyperRPC. The repository notes contributions from the SQD team, and issues or pull requests are the way to correct a row that looks wrong.

Which blockchain indexer is fastest?

It depends on the workload, which is why the benchmark runs several scenarios rather than one. In the 16 September 2026 run, HyperIndex is fastest at state aggregation, at factory contract registration, where the fastest row is HyperIndex running an unmodified subgraph, and on Solana USDC transfers. It is joint fastest with the Squid SDK on external contract calls, and second on the decoded event stream, where Rindexer, which reads Envio's HyperSync, is ahead. Every scenario is in a public repository you can clone and run.

How much faster is Envio than The Graph?

It depends on the workload and on the data source. In the 16 September 2026 run of the Open Indexer Benchmark, the Envio Indexer reading HyperSync processed 260.6 times more events per second than a subgraph on Graph Node reading RPC on state aggregation, and 581.2 times more on the decoded event stream. Those are the two scenarios Graph Node finished inside the 300 second cap. Much of that gap is the data source, so it is worth reading the rows where both read the same RPC endpoint.

Can I move an existing subgraph to Envio without rewriting it?

In some cases, yes, with no rewrite at all. The pinned Envio Subgraph build runs an existing subgraph directory as it is, which is what the benchmark's own Envio Subgraph rows do. For a full move to native HyperIndex, the schema carries over with small changes, the manifest becomes a single config.yaml and AssemblyScript mappings are ported to TypeScript. There are guides for The Graph and for Alchemy Subgraphs, which Alchemy sunset on 8 December 2025, HyperIndex ships Claude skills that guide an AI assistant through the migration, and Envio's white-glove service will do the migration for you.

Does Envio support Solana?

Yes, and the Solana API is stable. HyperIndex indexes Solana at the instruction level, reading from HyperSync rather than an RPC node. Point a program at an Anchor, Shank or Codama IDL and the discriminators, arguments and accounts are derived for you. Inner instructions and CPIs decode the same way as top level ones, with their full instruction path, and pre and post SPL Token and Token-2022 balances can be attached to each transaction. It is the same config.yaml, the same TypeScript handlers and the same Envio Cloud deploy as an EVM indexer, though a Solana indexer is its own indexer rather than another chain inside an EVM one.

Can one indexer cover EVM chains and Solana at the same time?

No. An indexer's config.yaml has a single ecosystem field that selects the chain family it targets, either evm, svm or fuel, so one indexer covers one of them. Ethereum and Monad sit in the same indexer because both are EVM, and Solana runs as its own indexer alongside it, with its own config.yaml and handlers. Both deploy to Envio Cloud the same way.

Do I need an API token to use Envio?

To read from HyperSync, yes, and the token is free. HyperSync returns 401 without one, so an indexer you run yourself needs it set. Indexers deployed to Envio Cloud do not need you to supply one.

What is the difference between an indexer and an RPC provider?

An RPC provider serves raw chain data one request at a time. An indexer reads that data continuously, runs your logic over it, and writes the result into a database you can query. Alchemy, QuickNode, Infura and Helius are mainly RPC providers. The Graph, SQD, Goldsky, SubQuery, Ponder, Ormi and Envio are indexers, and some of them, including Goldsky and Envio, also offer RPC endpoints. Most production teams use both.