What is a blockchain Firehose?

Updated August 2026

Firehose is a blockchain data extraction layer built by StreamingFast. It instruments a blockchain node to capture everything that happens during block execution, writes it to flat files, and serves it as a stream — so the same system provides full chain history and live data at the head.

The name is also used generically for "a high-throughput stream of blockchain data," but Firehose specifically refers to this open-source component family, which is a core part of The Graph's data infrastructure.

What problem does it solve?

Getting data out of a blockchain node normally means JSON-RPC. That works for one-off lookups and falls apart as a data pipeline: it is slow under load, response shapes vary between clients, and reading large ranges of history means an enormous number of sequential round trips.

Firehose inverts this. Instead of asking a node repeatedly for data, an instrumented node emits everything as it executes, once. That output is stored as flat files that can be read in parallel by as many consumers as you like — no re-querying, no rate limits on your own data, no node under pressure.

What does Firehose capture that RPC does not?

This is the part most often missed. Firehose records the execution detail of each block, not only its published results:

	Typical RPC / log-based indexing	Firehose
Events and logs	Yes	Yes
Transaction receipts	Yes	Yes
Internal transactions / call trees	Usually not	Yes
State changes	No	Yes
Balance changes	No	Yes

If you have ever needed internal transactions and found that your indexer simply could not see them, this is why. A contract that moves value without emitting an event is invisible to log-based indexing and fully visible to Firehose.

How does it handle chain reorgs?

Every block Firehose sends carries a cursor identifying its exact position in the chain, including fork context. If a consumer disconnects, it reconnects with its last cursor and resumes precisely where it left off. If the chain reorganises, the cursor lets the stream describe what was undone rather than silently skipping it.

This is why Firehose consumers can make reliability guarantees that polling-based pipelines cannot.

What are the pieces?

An instrumented node produces the data. A Reader captures it, a Merger consolidates blocks into files, a Relayer distributes live blocks, and a gRPC server serves streams to consumers. Running multiple Readers lets them race to deliver each block first, which lowers latency and removes a single point of failure.

Substreams is the transformation engine that runs on top of this data.

Frequently asked questions

Is Firehose the same thing as Substreams? No. Firehose extracts and serves raw blockchain data; Substreams transforms it. Firehose is the source, Substreams is the compute layer. See the full comparison.

Do I need to run my own node to use Firehose? No. You can self-host the full stack, or consume hosted Firehose and Substreams endpoints via thegraph.market without operating any infrastructure.

Is Firehose open source? Yes, under the Apache 2.0 licence. Source is at github.com/streamingfast/firehose-core.

Want the data without running the stack? Get an API key at thegraph.market — no personal information required.