Why Substreams Will Revolutionize Real-Time Blockchain Data

Traditional RPC endpoints are request-response, forcing developers to poll for changes and rebuild state from scratch. This is slow, expensive, and unscalable for real-time applications.

• Polling Inefficiency: Wastes compute and bandwidth on empty calls.
• State Recalculation: Every app redundantly processes the same chain data.
• Latency Floor: Impossible to achieve sub-second updates at scale.

A two-layer architecture that decouples raw data ingestion from business logic. The Firehose provides deterministic raw blocks; Substreams are composable data pipelines that transform it.

• Deterministic Streaming: Single source of truth for raw chain data.
• Composable Modules: Developers subscribe to pre-processed data streams (e.g., map, store).
• Parallel Execution: Modules run in parallel, enabling ~500ms end-to-end latency.

Substreams enables applications previously impossible with RPCs, like monitoring Uniswap pool reserves, Aave health factors, or Compound borrowing rates across thousands of wallets simultaneously.

• Live Portfolio Tracking: Update user positions on every block.
• Cross-Chain Analytics: Power dashboards for LayerZero or Wormhole flows.
• Event-Driven Bots: Trigger actions based on sub-second on-chain signals.

While The Graph indexes historical data for queries, Substreams fills the gap for real-time streaming. Together, they form a complete data stack. Substreams can feed processed data into subgraphs.

• Synergy, Not Competition: Substreams for live data, The Graph for complex historical queries.
• Developer Leverage: Build once, deploy indexing logic to both stacks.
• Infrastructure Consolidation: Reduces reliance on Alchemy, Infura for real-time needs.

Shifts the cost model from per-query to per-data-sink. Developers pay for the specific data streams they consume, not for each API call. Aligns incentives with infrastructure efficiency.

• Predictable Pricing: Cost scales with data modules, not user traffic.
• No Redundant Payloads: Multiple apps can subscribe to the same pre-processed stream.
• Protocol Revenue: Value accrues to StreamingFast and module developers.

Substreams creates a network effect of composable data. The first team to build a USDC transfer or ERC-721 Transfer module creates a public good for all subsequent developers.

• Composability Flywheel: More modules → richer ecosystem → more developers.
• Vendor Lock-In Escape: Data logic is portable, defined in Rust, not proprietary APIs.
• Architectural Mandate: For any app requiring <1s updates, this becomes the only viable stack.

Substreams provide a deterministic, ordered stream of pending transactions before they hit a block, enabling real-time arbitrage and front-running detection.

• Zero RPC polling: Eliminates the latency and rate-limiting of traditional mempool APIs.
• Cross-chain composability: Seamlessly monitor mempools on Ethereum, Arbitrum, and Solana in a single, synchronized firehose.
• Event-driven architecture: Triggers custom logic on specific transaction patterns, not just block arrivals.

Real-time, multi-chain portfolio tracking and risk management for protocols like Aave, Compound, and Uniswap.

• Sub-second PnL updates: Track positions and impermanent loss as transactions occur, not with 12-second block delays.
• Cross-margin monitoring: Aggregate exposure across Ethereum L1, Polygon, and Base in a unified view.
• Liquidation engine: Build proactive liquidation protection that reacts to price movements in the same block.

Powering next-generation cross-chain applications like UniswapX and Across by providing verifiable, real-time proof of fulfillment.

• Atomic composability: Execute swaps and bridges in a single logical transaction with guaranteed state consistency.
• Solver competition: Enable a network of solvers to bid on fulfilling user intents by streaming live chain state.
• Trust-minimized proofs: Use Substreams' deterministic output as a verifiable data source for optimistic or ZK verification layers.

Enabling platforms like Goldsky and The Graph to serve high-frequency, subscription-based data feeds.

• Infinite parallel consumers: One Substream can serve thousands of independent subscribers with no performance degradation.
• Custom data products: Publishers can transform raw chain data (e.g., NFT floor prices, DEX volumes) into derived streams.
• Pay-per-compute model: Monetize data transformation logic, not just raw data access, creating new revenue streams.

Automated, real-time transaction monitoring for sanctions screening and regulatory compliance (e.g., TRM Labs, Chainalysis).

• Streaming analytics: Apply complex entity-clustering and pattern-detection algorithms to live transaction flows.
• Multi-chain coverage: Monitor Tornado Cash interactions or OFAC-sanctioned addresses across all major chains simultaneously.
• Immutable audit trail: Every alert is backed by a cryptographically verifiable Substream execution trace.

Powering fully on-chain games and autonomous worlds (e.g., Dark Forest, Loot Survivor) with sub-second state synchronization.

• Deterministic game ticks: Advance game state based on transaction events, not block times, enabling real-time interaction.
• Massively multiplayer proofs: Use Substreams to generate verifiable proofs of player actions and world state for clients.
• Cheat-proof mechanics: Game logic executes in the data layer, making front-running and state manipulation detectable in real-time.

Building real-time apps on standard RPCs is slow and expensive. Indexers like The Graph require custom subgraph development and suffer from ~2-10 second latency for finality. This kills UX for DeFi, gaming, and social apps.

• Cost: Paying for every eth_getLogs call on high-throughput chains.
• Speed: Block-by-block polling introduces inherent lag.
• Complexity: Managing subgraph syncing and hosting is operational overhead.

Substreams treats the blockchain as a firehose of raw data. Developers write Rust modules that define deterministic transformations. The network streams the resulting data streams directly to clients.

• Parallel Processing: Modules execute in parallel, enabling >10,000 blocks/sec processing speeds.
• Determinism: Every consumer gets the exact same output for a given block, enabling caching and p2p sharing.
• Composability: Chain data becomes a modular pipeline, not a monolithic index.

This enables previously impossible architectures. Think real-time portfolio dashboards across Ethereum, Arbitrum, and Solana, or intent-based bridges like Across and LayerZero that need instant state verification.

• Unified API: One Substreams endpoint can serve data for multiple chains (EVM, Solana, Cosmos).
• Event-Driven Apps: Build WebSocket-like services that push state changes, not poll for them.
• Data Markets: Deterministic outputs allow for trust-minimized data resale between indexers.

The power comes with a learning curve. You trade the familiarity of GraphQL for the performance of Rust-based Substreams modules. This is infrastructure for teams building at scale.

• Developer Onboarding: Requires Rust knowledge vs. GraphQL/AssemblyScript.
• Early Ecosystem: Fewer pre-built "substreams" than subgraphs, but growing fast.
• Operational Shift: Move from hosted indexer services to managing data stream consumers.