Your bot is not slow.
Your data is late.
Raw Solana shreds, pushed over UDP to your socket the instant the leader puts them on the wire — while the block is still being built. Geyser gRPC fires after the validator has already processed the entry. That is 87 milliseconds you are giving away, every slot.
Pay in SOL from your own wallet. No card, no KYC, no auto-renew.·All we need from you is an IP and a port.
- 0.0 ms
- p50 wire → your socket
- 0 ms
- head start over Geyser gRPC
- 0
- regions: NY + Frankfurt
- 0
- rate limits, ever
gRPC is not slow.
It is just downstream.
If you already run Geyser or Yellowstone, you have done the obvious optimisation. But a plugin fires after the validator has replayed the entry against its bank — and no amount of tuning moves a tap further up the pipe than where it is attached.
Shreds are attached one stage earlier: the leader's broadcast itself. That is the difference below, and it is structural, not a benchmark you can out-engineer.
Time from leader broadcast to your code seeing it
lower is bettertapped at the leader's broadcast — one hop, no processing
tapped after the validator replays the entry against its bank
after processing → serialisation → JSON encoding
by now the pool has moved twice
The gap to gRPC is where the trade lives. 87 milliseconds in which you have seen the transaction and every Geyser-fed desk has not. On a 400 ms slot that is a fifth of the block — enough to sign, submit and land before they have been told it happened.
Everyone on gRPC sees it together
Geyser feeds are commodity — your competitors subscribe to the same stage of the same pipeline. Racing them means racing on execution alone, from an identical start line.
You pay the worse price
Every millisecond of staleness is adverse selection. The fills that reach a gRPC-fed bot first are the ones nobody upstream wanted.
You tune the wrong thing
Teams burn months shaving microseconds off their strategy loop while attached to a tap that costs 87 milliseconds. The bottleneck was never the code, and profiling it will never show that.
This is the same second,
seen two different ways.
Left column is our UDP feed. Right column is a commodity RPC websocket watching the identical mainnet. Same transactions, same wall clock — one of them just gets there first.
slot 341,880,412 · shred 0/64
You are inside the slot the leader is still writing.
0.9 ms wire → callback
Kernel to your handler. No JSON, no HTTP, no queue.
FEC set complete · 0 gaps
Full set recovered. Nothing sampled, nothing dropped.
RPC confirms · +214 ms
That is the moment everyone else finds out.
Six strategies. One thing
decides all of them.
Every edge below comes down to the same question: who saw it first. Not who modelled it best, not who had the cleverest sizing. If you and your competition both subscribe to Geyser, you start from the same line and the race is a coin flip.
The first block is the whole trade
On a fair launch, the entire opportunity lives in the first few slots. Position in the queue is the product.
- The moment that decides it
- Leader shreds the create instruction
- What being late costs
- Geyser reports the mint ~88 ms later — and every other gRPC-fed sniper gets it at the same instant. You are racing a pack from an identical start line, on a curve that has already moved.
- Reading the wire instead
- You see the create instruction inside the slot it lands in — the same instant a co-located bot does — and your buy is signed and in flight before the Geyser plugin has even fired.
~0.9 ms
create → your handler
Not sure yours is latency-bound? Measure the gap between when a transaction was broadcast and when your handler ran. Under 10 ms and your code is the bottleneck. Around 90 ms and you are on a gRPC tap — no amount of optimising the loop recovers that.
Three steps. One of them is a port number.
There is no SDK to vendor, no gateway to authenticate against, no connection to keep alive. We push, you listen.
Pay in SOL
Pick a term, connect your wallet, send the transfer. We watch the chain for it — access switches on the moment it confirms. No invoice, no card, no KYC.
~15 seconds
Give us an IP and a port
One UDP socket on your server, per region. Paste it into your dashboard and we whitelist it on the New York and Frankfurt proxies. That is the entire integration — there is nothing to install on your side.
the only thing we need from you
Bind, and start reading
Shreds begin arriving as raw UDP datagrams. Deserialise them with Jito's reference deshredder, Agave's own shred crate, or your own parser. You own the hot path end to end.
packets, not promises
use std::net::UdpSocket;
// The socket you registered in the dashboard.
let sock = UdpSocket::bind("0.0.0.0:20000")?;
sock.set_nonblocking(true)?;
// A shred is at most 1228 bytes on the wire.
let mut buf = [0u8; 1500];
loop {
match sock.recv_from(&mut buf) {
Ok((len, _src)) => {
// Raw shred. Parse with solana_ledger::shred::Shred,
// or your own layout reader for the header only.
let shred = &buf[..len];
handle_shred(shred); // <- you are here, ~0.9 ms after the wire
}
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
Err(e) => eprintln!("recv error: {e}"),
}
}That is the whole client. There is no step four.
Every layer removed is a
millisecond you keep.
No decoding, no queueing, no serialisation, no handshake. The shortest path that exists between a leader's broadcast and your code is a UDP datagram, and that is exactly what you get.
Raw bytes. Nothing interpreted.
We do not decode, normalise, enrich or re-serialise. You receive the shred exactly as the leader broadcast it, header intact. Whatever your parser can do with it, it can do 200 ms sooner.
UDP, deliberately
No handshake. No retransmit stalls. No head-of-line blocking behind a packet you no longer care about. In a market, a dropped shred is cheaper than a late one — and FEC gets most of them back anyway.
Complete FEC sets
Data shreds and coding shreds, the whole set. Reconstruct anything the public network lost instead of waiting for someone else to rebuild the block for you.
Dual-region, deduplicated
New York and Frankfurt both fire at you. Take whichever copy lands first and discard the twin — a free head start on whichever side of the Atlantic the leader happens to be.
No rate limits. None.
Flat rate per day. We do not meter messages, throttle bursts, or bill you for bandwidth on a busy day. Congestion is exactly when you need the feed most.
Leader-adjacent
Cross-connected inside the two metros carrying the densest concentration of Solana stake. Physical distance is the one latency you cannot optimise away in software.
IP-whitelisted delivery
Your socket, and only your socket. No shared token to leak, nothing to rotate, no credential in your hot path to check.
Bring your own stack
Rust, Go, Python, C++ — if it can bind a UDP port, it can consume this. No SDK to vendor, no client library to fall behind our release cycle.
Two metros. Most of the world's stake.
Solana's validator set is not spread evenly across the planet — it clusters. We put a proxy inside each of the two buildings-worth of fibre that matter, and push from both at once.
New York
NYNY5 / Secaucus — US-East leader cluster
Cross-connected inside the metro that carries the densest concentration of North American stake. When a US leader turns the crank, you are one hop from the wire.
0.9 ms
2.4 ms
700+
99.98%
Frankfurt
FRAFRA1 / Interxion — DE-CIX adjacent
Sat on Europe's biggest exchange fabric, beside the heaviest European validator concentration. The other half of the world's stake, covered.
0.8 ms
2.1 ms
900+
99.98%
Every plan includes both regions — we do not sell them separately, because taking the first of two copies is the entire point.
The only thing as fast as a shred feed
is being the validator.
Running your own peered validator gets you the same bytes at the same moment. It also costs you stake, hardware, a datacenter contract and an on-call rotation. We already did that part.
| ShredStream | Geyser gRPC | Public RPC | Own validator | |
|---|---|---|---|---|
| Where it taps the pipeline | Leader broadcast | After bank replay | After serialisation | Leader broadcast |
| Typical delivery latency | ~1 ms | 80–120 ms | 200–400 ms | ~1 ms |
| What arrives | Raw shreds | Protobuf events | Parsed JSON | Raw shreds |
| Rate limits | None | Per-plan | Aggressive | None |
| Who else has the same view | Very few | Every Geyser user | Everyone | Very few |
| What you operate | A UDP socket | A gRPC client | An HTTP client | A validator, 24/7 |
| Monthly cost | 14.25 SOL | $500–2,000 | Free–$500 | Stake + hardware + staff |
Every relay between the validator and you is latency
All shred feeds tap the same moment — the leader's broadcast. What separates them is what happens next. The common architecture forwards shreds into a central block engine first, and only then fans them out to subscribers. That intermediary is a full round-trip you pay on every single shred.
We are peered directly with validators and push straight to your socket. No block engine in the middle, no fan-out queue, no second hop. Both regions fire simultaneously and you keep whichever copy lands first, so a leader anywhere in the world reaches you by the shortest available path.
Direct peering
no block engine relay
Dual-region race
first copy wins, twin discarded
No metering
full rate on congested slots
Do not take our word for it — that is what the 24-hour term at 0.5 SOL is for. Run both feeds side by side, timestamp the same slot on each, and keep whichever wins.
0.5 SOL a day.
Cheaper the longer you commit.
One rate, both regions, no metering. Pay from your own wallet and the feed switches on as soon as the transfer confirms.
24 Hours
Prove it against your own bot.
0.5 SOL / day · 1 days
- Raw UDP shreds pushed to your IP:port
- New York + Frankfurt, both live
- Unlimited bandwidth — no per-message billing
- Full FEC set, nothing sampled or filtered
- 1 delivery destination, editable any time
- No auto-renew, no card, no commitment
7 Days
A full trading week of edge.
0.5 SOL / day · 7 days
- Raw UDP shreds pushed to your IP:port
- New York + Frankfurt, both live
- Unlimited bandwidth — no per-message billing
- Full FEC set, nothing sampled or filtered
- 1 delivery destination, editable any time
- Priority Telegram support
30 Days
The default for live desks.
0.475 SOL / day · 30 days
- Raw UDP shreds pushed to your IP:port
- New York + Frankfurt, both live
- Unlimited bandwidth — no per-message billing
- Full FEC set, nothing sampled or filtered
- 1 delivery destination, editable any time
- Priority Telegram support
- 5% off the daily rate
12 Months
Lock the rate. Ship the year.
0.45 SOL / day · 360 days
- Raw UDP shreds pushed to your IP:port
- New York + Frankfurt, both live
- Unlimited bandwidth — no per-message billing
- Full FEC set, nothing sampled or filtered
- 1 delivery destination, editable any time
- Rate locked for the full term
- Direct line to the infra team
- 10% off the daily rate
Terms stack instead of overlapping. Buy again while you are still active and the new term begins the moment the old one ends — you never pay twice for the same day.
no auto-renew · no card on file · no KYC · cancel by simply not renewing
The ones traders actually ask
When a Solana leader builds a block it does not wait for the block to finish before telling anyone. It slices entries into small fragments called shreds — roughly 1,200 bytes each — signs them, wraps them in forward-error-correction sets, and fires them across the validator network immediately. Shreds are how the block travels. Reading them means you see transactions during the slot they are landing in, rather than after the network has agreed on the result.
One day costs 0.5 SOL.
One lost race costs more.
Point your bot at our socket for twenty-four hours and log the gap yourself. If it is not there, you are out half a SOL. If it is, you have found the 87 milliseconds every Geyser-fed desk is still giving away, every single slot.
new york + frankfurt · raw udp · no rate limits