Your chain events,
in your own Postgres.
Give it an ABI, a contract address, and an RPC. Arckive streams every on-chain event into your own PostgreSQL — one table per event, reliable and gap-free — from a single YAML manifest.
Dune is delayed and rate-limited. Raw logs leave reorgs and back-fill to you. The Graph means subgraphs and heavy ops. There was no declarative path to your events, in your Postgres, in plain SQL.
Declare it. The operator does the rest.
One Indexer resource describes what you want. A Kubernetes operator keeps it true — database, schema, listener, optional read API.
Write one manifest
Contracts, ABI ref, RPC pool, storage mode — the whole setup.
kind: Indexer metadata: { name: usdc-arc } spec: rpc: # health-checked failover - https://rpc.arc.example storage: { mode: Embedded } contracts: - address: "0xA0b8…eB48" abi: { configMapRef: usdc-abi } startBlock: 0
The operator provisions
A reconcile loop turns the spec into running parts — and heals them.
Query plain SQL
Each event is a table in your Postgres. No API between you and your data.
-- one table per event SELECT "from", "to", value FROM usdc_transfer WHERE value > 1000000000 ORDER BY block_number DESC;
ABI in → tables out · empty events list = every event · startBlock: 0 backfills from genesis
Even if the network blips, no data is lost.
A poll-based backbone chosen for loss-free, self-healing ingestion — not just latency. Don't take our word for it: break something.
The last processed block lives in Postgres. After any crash it resumes exactly there.
Event inserts and cursor advance share one transaction — a commit, or nothing.
Indexes to the finalized tag — BFT finality means finalized blocks never reorg.
A health-checked pool with rotation, backoff, circuit-breaker. A blip never becomes a gap.
Measured, not promised.
Every number comes from running the real worker against the public Arc testnet and reading only its production surface — Postgres rows and /metrics. Reproduce it with pnpm bench.
Block close to queryable row on Arc testnet — live USDC traffic, WebSocket newHeads listening, not polling. Even p99 stays under a second (0.97s).
5,107 blocks of real USDC history caught up in 55 seconds over a public RPC — ~48× faster than the chain. Zero RPC errors.
The decode + transactional-SQL write ceiling, measured with WAN latency out of the picture.
The budget is published too: the head signal is consumed straight from the newHeads payload and one parallel eth_getLogs round-trip later the row is committed — the engine itself adds ~40ms; the rest of the latency belongs to how fast the RPC announces blocks — and it shrinks further with a cluster-local Arc node. Full methodology and raw results: benchmark report · docs/benchmarks.
A specific combination nobody else offers.
| Dune | The Graph | Raw RPC | Arckive | |
|---|---|---|---|---|
| Data in your own DB | No | Via graph-node | If you build it | ✓ Yes |
| Plain SQL access | Dune SQL only | GraphQL | Raw JSON | ✓ Yes |
| Reorg & gap handling | Theirs | Yes | On you | ✓ Built-in |
| Setup effort | Low | Med–high | High | ✓ One YAML |
Honest positioning: Dune stays great for ad-hoc analytics; The Graph for hosted multi-chain. Arckive is for teams that want their own Postgres, plain SQL, and K8s-native ops — together.
One YAML. A running indexer.
Runs in your cluster. Your data never leaves it.
$ kubectl apply -f https://arckive.org/install.yaml