Decoded Shreds

Decoded Shreds is a Shred Stream: transaction-level data extracted from Solana shreds. Shreder handles reconstruction and decoding — your app receives a filtered transaction stream over gRPC instead of raw UDP packets.

The gRPC API is ShredStream (shredstream proto, ShrederService.SubscribeTransactions). That is the same API as the Rust transactions example.

It is a pre-execution stream for early intent detection. It does not include post-execution account state, logs, balances, or final outcomes. Use Geyser gRPC / Fastlane when you need that context.

In GeyserBench Decoded Shreds uses kind = "shreder".

Highlights

Transaction data derived from shreds
No self-hosted deshredder required
Geyser-style account filters: account_include, account_exclude, account_required
Multiple filters and multiple connections supported
Same ShredStream service also exposes SubscribeEntries (serialized Solana entries)

Filters

Filter	Behavior
`account_include`	Allows only transactions involving any of these accounts
`account_exclude`	Excludes transactions involving any of these accounts
`account_required`	Allows only transactions involving all of these accounts

Example SubscribeTransactionsRequest filter map (Pump.fun program), from the ShredStream client guide:

{
  "pumpfun": {
    "account_include": [],
    "account_exclude": [],
    "account_required": [
      "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
    ]
  }
}

Usage example (Rust)

Connect to a Decoded Shreds (ShredStream) endpoint, subscribe with filters.

git clone https://github.com/shrederxyz/shreder-rust-example.git
cd shreder-rust-example
# set the endpoint in src/examples/transactions/main.rs
cargo run --example transactions

use futures::{channel::mpsc::unbounded, sink::SinkExt};
use shredstream::{
    shreder_service_client::ShrederServiceClient,
    SubscribeRequestFilterTransactions, SubscribeTransactionsRequest,
};

#[tokio::main]
async fn main() -> Result<(), std::io::Error> {
    let entrypoint = "http://fra1.shreder.xyz:9991";
    let mut client = ShrederServiceClient::connect(entrypoint).await.unwrap();

    let request = SubscribeTransactionsRequest {
        transactions: maplit::hashmap! {
            "pumpfun".to_owned() => SubscribeRequestFilterTransactions {
                account_exclude: vec![],
                account_include: vec![],
                account_required: vec![
                    "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P".to_owned()
                ],
            }
        },
    };

    let (mut subscribe_tx, subscribe_rx) = unbounded();
    let response = client.subscribe_transactions(subscribe_rx).await.unwrap();
    let mut stream = response.into_inner();

    let _ = subscribe_tx.send(request).await;

    while let Some(message) = stream.message().await.unwrap() {
        println!(
            "Filters: {:?}, Sig: {:?}",
            message.filters,
            bs58::encode(
                &message.transaction.unwrap().transaction.unwrap().signatures[0]
            )
            .into_string()
        );
    }

    Ok(())
}

When to use it

Trading systems / searchers that need early transaction intent
Teams that want shred-path latency without operating a decoder
Workloads that need filtered streams, not full raw UDP

Prefer Binary when you need even lower latency via compact serialized payloads. Prefer Raw Shreds when you need packet-level control and run your own deshredder.

Endpoints

Decoded Shreds is available in all five regions.

Region	Endpoint
Frankfurt	`http://fra1.shreder.xyz:9991`
Amsterdam	`http://ams1.shreder.xyz:9991`
New York	`http://ny1.shreder.xyz:9991`
London	`http://lon.shreder.xyz:9991`
Tokyo	`http://tyo.shreder.xyz:9991`

Product: Decoded Shreds
Rust: shreder-rust-example (cargo run --example transactions)
Benchmark with GeyserBench (kind = "shreder")

Highlights

Filters

Usage example (Rust)

When to use it

Endpoints

Related

On this page