Solana stream messages differ mainly in how much work has already been done for you. A raw shred datagram carries a fragment of a block. An entry carries signed transactions. A Geyser-style update adds execution results. A WebSocket log notification carries a signature, an error field and log lines. The earlier the format, the fewer fields you receive.
The five formats#
Raw shred datagram. One UDP packet holding a piece of a block, either data or recovery (erasure) material. On its own it is not a transaction. You collect enough of them to rebuild the block's byte stream.
Entry. What the reassembled block is made of. An entry holds a hash count, a hash and a list of signed transactions, in the leader's order, and nothing else (E4 tech facts X-01).
Serialized transaction. A single signed transaction pulled out of an entry, in one of three formats that are all live on mainnet: legacy, v0 and v1 (E4 tech facts T-01). You still have to resolve v0 lookup tables and decode each program's instruction data.
Geyser-style transaction update. The shape used by the Yellowstone gRPC protocol: the signature, a vote flag, the transaction, its TransactionStatusMeta, its index in the block and the slot. It exists only after the transaction has been executed.
RPC WebSocket log notification. What logsSubscribe sends: the slot as context, then the signature, an err value and the log lines, at the commitment level you asked for.
Field by field#
| Field or property | Shred datagram | Entry | Serialized transaction | Geyser-style update | WebSocket log notification |
|---|---|---|---|---|---|
| Transaction bytes | Fragment only | Yes | Yes | Yes | No |
| Signatures | Inside fragments | Yes | Yes | Yes | First signature |
| Slot | Yes, in the shred header | From the shreds it came from | From the entry | Yes | Yes, as context |
| Position in block | Shred index | Entry order | Order within the entry | Index field | No |
| Success or error | No | No | No | Yes | Yes |
| Program logs | No | No | No | Yes | Yes |
| Inner instructions | No | No | No | Yes | No |
| Balances before and after | No | No | No | Yes | No |
| Lookup table addresses resolved | No | No | No | Yes, in the meta | Not applicable |
| Ordering guarantee | None, packets arrive as the network delivers them | Leader order | Leader order | Provider dependent | Provider dependent |
The five columns from left to right also run from earliest to latest in the life of a transaction: the first three exist before execution, the last two after it (E4 tech facts X-02).
Integration work each format leaves you#
| Work item | Shred datagram | Entry | Serialized transaction | Geyser-style update | WebSocket log notification |
|---|---|---|---|---|---|
| Receive UDP and size buffers | Yes | No | No | No | No |
| Recover missing pieces, rebuild the block | Yes | No | No | No | No |
| Split entries into transactions | Yes | Yes | No | No | No |
| Tell legacy, v0 and v1 apart | Yes | Yes | Yes | Library usually does it | Not needed |
| Resolve v0 lookup tables | Yes | Yes | Yes | No | Not needed |
| Decode program instructions | Yes | Yes | Yes | Yes, unless the provider parses | Parse logs instead |
| Attach success or failure | Later, from another source | Later | Later | Included | Included |
Transport is a separate question#
UDP, gRPC and WebSocket are ways to carry messages, not message formats. A provider could in principle send entries over gRPC or log lines over UDP. When you compare feeds, ask two separate questions: what is inside each message, and how does it travel. The first decides your decoding work; the second decides your networking work.
Transaction size is one place where format matters to transport. Legacy and v0 transactions are capped at 1232 bytes, while v1 transactions can reach 4096 bytes and do not use lookup tables (E4 tech facts T-04).
Where SolanaShreds sits#
SolanaShreds delivers the leftmost column: raw shred datagrams over UDP, each at most 1228 bytes, with nothing decoded on our side. Every other column in the work table is yours to build, and the decoding pipeline guide walks through it stage by stage.
Questions about message contents#
Does a Geyser-style update include program logs?#
Yes. It carries the transaction's TransactionStatusMeta, which holds logs, inner instructions, balances and the error, if any. That is also why it can only exist after execution.
Can I get inner instructions from shreds?#
No. Inner instructions are created when the transaction runs, so they are absent from entries and from every serialized transaction you extract from them (E4 tech facts X-02).
Why does a log notification have no transaction bytes?#
Because logsSubscribe is designed to report logs and the outcome. If you need the instruction data as well, fetch the transaction by signature or use a format that includes it.
Which format should a new project start with?#
The one whose missing fields you can live with. If you need outcomes on every row, start with an execution-based format; if you need the earliest view and can confirm later, start lower.
Limits of this comparison#
The Geyser and WebSocket columns describe the published protocol definitions, not any single provider's deployment. Providers can add, filter or reshape fields, so check the exact schema of the service you use. Nothing here measures timing; the left to right order describes when data can exist, not how many milliseconds apart.
Related reading#
Raw feed or managed stream turns this table into an ownership decision. Parser libraries covers the open source code for the left columns, parsed transaction APIs covers the right ones, and how a transaction is laid out explains the bytes in the middle. To see what raw shreds cost, read the plans and prices.
Sources#
- Agave source: the Entry struct (checked 2026-11-18)
- solana-transaction-status crate: TransactionStatusMeta (checked 2026-11-18)
- Solana improvement document 0385, the v1 transaction layout (checked 2026-11-18)
- solana-message 6.0.0: legacy, v0 and v1 messages (checked 2026-11-18)
- Yellowstone gRPC proto: SubscribeUpdateTransaction and SubscribeUpdateTransactionInfo (checked 2026-11-18)
- Solana docs: logsSubscribe notification format (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.