NoLimitNodes
PricingDocsBlogAcademyAboutSupportContact
Log in
Blog/Engineering

How to Decode Jito Shreds: Turn Solana Shreds into Transactions

From UDP socket to transaction: receive Jito-compatible shred packets, parse the 83-byte header, buffer and recover FEC sets, deshred into entries, and handle the edge cases that break naive decoders.

N
NoLimitNodes Engineering
Infrastructure Team
Nov 17, 20268 min read
On this page +
  • 01Where Jito shreds come from now
  • 02Step 1: Receive shred packets
  • 03Step 2: Parse the shred header
  • 04Step 3: Buffer and recover
  • 05Steps 4 and 5: Deshred and deserialize
  • 06Edge cases that break deshredders
  • 07FAQ
  • 08Start decoding shreds today
  • 09Sources

To decode Jito shreds, you receive raw shred packets over UDP, group the data shreds by slot, order them by index, join their payloads up to a “data complete” flag, and deserialize the bytes into Solana entries. Each entry holds a list of transactions you can read before the block finishes executing.

This guide is for developers building sniper bots, MEV searchers, market makers or indexers who already have, or are about to get, a Jito-compatible shred feed. It walks through the pipeline from UDP socket to transaction, shows the header layout, and lists the edge cases that break naive deshredders.

TIP / The pipeline in five steps
  1. Receive UDP packets on your shred port, one shred per packet.
  2. Parse the common header: slot, index, variant, FEC set.
  3. Buffer data shreds per slot and FEC set, and recover missing ones from coding shreds if needed.
  4. Deshred contiguous data shreds into a byte buffer at each data-complete boundary.
  5. Deserialize the buffer into Vec<Entry> and read each entry's transactions.
Five-stage deshred pipeline: receive UDP packets, parse the shred header, buffer and recover by slot and FEC set, deshred contiguous data shreds, and deserialize entries into transactions.
From UDP datagram to unexecuted transaction. Dedupe and FEC recovery happen before deshredding.

01Where do Jito shreds come from now?#

Jito ShredStream used jito-shredstream-proxy to pull shreds from Jito's Block Engine and forward them to your DEST_IP_PORTS. It could also decode them and stream transactions over gRPC, and the repo includes a deshred example client. Jito announced that its hosted ShredStream service would shut down on September 5, 2026.

The packets themselves are raw Solana shreds, and that is still what most deshredders expect. NoLimitNodes Shredstream sends raw mainnet shreds in a format compatible with the Jito proxy and client path, straight to a UDP port you verify, so the code below works without running the Jito proxy. New to shreds? Start with Jito Shreds Explained.

02Step 1: Receive shred packets#

Each UDP datagram holds one shred. Bind a socket on a public IPv4 host, and keep the receive buffer large, because shred traffic is bursty.

receive.py
python
import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Linux caps this at net.core.rmem_max; raise that sysctl too
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 64 * 1024 * 1024)
sock.bind(("0.0.0.0", 20000))  # the port you registered as your destination

while True:
    packet, _ = sock.recvfrom(2048)  # one shred per datagram, about 1,200 bytes
    handle(packet)

To check that packets are arriving, run sudo tcpdump -n -i any 'udp and dst port 20000'. Jito's docs describe healthy traffic as many packets of about 1,200 bytes.

03Step 2: Parse the shred header#

Every shred starts with an 83-byte common header. Data shreds add a 5-byte data header, and coding shreds add a 6-byte coding header.

OffsetSizeFieldNotes
064signatureLeader signature
641variantShred type (data or coding) and format
658slotu64
734indexu32, position in the slot
772versionu16, cluster shred version
794fec_set_indexu32, first index of the FEC set
832parent_offsetData header: slot minus parent slot
851flagsData header: includes the data-complete and last-in-slot bits
862sizeData header: bytes of headers plus payload actually used
Common header and data shred header layout, as defined in Agave's solana-ledger crate. Integers are little-endian.
Byte layout of a Solana data shred: 64-byte signature, 1-byte variant, 8-byte slot, 4-byte index, 2-byte version and 4-byte FEC set index make the 83-byte common header, followed by a 5-byte data header with parent offset, flags and size, then the payload.
The first 88 bytes of a data shred. Merkle shreds also reserve space at the end of the packet for a proof.

A minimal header parser for routing packets by slot:

