Why Sieve

What changes when you drop the RPC provider.

The problem

Every existing indexer requires an RPC endpoint. That means either running a full node or paying a provider like Alchemy or Infura. Providers cost $225–900/month for serious usage, enforce rate limits, and add a dependency you don't control.

Your indexing speed is capped by their rate limit. Your uptime depends on their infrastructure. Your bill scales with your query volume.

How Sieve is different

Sieve connects directly to the chain's P2P network using the same devp2p protocol that full nodes use. It fetches block headers and receipts from peers, filters logs against your config at sync time, decodes matched events, and writes only what you asked for to PostgreSQL. Unmatched log and payload data is discarded.

Peers are anonymous, so none of them is trusted on its own. The canonical hash of each segment is confirmed by a quorum of distinct peers, the header chain up to that tip is checked link by link, and every block has its payload roots recomputed before it is committed. See Integrity.

~1000blocks/sec on Ethereum mainnet

$0per month. No RPC keys, no accounts, no billing

1TOML file. Zero code to write

5chains. Ethereum, Base, OP Mainnet, Unichain, World Chain

AutoGraphQL API with filters, pagination, sorting

Benchmarked on a Hetzner dedicated server, Ethereum mainnet, 11 contracts, 29 events, RabbitMQ streaming active. OP-Stack chains have thinner peer sets, so backfill throughput there depends on how many peers serve receipts.

Architecture

pipeline

P2P Network (Ethereum / OP-Stack)
       |
       v
  Sync Engine (parallel workers, bloom filter pre-screening)
       |
       |-----------------+-----------------+
       v                 v                 v
  Event Filter     Call Scanner     Transfer Scanner
       |                 |                 |
       v                 v                 |
  ABI Decoder      ABI Decoder            |
       |                 |                 |
       +-----------------+-----------------+
                         |
                         v
                   PostgreSQL -------> Webhooks / RabbitMQ
                         |
                         v
                   GraphQL API

The sync engine connects to the chain's peers and fetches block headers and receipts in parallel batches. A bloom filter pre-screens blocks before fetching receipts, skipping ~98% of blocks that have no matching events. Matched logs are decoded using your ABI and written to PostgreSQL in batched transactions.

▸ One command backfill, catch-up, and live head-following, no separate modes

▸ Checkpoint/resume restarts exactly where it left off

▸ Reorg handling rolls back only when a peer quorum agrees on the new tip

▸ Follow mode after historical sync, follows the chain head in real-time

▸ Graceful shutdown Ctrl+C stops cleanly, progress is saved

What you can index

Event logs

Filter by contract address, event signature, and indexed parameter values. Bloom filter pre-screening at sync time.

Function calls

Decode top-level transaction calldata for specific function selectors. Only successful (non-reverted) transactions.

Native ETH transfers

Track top-level transaction value with optional sender/receiver address filters. No ABI needed.

Factory contracts

Dynamically discover and index child contracts as they're deployed.

All configured in one TOML file. All stored in PostgreSQL. All queryable via GraphQL.

Next steps

▸ Get Started install and run Sieve in five steps

▸ Integrity what has to hold before a block is committed