🐇RabbitStream Overview

Stream Transactions From Solana Shreds With gRPC Style Filters

On Solana, speed is everything for high-frequency trading and sniping bots. The fastest data comes from Shreds, which are raw data packets emitted at the earliest stage of processing. While Shreds provide the earliest transaction detection (pre-processing), they are missing the final details (transaction meta) like logs and confirmed results. They still contain enough information to be useful for speed-critical sniping strategies.

The Problem with Raw Shreds

While raw shreds offer unbeatable speed, working with them have their own challenges for developers:

• Filters not available, Data Overload: Shreds are unfiltered, meaning you get every single transaction on Solana—even the internal voting and failed ones—which creates a huge data load that's hard to handle. Any form of filtering is not available.

• Difficult Decoding Requirements: The data structure of raw shreds is complex and binary-encoded, making them incompatible with standard Solana parsing libraries and requiring custom, time-consuming decoding logic.

• Missing Transaction Context: Since shreds are unconfirmed, they lack the full transaction metadata (meta), including program logs, inner instructions, and pre/post token balances. This limits them primarily to simple sniping strategies.

• High Expense: Few providers offer raw/decoded shred streams, and those that do are often priced out of reach for independent developers and smaller teams.

Introducing RabbitStream: Shred Speed, gRPC Usability

RabbitStream provides real-time transactions extracted directly from shreds, coming straight from leaders, and streamed through a gRPC interface. It combines the delivery speed of shreds, and the usability and filtering power of Yellowstone gRPC.

Feature	How Rabbitstream solves it
Yellowstone gRPC Filtering	Use the exact same SubscribeRequest format as Yellowstone gRPC. Filter by accountInclude, accountRequired, and more—no complex decoding is required on your end.
Compatible Transaction Structure	Transactions are streamed with a structure similar to Yellowstone gRPC (minus the full meta data), making it instantly compatible with existing gRPC clients and processing logic.
Ultra-Low Latency	Feel Solana's pulse as it happens. RabbitStream provides the lowest latency for transaction detection possible outside of running your own validator cluster.

Allowed Filters in Rabbitstream: The Trade-Off

RabbitStream is designed for maximum speed, which means we get you the transaction data at the very start of the Solana process (Shredding).

Since RabbitStream capture the data before execution happens, certain information that is generated later in the pipeline is not available:

• No Execution Metadata: RabbitStream does not have fields that are created during the final processing stage (like logs, inner instructions, or precise error details).

• Limited Filters: Rabbitstream streams data from the pre-processed stage, and only transactions filters are allowed. It does not allow filtering by accounts, blocks, or slot number directly on the stream. This information is typically confirmed and compiled later by the RPC node.

Filter type	Yellowstone gRPC	RabbitStream
transactions	✅	✅
accounts	✅	❌
slots	✅	❌
blocks	✅	❌
blocksMeta	✅	❌
accountsDataSlice	✅	❌

Speed Advantage

We have already benchmarked RabbitStream's performance against standard Yellowstone gRPC by creating a simple Pump.fun Token Launch Detector. Our initial tests reveal a consistent speed advantage ranging from ~15ms to 100ms.

Rabbitstream Token Detector Examples [.ts]

We feel this will be a huge unlock for a lot of devs and await feedback from the community.