TL;DR

  • Shreds are the earliest form of Solana block data available; you see transactions before the block is assembled
  • Triton streams shreds directly to a UDP port on your server
  • Our open-source deshred-example repo turns those shreds into transactions, which you can test with a single command
  • From there, you adapt the example to feed your own systems
💡
Trading in the Green Candle competition? This is your setup guide. Start by registering at Frontier Traders and set up your Triton account.

If you're serious about reacting to Solana in real time, shreds are as early as it gets. Validators break each block into small fragments called shreds and broadcast them while the block is still being produced. Most infrastructure waits for those fragments to be reassembled, verified, and served up as a confirmed block. With shred streaming, we deliver the raw fragments straight to your server as they arrive, and you reconstruct the transactions yourself.

This guide takes you from a fresh server to live transactions printing in your terminal. If you'd rather have us handle the reconstruction and just want deshredded transactions over gRPC, use a SubscribeDeshred subscription instead; everything below is for consuming raw shreds directly.

What you'll need to register for Triton as part of the Green Candle Cup

Shred streaming works differently from an RPC endpoint. There's no URL to call; we push packets directly to your machine. That's why onboarding asks for more than an email address:

  • A Triton account
  • A server you control, in a data centre in Frankfurt, Amsterdam, New York, London, or Tokyo
  • Your server's IP address, desired port and data centre, so we know exactly where to send your stream

Once you're onboarded, shreds start arriving on your UDP port.

From shreds to transactions

A raw shred isn't much use on its own. To trade on the data, you need to reassemble shreds into entries and unpack those entries into transactions. That's exactly what our open-source deshred-example does.

Clone the repo and run it:

git clone https://github.com/rpcpool/deshred-example
cd deshred-example
cargo run --release -p deshred-minimal -- 0.0.0.0:20000

The listener binds your UDP port, ingests the incoming shreds, and prints every transaction it recovers. Under the hood, it runs the full pipeline: shreds are reassembled into entries, and the entries are unpacked into VersionedTransaction objects. If transactions are printing, your stream is live.

Video guide to getting started with shred streaming

💡
Need help getting started and participating in the Green Candle Cup? Join our private Telegram Group for support from the Triton team.

Where to go next

Printing to a terminal proves the setup works. From here, adapt the example for your own code:

  • Lift the pipeline into your own binary. The deshredding logic lives in a library crate separate from the CLI, so you can embed it directly in your trading system rather than parsing terminal output
  • Filter for what you care about. Once you hold VersionedTransaction objects, you can match on the programs, accounts, and instructions relevant to your strategy
  • Feed your existing stack. Anything you currently trigger from a gRPC or WebSocket feed can run from deshredded transactions, and it'll fire earlier

Our engineers built this stack and support it directly, so if you get stuck during setup, contact support and you'll be talking to the people who wrote the code.

Get your endpoint, point the stream at your server, and start working from the earliest data on Solana.