Raw Shreds
Raw packets plus your own decoder.
// Binary
Binary — the fastest path to Solana transaction data
Stream serialized Solana VersionedTransaction bytes efficiently extracted from shreds, filtered by account, and ready to deserialize directly in your application.
- Lowest latency stream
- Serialized
VersionedTransactionbytes - Reliably streamed via gRPC
- Geyser-style account filters
- No local shred decoder required
- Built for latency-sensitive transaction workloads
- Available across Shreder’s global regions
Binary gives you the fastest shred streaming data. Choose Fastlane/Geyser for post-execution state and Yellowstone compatibility.
Formatserialized VersionedTransaction bytes
TransportgRPC SubscribeBinaryTransactions
Filtersaccount_includeaccount_excludeaccount_required
Best forlatency-sensitive transaction processing
For public performance data, see Shreder’s shred stream benchmarks. View benchmarks and methodology →
// What it is
Transaction-level data from the shred path
Binary sits between raw shred delivery and fully decoded transaction streams. Instead of sending raw UDP packets to your infrastructure, Shreder Binary extracts transaction data from shreds and sends each update as a compact binary payload.
Each update contains serialized Solana VersionedTransaction bytes. Your client deserializes the payload locally, then applies your own strategy logic, instruction parsing, account matching, risk checks, indexing, or alerting.
- You do not run a validator to receive the stream.
- You do not maintain a raw deshredding pipeline.
- You keep local control over how each transaction is processed.
Binary is the right fit when you need the absolute lowest latency.
Decoded Shreds
Structured transaction stream with less local parsing.
Binary
Compact transaction bytes plus local deserialization.
// Why Binary
Less overhead between the network and your transaction logic
Use Binary when you need the earliest actionable transaction data.
Every step optimized
Our fastest Shred Stream: Shreder tunes decoding and delivery end to end so you get compact transaction bytes with minimal work on your side.
No raw decoder
Skip custom deshredding, reconstruction, packet deduplication, and low-level shred maintenance.
Local control
You own the hot path: deserialize compact transaction bytes and apply your own and business logic.
Filtered delivery
Use account filters to narrow the stream before it reaches your application.
// Use cases
Built for teams that care about transaction arrival time
Trading and market-making
React to Solana transaction flow with the fastest stream.
Searchers and execution
Monitor specific programs or accounts and move transaction bytes quickly into strategy logic.
DeFi monitoring
Track activity around pools, markets, token launches, and program-specific flows.
Memecoin snipers
Increase your transaction inclusion probability by being the first to see and execute trades on newly launched tokens.
// Benchmarks
Binary benchmarks
Representative runs under specific location, endpoint, and filter.
Run 004
Shreder Binary vs DoubleZero
Measured in Frankfurt, Teraswitch FRA2.
| Provider | p50 | p95 | p99 |
|---|---|---|---|
| Shreder Binary Frankfurt | 0.00 ms | 0.94 ms | 3.70 ms |
| DoubleZero Frankfurt | 1.69 ms | 15.06 ms | 24.45 ms |
Run 003
Shreder Binary vs Shyft RabbitStream
Measured in Frankfurt, Teraswitch FRA2.
| Provider | p50 | p95 | p99 |
|---|---|---|---|
| Shreder Binary Frankfurt | 0.00 ms | 0.00 ms | 0.00 ms |
| Shyft Frankfurt | 4.33 ms | 34.16 ms | 56.75 ms |
// How to use
Connect, subscribe, and deserialize in Rust
Point the client at your Binary endpoint, send a filter over gRPC, then deserialize each binary_transaction payload into a VersionedTransaction with bincode.
// rust · connect and subscribe
let entrypoint = "http://fra.binary.shreder.xyz:9991";
let mut client = ShrederBinaryServiceClient::connect(entrypoint)
.await
.unwrap();
let request = SubscribeBinaryTransactionsRequest {
transactions: maplit::hashmap! {
"pumpfun".to_owned() => SubscribeRequestFilterBinaryTransactions {
account_include: vec![],
account_exclude: vec![],
account_required: vec!["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P".to_owned()],
}
},
};
let (mut subscribe_tx, subscribe_rx) = unbounded();
let response = client
.subscribe_binary_transactions(subscribe_rx)
.await
.unwrap();
let mut stream = response.into_inner();
subscribe_tx.send(request).await.unwrap();// rust · read stream and deserialize
while let Some(response) = stream.message().await.unwrap() {
let update = response.transaction.expect("transaction must be present");
let tx = update.transaction.expect("transaction must be present");
let versioned_tx =
bincode::deserialize::<VersionedTransaction>(&tx.binary_transaction)?;
println!(
"filters: {:?}, slot {}, signatures: {}, instructions: {}",
response.filters,
update.slot,
tx.signatures.len(),
versioned_tx.message.instructions().len(),
);
}// Compare
Choose the right Data stream
Binary is the lowest-latency transaction stream.
| Product | Format | Best for | Customer-side work | Latency profile |
|---|---|---|---|---|
| Raw Shreds | Raw UDP shred packets | Teams with custom deshredding and strict latency budgets | Highest: receive, dedupe, reconstruct, decode, filter | Earliest feed; end-to-end speed depends on your decoder |
| Decoded Shreds | Structured transaction stream with filters | Production teams that want shred-level delivery without running a decoder | Low: subscribe and process transaction updates | Low latency with less operational overhead |
| Binary | Transaction data from shreds | Trading systems that want efficient transaction-level delivery | Low: no local decoding required | Lowest-latency transaction-level path for most workloads |
| Geyser gRPC / Fastlane | Yellowstone-compatible gRPC | Existing Geyser users, indexers, wallets, DeFi apps | Low: use existing gRPC tooling | Same interface; Fastlane is optimized for speed |
Binary is pre-execution transaction data. For account state, logs, balances, and execution results, use Geyser gRPC or Fastlane.
Not sure which stream to use? Talk to us →
// Requirements
What your client should handle
- Reconnect logic.
- gRPC client support—review the Shreder Binary proto.
VersionedTransactiondeserialization (e.g.bincodein Rust).- A Shreder Binary endpoint in your selected region.
- Transaction filters for target accounts or programs.
- Backpressure handling—keep slow work off the receive path when needed.
- Optional confirmation path through Fastlane, Geyser, or RPC.
- Alerts and health checks.
Binary FAQ
What is Shreder Binary?
Shreder Binary is an ultra low-latency transaction stream that delivers serialized Solana VersionedTransaction bytes extracted from shreds. It is designed for teams that want the absolute lowest latency without operating a raw shred decoder.
How is Binary different from Raw Shreds?
Raw Shreds sends raw UDP shred packets to your infrastructure. You are responsible for deshredding, reconstruction, deduplication, decoding, and filtering. Binary skips that raw packet layer and sends transaction bytes that your client can deserialize and process directly.
How is Binary different from Decoded Shreds?
Decoded Shreds is more ergonomic when you want a structured transaction payload with less local parsing work. Binary is closer to the transaction bytes—better when you want to further cut latency.
Is Binary faster than Raw Shreds?
For most transaction-focused workloads, Binary is faster to actionable transaction data because Shreder handles processing and sends compact transaction bytes directly. Raw Shreds might still be the right choice when you have a highly optimized in-house deshredding pipeline and need maximum packet-level control.
Is Binary a Geyser gRPC product?
No. Binary is a Shred Streaming product. Use Fastlane/Geyser when you need Yellowstone-compatible account updates, slots, blocks, or post-execution data.
How do I deserialize Binary transactions?
In Rust, use the public Binary example. It deserializes binary_transaction with bincode::deserialize::<VersionedTransaction>(&tx.binary_transaction).
What filters does Binary support?
account_include, account_exclude, and account_required.
Does Binary include execution results, logs, balances, or account updates?
No. Use Fastlane/Geyser for post-execution account updates, blocks, slots, or Yellowstone-compatible streams.
Which region should I use?
Use the region closest to your workload. Binary is available in Frankfurt, Amsterdam, and New York.
How should I measure Binary performance?
Measure first-detection share, p50/p95/p99 delay. Compare the same signatures across providers from the same region. See the Benchmarks page.
When should I choose Fastlane/Geyser instead?
When you need the Yellowstone interface or post-execution account updates, slots, and blocks rather than only transaction bytes.
How do I get access?
Start from the Shreder console or contact the team. We will provide endpoint and region guidance.
Ready to get Solana transactions faster?
Get transaction bytes from Shreder’s shred-streaming infrastructure and move them directly into your pipeline.