For the complete documentation index, see llms.txt. This page is also available as Markdown.
📐RabbitStream vs. Yellowstone gRPC
Decide between Solana Shreds based RabbitStream for earliest detection or Yellowstone gRPC for full transaction conext.
Flow of information
The difference in speed between Yellowstone gRPC and RabbitStream comes down to where in the Solana validator's data pipeline the information is extracted.
Yellowstone gRPC vs Rabbitstream: Flow of information
Solana Validator Steps (The Pipeline)
Gossip: Leader receives transactions.
Shredding: Leader breaks data into packets (Shreds) for network broadcast.
Execution: Transactions are run to determine the final outcome and generate meta (logs, fees, errors).
Geyser Hook: The validator makes the final, processed data available to plugins.
Yellowstone gRPC Flow
Extraction Point: Data is extracted after it RPC processes the transaction, which is Step 4 (Geyser Hook), after execution.
Latency: Slower than shreds as the transaction is processed to generate the inner instructions, meta, logs and all the other fields.
Data Completeness: Includes full transactionmeta, logs, and final status.
Best For: Reliable indexing and analytics requiring full transaction context.
Rabbitstream Flow
Extraction Point: Data is extracted from raw UDP Shreds, without the RPC being involved in any stage.
Latency: Ultra-Low (Fastest). Minimal delay from the leader.
Data Completeness: Missing all meta data, logs, and final execution status.
Best For: Sniping and time-critical alerts where speed is the only priority.
Difference between RabbitStream & Yellowstone gRPCs
RabbitStream
Yellowstone gRPCs
Extraction Point
Data is extracted before it is processed by RPC, offering maximum immediacy and raw access.
Earliest detection is at Processed commitment, when RPC processes and executes the transaction.
Latency
Ultra-Low (Fastest). Minimal delay, as data is captured at the earliest possible stage.
Slower than shreds as the transaction is processed to generate the inner instructions, meta, logs, etc. High latency.
Data Availability
Missing some meta data, logs, and final execution status upon initial capture, requiring external validation.
Includes full transaction meta, logs, and final status (executed or failed). Comprehensive data.
RabbitStream vs Yellowstone gRPC — the key architectural difference
Yellowstone gRPC is a Geyser plugin that runsinside an RPC node. It is bound to that node's execution pipeline and can only emit data after the node has fully replayed the transaction.
RabbitStream operates entirely outside the RPC layer — listening directly to raw UDP shreds from multiple sources across the Solana network. No RPC node involved at any point.
RabbitStream vs. Yellowstone gRPC: Benchmarks
RabbitStream's architectural advantage over Yellowstone gRPC is structural — it operates before the RPC execution pipeline entirely. The benchmarks below quantify that gap on live mainnet traffic across three regions.
Methodology
Both runs used geyserbench v1.2.2, an open-source benchmarking tool by Solstack that connects to two endpoints simultaneously on the same live transaction stream and tags every delivery by which arrived first. No runs were excluded.
Tool: geyserbench v1.2.2
Sample size: 10,000 valid transactions per run
Runs: 2 per region (6 total)
Regions tested: Frankfurt (FRA), New York (NY), Amsterdam (AMS)
Test node: Dedicated bare-metal server (AMD EPYC 9254, 384 GB RAM), co-located in the respective test region with under 1ms ping to both endpoints. Client-side network variance was not a factor in the results.
Results Summary
Region
RabbitStream Win Rate
Yellowstone P50 Behind
Yellowstone P95 Behind
Yellowstone P99 Behind
Frankfurt (FRA)
~99.77% avg
~11.98ms
~30.36ms
~42.40ms
New York (NY)
~99.94% avg
~7.24ms
~20.88ms
~28.55ms
Amsterdam (AMS)
~97.86% avg
~5.99ms
~20.92ms
~30.38ms
Frankfurt (FRA) — Full Results
RabbitStream vs Yellowstone gRPC: Benchmarks (Frankfurt)
Run
RabbitStream Win Rate
Yellowstone P50 Behind
Yellowstone P95 Behind
Yellowstone P99 Behind
Run 1
99.68% (9,968 / 10,000 txns)
16.12ms
36.72ms
50.48ms
Run 2
99.87% (9,987 / 10,000 txns)
7.84ms
24.00ms
34.31ms
New York (NY) — Full Results
RabbitStream vs Yellowstone gRPC: Benchmarks (New York)
Run
RabbitStream Win Rate
Yellowstone P50 Behind
Yellowstone P95 Behind
Yellowstone P99 Behind
Run 1
99.96% (9,996 / 10,000 txns)
6.66ms
19.20ms
24.32ms
Run 2
99.92% (9,992 / 10,000 txns)
7.82ms
22.55ms
32.78ms
Amsterdam (AMS) — Full Results
RabbitStream vs Yellowstone gRPC: Benchmarks (Amsterdam)
Run
RabbitStream Win Rate
Yellowstone P50 Behind
Yellowstone P95 Behind
Yellowstone P99 Behind
Run 1
98.53% (9,853 / 10,000 txns)
7.00ms
24.54ms
36.34ms
Run 2
97.20% (9,720 / 10,000 txns)
4.97ms
17.29ms
23.79ms
Amsterdam showed a slightly wider variance in win rate across runs compared to Frankfurt and New York, though RabbitStream arrived first in over 97% of transactions in both iterations. Yellowstone's P99 ranged from 23.79ms to 36.34ms across the two runs. Both feeds delivered zero backfill.
What the numbers mean
RabbitStream's P50 of 0.00ms across all runs is not a rounding artifact — it reflects delivery at the shred layer, before any RPC node has begun processing the transaction. Yellowstone gRPC can only emit data after the block has been fully replayed by the node. The latency gap in the tables above is that processing overhead, and it is structural rather than incidental — it will exist regardless of hardware or network conditions.
Both feeds delivered zero backfill across all runs and all regions. The shred-layer speed advantage carries no reliability trade-off.
Response structures
While both Rabbitstream and Yellowstone gRPC use the same gRPC subscription method, the content within the streamed transaction is different. This key difference is entirely the meta field. Yellowstone gRPC delivers data after being processed, this having a complete meta field with logs, fees, and final balances. RabbitStream, however, delivers data captured at the high-speed Shred level (pre-execution by the RPC), meaning the valuable meta data is not available. This side-by-side comparison illustrates the trade-off between ultra-low latency and full transaction context.
Yellowstone vs Rabbitstream: Response Structures
The following section denotes the detailed response structures. Please note, that the transactions received are in raw format, we have parsed them just for understanding. Also, this is a sample transaction, some parts of it may have been trimmed down for better visibilty, but the structure is the same.
