Jito ShredStream Guide: Raw Solana Shreds for Traders Outgrowing Yellowstone gRPC

Your p99 is 400 ms. Your sniper lands third. Your backrun dies to a pack of bots with tighter stacks. You run on Chainstack Yellowstone or Helius gRPC, you've tuned the client, you've colocated in Frankfurt, and the numbers still won't move. You Google. You read a thread. Someone mentions shreds.

This guide is for the developer who just hit that wall. Who realized Yellowstone gRPC is structurally not the fastest layer on Solana. Who started reading about Jito ShredStream and discovered it is not a signup away. Who is now wondering whether there is a shortcut between "run your own validator proxy" and "wait three weeks for Jito to email you back."

We built Shredline for that exact person. This guide is for you even if you do not end up using us.

Why Yellowstone gRPC is already as fast as it can be

Yellowstone gRPC reads Solana entries from a Geyser plugin. Geyser emits after the validator's Bank has parsed, verified, and committed a batch of transactions. By the time a gRPC message reaches your bot, the shreds that carried those transactions have already travelled through every stage of the validator pipeline:

• broadcast by the leader over UDP
• propagated through Turbine, Solana's gossip tree
• reassembled and FEC-recovered at the receiving validator
• parsed into entries
• executed by the Bank
• emitted to Geyser
• serialized into protobuf
• sent through a gRPC stream

Each of those steps is measured in milliseconds. They stack. The gap between "shred broadcast" and "Geyser emit" is typically 20 to 100 ms, dominated by block completion and Bank execution. Nothing your Chainstack, Helius, or Triton provider can do will close that gap. The architecture is downstream.

If you need to react to a transaction before it executes, you need to be upstream of Geyser. That means shreds.

What a shred actually is

A shred is a 1232-byte UDP packet. A Solana leader splits each block into shreds as it builds it, FEC-encodes them for loss tolerance, and broadcasts them through Turbine.

Shreds carry transactions before those transactions land in a confirmed block. They arrive 10 to 50 ms before the equivalent data appears in a Yellowstone gRPC stream. They are the earliest form in which Solana state exists outside the leader.

They are also raw bytes. No JSON, no decoded Transaction structs. If you want to extract a signal, you read specific byte offsets and deserialize yourself. That is the trade-off: the closer to the wire, the less ceremony, the more work. For latency-sensitive strategies, it is worth every byte.

How much latency you actually gain

We benchmarked raw UDP shred delivery against shreds shipped over gRPC. Same Frankfurt node, 16,523 dual-observed slots. Raw UDP arrived first on 98.84% of slots with a +8.5 ms p50 lead. Full methodology and reproducible code live in the published benchmark.

That is the gap within the shred layer, between pass-through UDP and gRPC-wrapped shreds. Against Yellowstone (entry layer), the gap widens to 20 to 100 ms depending on network conditions. Against confirmed blocks over JSON-RPC, hundreds of milliseconds.

On a Pump.fun migration, 8 ms is the difference between being the first wallet in the pool or the third. On a backrun, it is land or miss. The value of the gap scales with how competitive your use case is.

The official path: Jito ShredStream

Jito operates a block engine network that receives shreds from staked validators as they are broadcast. They expose this through jito-shredstream-proxy, an open-source Rust binary that connects to their block engine, authenticates with a keypair, and forwards shreds to your application over UDP.

To run it, you need four things:

1. An approval keypair. Jito filters ShredStream access. You submit a form, wait for review.
2. A server to run the proxy on. Persistent process, modest but non-zero CPU and network footprint.
3. Network configuration. You specify destination IP, port, and desired region. The proxy forwards UDP shreds there.
4. Ongoing operations. Rate limit of 20 heartbeats per minute per keypair. Regions are per connection. Shreds in Frankfurt and Tokyo means two proxy deployments.

The proxy itself is well-engineered. Jito's documentation is solid. The code is open-source and battle-tested. If you have infra time and the approval lands quickly, self-hosting is the correct long-term path.

Your three real options

Option A — Self-host jito-shredstream-proxy

Free after approval. Full control. Zero middleman. Optimal if you have infra time, your use case is approval-friendly, and your keypair timeline aligns with your trading launch. Expect 2 to 4 weeks end-to-end from first application to shreds landing in your app.

Option B — Helius Shred Delivery

Helius operates their own relationship with the shred layer and resells it via their Business plan (from $499/mo) or custom enterprise tiers. Signup is standard SaaS. Good fit if you want SDK support, historical replay, a polished dashboard, and are comfortable with the monthly minimum and KYC flow.

Option C — Shredline

We operate our own raw shred infrastructure, aggregating from multiple upstream sources and forwarding UDP shreds directly to your IP. Multi-region coverage, colocated near the fastest leaders. Pricing starts at 5 SOL/mo wallet-to-wallet with a free 1-hour trial. No approval, no signup, no SDK.

Raw shreds or decoded entries

If you want the fastest possible shreds on Solana, Shredline delivers both ends of the spectrum.

RAW — UDP shreds forwarded unchanged to your IP, exactly as leaders broadcast them. Zero server-side processing, shortest pipeline. You handle shred reassembly and FEC recovery on your side.

DESHRED — the same shreds, reassembled and decoded into entries server-side on an ultra-optimized hot path, then streamed to your IP. You receive ready-to-use transactions without touching wire format.

Shred decoding is the step that turns raw UDP packets into usable transactions. Each shred carries a 1232-byte slice of a block with FEC redundancy. Decoding reassembles the slices in order, recovers anything missing from the parity shreds, and parses the resulting bytes into entries and transactions. Doing it yourself (RAW) is the absolute shortest path but requires a decoder. Doing it on our side (DESHRED) saves you the engineering work with a pipeline tuned for minimum added latency.

RAW for minimum latency and maximum control. DESHRED for plug-and-play with decoded output. Either way, no approval, no signup.

Getting started with Shredline

Message @shredline on Telegram. Tell us the IP and port where you want shreds delivered. We provision a test stream within the hour. If it works, pay 5 SOL for a month of RAW tier. If it doesn't, walk away. We don't bill.

No signup, no SDK, no KYC. Read UDP, parse shreds, react.

Frequently asked questions