Introducing RabbitStream: Detect Unconfirmed (pre-processed) Solana Transactions with Shyft gRPC

Stream pre-processed Solana transactions straight from Shreds with gRPC filters.

“Speed is everything on Solana.” ⚡

Whether you’re building a sniping bot, MEV searcher, or a high-frequency trading system, you already know the fastest data comes from shreds.

These raw shreds, broadcast by validators, before execution even happens — gives you unfiltered access to every transaction on the network.

🤯 But Here’s the Problem: Raw Shreds are a Nightmare to work with.

You get every transaction on the network. Unfiltered. Binary-encoded. Missing execution metadata. And you need custom decoding logic just to make sense of it all**.**

🐰 RabbitStream fixes this!

RabbitStream delivers real-time Solana transaction data at shred speed with Yellowstone gRPC filtering. Perfect for token sniping, MEV detection, and high-frequency trading on Solana.

What is RabbitStream?

RabbitStream = Superior speeds of Shreds + Ease of Use like gRPC

RabbitStream streams transactions directly from Solana shreds, but delivers them in the same structured format that you’re used to with, i.e Yellowstone gRPC.

Same filters. Same subscription format. Just 30–100ms faster ⚡

Get Team Shyft’s stories in your inbox

Join Medium for free to get updates from this writer.

Get shred-speed data with gRPC filtering. No raw shred parsing required.

Why We Built It?

Solana processes transactions in stages:

1. Shredding — Validators receive transactions and broadcast shreds
2. Execution — Transactions run, generating logs and metadata
3. Geyser — Standard gRPC extracts fully processed data

• Standard gRPC extracts information at the Geyser phase (last one). You get complete data, but you wait a bit longer.
• But RabbitStream extracts information at the Shredding phase itself. You get data faster, but without execution logs and inner instructions.

What Makes It Different

• **Use Your Existing Code
  **Same SubscribeRequest format as Yellowstone gRPC. Filter by accounts, programs, or transaction types. Switch endpoints and keep your code.
• **Structured Transactions
  **No binary decoding. You get signatures, account keys, instructions, and basic metadata in a familiar format.
• **30–100ms Faster
  **We benchmarked RabbitStream against standard Yellowstone gRPC with a Pump.fun token detector. Consistent speed advantage across all tests. View the benchmark code →
• **Direct From Leaders
  **Shreds come straight from Solana validators across multiple regions. No relay delays.

When to Use RabbitStream?

Use RabbitStream when:

• You’re sniping token launches (Pump.fun, Raydium, Orca)
• You’re detecting MEV or arbitrage opportunities
• You need the fastest transaction alerts possible

Use gRPC when:

• You need transaction logs and inner instructions
• You need execution results and error details
• Data completeness matters more than speed

Quick Start

Here’s a basic Pump.fun code:

import "dotenv/config";import Client, {  CommitmentLevel,  SubscribeRequest,  SubscribeRequestAccountsDataSlice,} from "@triton-one/yellowstone-grpc";const client = new Client(  "https://rabbitstream.ams.shyft.to/",  process.env.X_TOKEN,  undefined);const req: SubscribeRequest = {  accounts: {},  slots: {},  transactions: {    pumpFun: {      vote: false,      failed: false,      signature: undefined,      accountInclude: ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],      accountExclude: [],      accountRequired: [],    },  },  transactionsStatus: {},  entry: {},  blocks: {},  blocksMeta: {},  accountsDataSlice: [] as SubscribeRequestAccountsDataSlice[],  ping: undefined,  commitment: CommitmentLevel.PROCESSED,};async function handleStream(client: Client, args: SubscribeRequest) {    console.log(`Subscribing and starting stream...`);  const stream = await client.subscribe();    const streamClosed = new Promise<void>((resolve, reject) => {    stream.on("error", (error) => {      console.log("ERROR", error);      reject(error);      stream.end();    });    stream.on("end", () => {      resolve();    });    stream.on("close", () => {      resolve();    });  });    stream.on("data", (data) => {    console.log("Received data....");    console.dir(data, { depth: null });  });    await new Promise<void>((resolve, reject) => {    stream.write(args, (err: any) => {      if (err === null || err === undefined) {        resolve();      } else {        reject(err);      }    });  }).catch((reason) => {    console.error(reason);    throw reason;  });  await streamClosed;}async function subscribeCommand(client: Client, args: SubscribeRequest) {  while (true) {    try {      await handleStream(client, args);    } catch (error) {      console.error("Stream error, restarting in 1 second...", error);      await new Promise((resolve) => setTimeout(resolve, 1000));    }  }}subscribeCommand(client, req);

That’s it. Same filtering as Yellowstone, just faster!

🛠️Looking for more technical details?

Understand the speed difference, response structures, or see more examples?

• Full RabbitStream Documentation →
• RabbitStream vs Yellowstone Comparison →
• Speed Benchmarks →

👉Try RabbitStream Now

(P.S — RabbitStream is LIVE🔴 for all Shyft users)

Read the Docs →
Find out More on Rabbitstream →