header.py
python
import struct

def parse_header(pkt: bytes) -> dict:
    variant = pkt[64]
    slot, index, version, fec_set = struct.unpack_from("<QIHI", pkt, 65)
    return {"variant": variant, "slot": slot, "index": index,
            "version": version, "fec_set_index": fec_set}

Payload bounds also depend on the shred variant. Newer Merkle shreds reserve space at the end of the packet for a Merkle proof. For that reason, do the full payload extraction with the Agave shred types shown in step 4 rather than by hand.

04Step 3: Buffer and recover#

  • Group shreds by slot, then by fec_set_index.
  • Deduplicate on slot, index and shred type (data or coding). You will see duplicates, especially with more than one feed.
  • Recover: if a data shred is missing but you hold enough shreds from its FEC set, run Reed-Solomon recovery with the coding shreds. Agave's solana-ledger crate implements this.
  • Expire buffers for old slots so memory stays bounded.

05Steps 4 and 5: Deshred into entries and transactions#

When you hold a contiguous run of data shreds ending in one with the data complete flag, join their payloads and deserialize the bytes as a Vec<Entry>. Each Entry has num_hashes, hash and transactions.

In Rust, the Agave crates do the heavy lifting. This is the same approach as the deshred example in the Jito proxy repo:

deshred.rs
rust
use solana_entry::entry::Entry;
use solana_ledger::shred::{Shred, Shredder};

// 1. Parse each UDP packet into a shred.
let shred = Shred::new_from_serialized_shred(packet.to_vec())?;

// 2. Collect data shreds for one slot, sorted by index,
//    up to and including the one flagged data-complete.
let payload: Vec<u8> = Shredder::deshred(&data_shreds)?;

// 3. Decode entries, then transactions.
let entries: Vec<Entry> = bincode::deserialize(&payload)?;
for entry in entries {
    for tx in entry.transactions {
        // tx is a VersionedTransaction: signatures, account keys, instructions
        println!("{}", tx.signatures[0]);
    }
}
WARNING / Pin your crate versions
Function names and signatures in solana-ledger and solana-entry change between Agave releases. Treat the snippet as an outline, pin the crates to the version your team runs, and check the crate docs.

From here, filter on the program IDs you care about, such as Pump.fun, Raydium or Meteora, and decode instructions with their IDLs. Remember that you are reading unexecuted transactions. A swap you see may still fail.

06Edge cases that break deshredders#

ProblemSymptomFix
Duplicate shredsSame transaction emitted twiceDedupe on slot, index and shred type before deshredding
Missing data shredsDeserialization errors mid-slotWait for coding shreds and run FEC recovery, or skip the batch
Out-of-order arrivalTruncated entriesBuffer by index and deshred only contiguous runs
Forks and skipped slotsTransactions that never landTreat shreds as unconfirmed. Confirm with gRPC or RPC before acting on state.
Wrong shred versionGarbage or non-mainnet dataDrop shreds whose version does not match mainnet
Socket overflowGaps under loadRaise the receive buffer, pin the receiver to a core and keep parsing off the receive thread

Pre-production checklist

  • Receiver isolated, with only the shred UDP port exposed. Raw UDP has no authentication or encryption.
  • Dedupe, FEC recovery and slot expiry in place
  • Packet-rate and deshred-error metrics with alerts
  • Unconfirmed transactions confirmed with Yellowstone gRPC before you rely on state
  • Agave crate versions pinned and upgraded with the cluster

07Frequently asked questions#

Do I need jito-shredstream-proxy to decode Jito shreds?

No. The proxy received shreds from Jito’s Block Engine, forwarded them, and could stream decoded transactions over gRPC. Decoding itself only needs the raw packets plus Agave’s shred and entry types. With NoLimitNodes Shredstream, Jito-compatible packets arrive directly at your UDP port, with no proxy.

Why do I get deserialization errors when deshredding?

The usual causes are missing or out-of-order data shreds, duplicates, or deshredding across a boundary that is not data-complete. Buffer shreds by slot and index, dedupe them, recover gaps with coding shreds, and only deserialize contiguous runs that end with the data-complete flag.

Can I decode Jito shreds in Python or TypeScript?

You can parse headers and route packets in any language. Payload extraction, Merkle shred handling and Reed-Solomon recovery are easiest with Agave’s Rust crates. A common pattern is a small Rust deshredder that passes transactions to your Python or TypeScript strategy over a local socket or queue.

