TL;DR

Fumarole is purpose-built for indexers, analytics, compliance, and any pipeline where missing a block isn't an option.

After months of beta testing across production workloads, Fumarole exits beta on June 1. Until then, it's available at no charge on any Triton plan. It's:

  • Reliable: server-side cursor tracking with 4 days of rolling retention. Disconnect and resume exactly where you left off, backfilling anything you missed automatically
  • Highly available: multi-node aggregation with automatic failover. Node restarts, upgrades, or outages don't interrupt your stream
  • Complete and accurate: at least once delivery guaranteed. Only whole blocks are served, with the full block data arriving before slot status updates
  • Scalable: persistent subscriber lets you distribute the full stream across multiple readers, each processing its own partition
  • Performant: 99% of blocks visible in under 410ms, on tip with confirmed server-side. Fast replay via parallel shards across multiple TCP connections

Solana streams weren't designed to be reliable

Solana produces a staggering volume of data. Some builders need it as fast as possible for trading and don't mind missing a few slots. Others have different priorities: indexers, analytics platforms, compliance tools, and accounting systems all depend on completeness and reliability, while speed is secondary.

For the latter, a consumer crash at 3 am or a 10-second network drop is a serious engineering problem. Stateless streams don't track your position, so when you lose the connection, you have no idea what you missed. Teams end up building replay logic to fill gaps, reordering logic to restore a deterministic sequence after reconnecting to a different node, and a state machine to determine whether a block is actually complete.

When any of it fails, even once, you get a corrupted state, broken reports, and hours spent tracing a single missing event.

Triton's solution: Yellowstone Fumarole

Fumarole is a persistent streaming service between Solana's Geyser data layer and your application, purpose-built for confirmed and finalised commitment levels where reliability is non-negotiable.

High availability

Fumarole aggregates data from multiple Solana nodes into a single, consistent timeline. If a node restarts, upgrades, or goes offline, your stream keeps flowing. No need for multi-node subscriptions or failover logic on your end.

Persistence

Every subscriber gets a server-side cursor that tracks its exact position in the stream. Data is retained for a rolling 4-day window, so your consumer can be offline for hours or days and resume without loss.

By default, Fumarole auto-advances the cursor as it delivers data. If you need tighter control, manual commitment lets you decide exactly when the cursor moves, so you can write to your database first and only confirm receipt after the write succeeds.

Whole blocks, guaranteed

Every block Fumarole delivers is complete: all transactions, account updates, and entries, with full data arriving before slot status updates. Each block is buffered in its entirety before being committed to storage, so you never have to wonder whether a block is done.

At-least-once delivery is guaranteed, so you never have a gap in your data.

Consistent ordering

Block ordering is deterministic across sessions. Disconnect at slot 102, reconnect after 105, and you'll receive slot 103 onward in the same order as if the connection never dropped. It's essential for any pipeline that depends on a reproducible view of history.

Streaming modes

The Rust client has three streaming modes.

  1. Slot-sequential delivers events one slot at a time, finishing slot N completely before starting N+1.
  2. Block stream delivers whole blocks as single payloads for logic that processes entire blocks at once.
  3. Raw stream sends events as they arrive without slot-sequential ordering. It's the fastest mode because it skips the reordering and buffering overhead.

Any mode can be paired with manual commitment for explicit cursor control, and all three benefit from parallel shard downloads.

Persistent subscriber

Persistent subscriber lets you distribute the stream across multiple readers when a single one isn't enough, enabling horizontal scaling. Even the full accounts stream can be split across readers, each processing its own portion of the data.

Dragon's Mouth compatibility

Fumarole outputs the same data and supports the same account and transaction filter APIs as Dragon's Mouth. If you already have a Dragon's Mouth integration, migration requires minimal code changes. The SDK includes a Dragon's Mouth adapter that lets you use Fumarole as a backend while keeping your existing processing logic intact.

Performance

Fumarole prioritises completeness over raw speed, but the architecture is designed to keep latency as low as possible within that constraint, while maximising throughput. Here's what we're seeing across production clusters:

  • Block ingestion: Fumarole's backend stays on tip with confirmed, with 99% of blocks going from buffering through storage to consumer-visible in under 410ms.
  • Parallel downloads: each block is split into many shards, each replicated across a fleet of storage servers, guaranteeing high availability. Your client leverages this to download blocks via parallel TCP connections, delivering the full block as fast as your connection allows.
  • Replay throughput: a client on a ~400 Mbps connection can catch up at ~10 full blocks per second with every transaction, account, and entry included. If co-located in the same data centre, that climbs to ~40 blocks / second.
  • Retention: Fumarole retains 4 rolling days of data. That's enough to recover from extended downtime, backfill gaps after a failed deploy, or replay a specific time window for auditing.

Getting started

Fumarole is now available on all Triton plans at no charge until June 1. After that, bandwidth usage is billed at $0.08 per GB. If you don't have an endpoint yet, you can self-onboard in under 2 minutes:

Once you have an endpoint, pick the SDK that fits your stack.

Rust is the primary client with slot-sequential streaming, block streaming, manual commitment, and parallel shard downloads. TypeScript and Python clients are also available, but don't yet support all the new features.

What's new for existing Fumarole users

If you've been using Fumarole during the beta period, here's what's new:

  • Sharded block storage: blocks are now split into shards replicated across a fleet of storage servers, enabling parallel downloads and significantly faster replay for the Rust client
  • 4 days of retention, up from ~23 hours during the beta
  • Three streaming modes in the Rust client: slot-sequential for ordered event processing, block stream for whole-block payloads, and raw stream for maximum throughput without reordering overhead
  • Manual commitment: set auto_commit: false to control exactly when your cursor advances
  • Simplified client API: the old DragonsmouthAdapterSession struct has been refactored into a cleaner streaming interface
  • Multi-region availability: EU cluster at ams.rpcpool.com, and US cluster at nyc.rpcpool.com