Pick raw shreds when you want transactions at the earliest point the network exposes them and you are willing to run every layer above the packet yourself. Pick a managed stream when you need execution results, logs or account state delivered for you, and would rather pay someone to operate decoding, ordering and reconnects.
The two models, defined#
A raw shred feed sends the pieces of each block to your server as UDP datagrams while the leader is still producing it. Once you reassemble them, a block becomes a list of entries, and each entry holds nothing but a hash count, a hash and the signed transactions, sequenced as the leader chose (E4 tech facts X-01). Everything else is your code.
A managed stream is run by a provider whose node executes each transaction first and then sends you updates. A Geyser-style transaction update, for example, pairs the transaction with its TransactionStatusMeta: whether it succeeded, its logs, its inner instructions and its balance changes. Someone else has already received, recovered, decoded and replayed the data before it reaches you.
The question is not which data is better. It is which layers you want to own.
Who owns each layer#
| Layer | Raw shred feed | Managed stream |
|---|---|---|
| Receiving packets | You run a UDP receiver and size its buffers | Provider |
| Recovering lost pieces and reassembling the block | You, with erasure recovery | Provider |
| Turning entries into transactions | You parse three transaction formats: legacy, v0 and v1 | Provider |
| Resolving lookup table addresses | You fetch and cache table accounts | Provider, usually included |
| Decoding program instructions | You, from IDLs or program source | Provider for the programs it supports, you for the rest |
| Execution status, logs, balances | Not available from shreds at all | Included |
| Account state | Not available from shreds | Often available as account updates |
| Confirming what you saw | You check status later | Arrives at the commitment you request |
| Reconnects and gaps | You detect and backfill | Provider tooling, within its limits |
| On-call when something breaks | Your team | Provider for their part, your team for yours |
Read the right column carefully: "provider" means the work exists, just not on your rota. It also means the provider's schema, timing and program coverage become your constraints.
What only a managed stream can hand you#
Execution output exists only after a validator replays the block. The outcome, any error code, the program's log output, the nested calls it made, how balances moved and how much compute it burned are all fields of TransactionStatusMeta, which is produced by execution and served by RPC or Geyser (E4 tech facts X-02). No amount of decoding on your side recovers them from shreds.
That matters more than it first appears:
- A swap's actual output amount is an execution result. From shreds you see the input amount and the minimum the user accepted.
- Events written with Anchor's
emit!are log lines, andemit_cpi!events are inner instructions. Both are absent from raw transactions (E4 tech facts X-03). - Account balances after a transaction are only known after it runs.
If your product shows any of these to a user, you need an execution source, either as your main feed or as a second one.
What only a raw feed can hand you#
A raw feed shows you the leader's transactions before the block is complete, with no provider schema between you and the bytes. You decide how to parse, what to keep and how to store it, and you can keep the original packets for replay and testing.
The cost of that position is uncertainty. Something you decoded from shreds may still fail and pay its fee anyway, or vanish with a skipped slot. Alpenglow settles blocks through certificates that never travel inside the shreds you receive (E4 tech facts X-04). Treat what you decode as provisional until a confirmation source says otherwise.
Which model fits which job#
| Job | Better fit | Why |
|---|---|---|
| Alerting on a watched wallet's outgoing transfers | Raw feed, confirmed later | You see the signed instruction early and can mark it pending |
| Showing a user their new balance | Managed stream or RPC | Balances are execution results |
| Detecting a new pool or token creation | Raw feed | A top-level creating instruction is visible before the block completes; creates made through another program's CPI are not |
| Reporting swap volume with real amounts out | Managed stream, or raw plus reconciliation | Output amounts need execution data |
| Tracking account state such as reserves | Managed stream | Account updates are not in shreds |
| Building a research archive you can replay | Raw feed | You keep the original bytes |
| A small team with no one on call | Managed stream | Fewer layers to operate |
Running both side by side#
Many teams end up with both. The raw feed gives early, provisional rows; an execution source upgrades each row to confirmed, failed or dropped. The reconciliation guide shows one way to run that loop against RPC, and the decoding pipeline shows what sits between packet and row on the raw side.
If you are unsure what each message type actually contains, the field-by-field comparison of stream messages lays them out next to each other.
Questions teams ask before choosing#
Can a raw feed tell me whether a transaction succeeded?#
No. Success, errors and logs are produced when the block is executed, and shreds carry only the signed transactions. You learn the outcome later from RPC or another execution source.
Is a managed stream always later than raw shreds?#
A stream that includes execution results has to wait for execution, so it cannot arrive before the transaction exists in shreds. How large the gap is depends on the provider and your location, so measure it rather than assume a number.
Do I need to resolve lookup tables if I take raw shreds?#
Yes, for v0 transactions. Shreds carry only the table key and index lists, so you need the table account data to know which addresses were used (E4 tech facts T-06, T-07).
Who should not run their own decoder?#
Teams that need execution results for every row, cover many programs without IDLs, or have nobody to fix a broken pipeline at night are usually better served by a managed stream.
When a raw feed is the wrong call#
- Your product depends on balances, logs or exact swap outputs for every event.
- You have no capacity to maintain parsers when transaction formats or programs change.
- You need historical data before the moment you connected; a live feed has no history.
- Nobody on your side can host a receiver that is reachable from the internet over UDP.
In those cases a managed stream or plain RPC is the honest recommendation.
Where to go next#
Start with where Solana data comes from for the wider map, read what your decoder cannot see for the gaps in raw data, or weigh the full workload in build or buy an indexer. If owning the decode layer is the right call, the Standard Shreds plan is the place to start.
Sources#
- Agave source: the Entry struct (num_hashes, hash, transactions) (checked 2026-11-18)
- solana-transaction-status crate: TransactionStatusMeta, produced by execution (checked 2026-11-18)
- SIMD-0326 Alpenglow: certificates and skipped slots (checked 2026-11-18)
- Yellowstone gRPC proto: SubscribeUpdateTransactionInfo carries TransactionStatusMeta (checked 2026-11-18)
- Solana docs: RPC commitment levels (checked 2026-11-18)
Raw shreds on your own server
Ultra Low Latency Shreds is $200 and Standard Shreds is $100. You pay in crypto, tell us which IPv4 address and UDP port should receive the stream, and we wire it up by hand.