Are transactions from shreds final?

No. They are what the leader included before execution and voting. The slot can be skipped or land on a fork, and transactions can still fail. Use shreds for the earliest signal, then confirm outcomes with Yellowstone gRPC or RPC at the commitment level you need.

08Start decoding shreds today#

Decoding Jito shreds is a pipeline: receive, parse, buffer, deshred, deserialize. The hard part is getting the packets early and reliably. The code stays the same whichever Jito-compatible feed you use.

Get a Jito-compatible shred feed with NoLimitNodes Shredstream: register a UDP destination, verify it, and point this deshredder at it. Follow the setup docs or talk to sales.

Related reading: Jito Shreds Explained · Migrate from Jito ShredStream · Solana Shredstream Guide

09Sources#

  • Jito docs: ShredStream, checked November 17, 2026
  • jito-labs/shredstream-proxy on GitHub, including the deshred example
  • Agave source: solana-ledger shred module
#solana#decode jito shreds#jito shreds#deshred#solana shredstream#rust#python
N
NoLimitNodes Engineering
Infrastructure Team

The team that runs our RPC, WebSocket, gRPC, and streaming fleet. We write about what we operate: validators, Geyser pipelines, and the request paths in between.

On this page
  • 01Where Jito shreds come from now
  • 02Step 1: Receive shred packets
  • 03Step 2: Parse the shred header
  • 04Step 3: Buffer and recover
  • 05Steps 4 and 5: Deshred and deserialize
  • 06Edge cases that break deshredders
  • 07FAQ
  • 08Start decoding shreds today
  • 09Sources
↑ back to top
///Read next
GuidesNov 17, 2026

Jito Shreds Explained: What Solana Shreds Are and Why Traders Want Them

Jito shreds are ordinary Solana shreds with faster delivery. What a shred contains, data vs coding shreds, Turbine vs shred streams, why traders want them first, and what they cannot tell you.

#solana#jito shreds#solana shreds
8 min read
EngineeringJun 24, 2026

Backtesting Solana Trading Strategies with Historical Raw Blocks (2026)

How to backtest Solana DEX arb, token sniping, liquidation, and LP strategies using historical raw blocks and parsed trading datasets. Python, DuckDB, and Rust.

#solana#backtesting#historical-data
18 min read
← Older
Jito Shreds Explained: What Solana Shreds Are and Why Traders Want Them
Run it yourself

Every benchmark in this blog runs against our public endpoints.

Spin up an RPC, WebSocket, or gRPC endpoint in under a minute. Flat monthly pricing. Reproduce the numbers for your own workload.

See pricing

Ready to get started?

Choose a plan and start building in under 30 seconds.

Talk to Sales
NoLimitNodes

Solana RPC infrastructure built for performance and scale.

RPC Access
  • Solana HTTP RPC nodes
  • Solana WebSocket nodes
  • Yellowstone gRPC nodes
  • Solana Shredstream
  • UltraSend transaction relay
Infrastructure
  • Compute Platform
  • VPS
  • VDS
  • Bare Metal
  • Geyser Plugin Hosting
Enhanced Streams
  • PumpFun
  • PumpSwap
  • Raydium
  • Orca
  • Meteora
  • System Events
  • Browse all Solana Enhanced Streams →
Program Streams
  • PumpFun
  • PumpSwap
  • Raydium CLMM
  • Orca Whirlpool
  • Meteora DLMM
  • Jupiter Swap
  • Jupiter Perps
  • Kamino Lending
  • Browse all 37 Solana programs →
Trading
  • EZWallet
Analytics
  • Historical Datasets
  • Historical Raw Blocks
Company
  • About
Resources
  • Pricing
  • RPC Rate Limits
  • Custom Development
  • Documentation
  • Blog
  • Academy
  • Support
  • Contact Sales
Compare
  • Yellowstone gRPC vs LaserStream
  • Triton vs Helius
  • Raydium API vs Helius
  • PumpSwap API vs Bitquery
  • QuickNode Streams vs NLN
  • All comparisons →
Legal
  • Terms & Conditions
  • Privacy Policy
© 2026 CLR3 Inc., operating as NoLimitNodes. Registered in Ontario, Canada. All rights reserved.solana mainnet