Verifiable blockchain indexing.
Willow indexes major blockchains into queryable tables and shows its work: proofs that nothing was missed, altered, or invented on the way. Verify them yourself — no trust in the indexer required.
The indexer is no longer a trusted party.
Every dapp, dashboard, and trading desk runs on indexed blockchain data. Raw chains aren't queryable, so an indexer ingests blocks, decodes events, and serves the result from a database — and whatever that pipeline says becomes your version of the truth. A bug, a stale node, or a compromised operator rewrites it silently.
Willow verifies the whole pipeline, not just the rows at the end. Completeness — every event your manifest matches is indexed, nothing silently dropped. Correctness — every row is a proven transformation of the raw on-chain events. Inclusion — every indexed event actually exists on the source chain. The results land in a verifiable table store, and the proofs travel with the data.
The rule: anything that can be proven cryptographically, is. On Ethereum that's the entire pipeline today. Chains without light clients — Solana among them — can't support every proof yet, so trusted execution environments and redundant, cross-checked indexers fill the missing links until proofs can take over.
Where the data lives is your call too. Stream it straight from the chain, through the indexer, to your client and verify on arrival — or persist it behind Willow consensus for a durable record others can query and verify later. Private subgroves keep the dataset itself off-chain, publishing only the commitments.
And it goes past raw events: declare derived tables — balances, aggregates, per-account state — and the derivation is verified the same way the raw data is. The numbers on your dashboard trace back to real blocks, provably.
Any chain, one API
Ethereum, Solana, BNB Chain, Polygon, Arbitrum, Optimism, Base — every blockchain lands in the same queryable shape, behind the same SDKs.
Verified, not trusted
Completeness, correctness, and chain-inclusion proofs — checked on your machine, not taken on faith. Where a chain can’t support a proof yet, TEEs and indexer redundancy stand in.
Derived tables
Schemas and transformations declared in a manifest. Balances, counts, aggregates — computed and committed with the same guarantees as the raw events.
From setup to verified reads.
- 01
Declare
Write a manifest: chains, contracts, events, and the tables to derive from them. Register it to create a subgrove — your indexed dataset on Willow.
- 02
Index
Willow indexers ingest blocks and decode your events in real time, generating proofs of the work as they go.
- 03
Query
Query rows through the SDKs — Rust, TypeScript, Python, Go, Swift, or React Hooks — the same shape as a normal database call.
- 04
Verify
The SDK checks the proofs client-side — streamed direct from the indexer, or anchored behind Willow consensus. Either way, no trusted blockchain indexer in the path.
import {
WillowClient,
verifyQueryResponse,
} from '@willow/sdk';
const client = new WillowClient({
apiUrl: 'https://api.willow.tech',
});
// Query indexed swap events — proof attached
const swaps = await client.data.query('dex-swaps-v3', {
filter: { pool: '0x88e6...' },
include_proof: true,
});
// Verify the proofs locally
const { valid } = await verifyQueryResponse(swaps);Common questions.
How is this different from a hosted indexer or running my own?
Other indexers — hosted or self-run — hand you a database you have to trust. Willow hands you the proofs: that every matching event was indexed, transformed correctly, and exists on the source chain. If an indexer drops, mangles, or invents a row, verification fails on your side. You audit math, not operators.
Does my data have to go through Willow's chain?
No. Indexed data can stream straight from the source chain, through the indexer, to your client, with every proof verified on arrival. Persisting behind chain consensus is opt-in — choose it when you want a durable, queryable record that third parties can verify later.
Which blockchains can Willow index?
Ethereum, Solana, BNB Chain, Polygon, Arbitrum, Optimism, and Base today, with more on the way. The full end-to-end proof pipeline runs on Ethereum; on chains without light clients, trusted execution environments and redundant indexing cover the missing links. Every chain lands in the same queryable shape behind the same SDKs.
Is my indexed data public?
Only if you want it to be. Register a private subgrove and the indexed dataset stays with your indexer — only state-root commitments go on-chain — with per-identity read access granted through encrypted keys in the SDKs. The source chain is public; your tables don't have to be.
What does verification cost at read time?
Proof checks run locally in milliseconds — in a browser, a server, a Lambda, or an enclave. Proofs are opt-in per query, so reads that just need speed can skip them.
Start indexing.
Register a subgrove from the dashboard and watch verified rows land in minutes.