Feed blockchain data into your own database, analytics pipeline, or event processor. GraphOps Substreams runs standard Substreams packages and delivers their output over gRPC, so you can backfill historical blocks and continue with a live stream.
- Best for
- Block pipelines, historical backfills, and data stored in your own systems.
- Interface
- gRPC streams with cursors
- Plan for
- Cursor persistence, undo signals, package output, and destination storage.
Stream five Ethereum blocks
Create an API key and stream Ethereum block metadata from a standard package.
Backfill a bounded range
Replay deterministic package output and commit it to your own system.
Recover without losing work
Persist committed cursors and process undo signals after reversible blocks.
How a Substreams pipeline is split
GraphOps runs the package and delivers its output. Everything after the stream belongs to your consumer: decoding the output type, writing it to storage, saving cursors, and reverting writes after a reorg.
What you can build
- Historical backfills that continue live. Start at the block your history needs and leave the stop block open to keep following the chain. See Backfill a range.
- Consumers that never skip a block. Commit each block's output with its cursor and resume from that cursor after a restart. See Resume with cursors.
- State that stays correct through reorgs. Revert writes after the last valid block when an undo signal arrives. See Cursors and reorgs.
- Package output in tables you own. Run a standard sink that writes to Postgres, ClickHouse, files, or Pub/Sub. See Run a sink.
Choose Substreams when
Use Substreams when you need to process blocks in order, replay a range, or build a data model in your own storage. You choose the package and output module; your consumer commits the data and saves its progress.
Use another GraphOps service when your job is different:
| Need | Use |
|---|---|
| Direct node calls, transactions, or contract state reads | RPC |
| Query indexed GraphQL entities without running your own materializer | Subgraphs |
Choose a package and destination
Find reusable packages on substreams.dev or in
Discover Substreams, or use
your own .spkg file. Pin the package version, choose an output module that produces the data your
application needs, and connect it to a supported network.
Your consumer can write to SQL, files, queues, or a custom store. If you want GraphOps to host the sink, contact support about enterprise options.
Plan for production
Backfills and live streaming use the same stream protocol. Before you rely on stored data:
- Save each cursor in the same transaction as the output it follows.
- Handle undo signals, or stream final blocks only if you cannot revert writes.
- Size backfills and reconnect loops to your organization's limits.
Usage follows the billable components and rates on Usage and limits.