Solana data sources differ in which fields they carry, not only in when they arrive. Raw shreds hold the signed transactions a leader produced, in block order, with no execution results. Geyser streams and RPC add results, logs and account state after a validator runs the block. Webhooks and indexers hand you someone else's parsed view.
Raw shreds: the leader's bytes, before anyone runs them#
A leader cuts each block it builds into small signed packets called shreds and sends them out across the network. Reassemble the packets for one block and you get entries, and each entry is a short list of signed transactions in the exact order the leader packed them. In Agave's own definition an entry holds three things: a hash count, a hash and the transactions. Nothing else rides along.
That makes shreds the earliest form of a block you can observe, and also the barest. You hold the instructions a sender asked for, the accounts they named and the signatures that authorise it. You do not hold whether any of it worked. The decoding pipeline walks through every stage from datagram to transaction, and why packets are not yet data explains the gap in plainer terms.
Geyser streams: what a validator saw after executing#
Geyser is the plugin interface inside a validator. A plugin receives callbacks as the validator processes accounts, transactions, slots and entries, and streaming services built on it forward those events to clients. The widely used Yellowstone gRPC plugin defines updates for accounts, slots, transactions, blocks and entries; its transaction update carries the transaction together with its status metadata.
Because the validator has executed the transaction by the time the callback fires, a Geyser stream can tell you about account state and results that a shred never will. The cost is that you depend on a validator running the plugin, and you see the data only after replay.
RPC and WebSocket: ask a node, or wait for it to tell you#
The JSON RPC interface answers questions. getBlock returns a whole block with each transaction's metadata, getTransaction returns one, and getAccountInfo returns an account's current data. The WebSocket side lets a client subscribe to accounts, logs, signatures, programs and slots and receive notifications.
RPC is where most projects start and where most of them keep checking their answers, because it is the reference view of what confirmed. Its limit is shape: you get the data in the formats the node offers, at the commitment level you ask for, and a busy public node will rate limit you.
Webhooks and parsed APIs: someone else's decoder#
Some providers run the decoding for you and push results to an HTTP endpoint you own, or expose parsed transactions through their own API. You get labelled events such as swaps or transfers instead of bytes.
What arrives depends entirely on the provider's parser and schema. That is convenient when the provider decodes the programs you care about, and limiting when it does not, because you cannot reach underneath to the raw instruction. The webhooks comparison looks at that trade in detail.
Archives and backfill: the past is a different problem#
A live source only shows what is happening now. To load history you go back to RPC methods such as getBlock against a node that keeps old blocks, or to a dataset someone has exported. How far back a given RPC provider can answer is that provider's policy, so check it before you plan a backfill around it.
Shreds have no past at all from the receiving side: a packet that was not read when it arrived cannot be asked for again. Treat history and live data as two inputs to the same tables.
Which fields each source carries#
| Field | Raw shreds | Geyser stream | RPC and WebSocket | Webhooks and parsed APIs |
|---|---|---|---|---|
| Signed transaction bytes | Yes | Yes | Yes (getBlock, getTransaction) | Usually not |
| Order inside the block | Yes, entry by entry | Yes (transaction index) | Yes (position in getBlock) | Provider dependent |
| Success or failure | No | Yes | Yes | Usually |
| Program logs | No | Yes | Yes | Sometimes, parsed |
| Inner instructions (CPIs) | No | Yes | Yes | Folded into parsed events |
| Balance changes | No | Yes | Yes | Often, parsed |
| Accounts loaded through lookup tables | Indexes only | Yes | Yes | Resolved for you |
| Account state | No | Yes (account updates) | Yes (getAccountInfo, subscriptions) | Provider dependent |
| Decoded instruction meaning | No, you decode | No, you decode | Some programs, as jsonParsed | Yes, their decoding |
Two rows decide most choices. If you need results, logs or balances, shreds alone cannot supply them, and you pair them with RPC later. If you need the transaction before it has been executed anywhere you can reach, nothing after replay can supply that.
Picking a source by the job in front of you#
| Job | Source that fits | Why |
|---|---|---|
| React to a transaction as the leader produces it | Raw shreds | The bytes arrive before replay and confirmation |
| Track balances or positions per account | Geyser account updates, or RPC | Needs account state, which shreds do not carry |
| Store final, correct history | RPC, then reconciliation | Needs results and confirmation |
| Alert on a few known events with little code | Webhooks or a parsed API | Someone else maintains the decoding |
| Build your own indexer | Raw shreds or Geyser, plus RPC | You own the decoder and check it against RPC |
| Load months of history | RPC archive nodes or exported datasets | Live sources have no past |
Many real systems use two of these at once: a fast, provisional view from one source and a confirmed view from another. The build or buy an indexer comparison helps with that decision, and a raw feed or a managed stream sets the two delivery models side by side.
Questions people ask when choosing#
Are shreds the same thing as Geyser data?#
No. Shreds are the block as the leader broadcast it, before any validator ran it. Geyser data comes from inside a validator after execution, so it can include results and account state.
Can I get transaction success or failure from shreds?#
Not from the shreds themselves. Being included and succeeding are separate facts: an included transaction may still have failed. You learn the outcome from a source that executed the block, usually RPC, which is why decoders that start from shreds reconcile later.
Which source shows each stream message's fields in detail?#
The comparison of what each stream message contains lists the fields message by message.
What raw shreds cannot give you#
Raw shreds are the wrong choice when your job needs execution: outcomes, logs, CPIs, balances or account state all come later, from elsewhere. They also cannot give you history, and a gap in reception stays a gap. If you do not want to run a decoder at all, a parsed source is simpler. The post on what a decoder cannot see lists the blind spots one by one.
Where to go next#
To see what you would be decoding, start with what is inside a Solana transaction and then inner instructions and CPIs. To try it end to end, the quickstart walks through your first decode. If raw shreds fit your job, get raw shreds.
Sources#
- Agave v4.4.1 entry/src/entry.rs: the Entry struct (num_hashes, hash, transactions) (checked 2026-11-18)
- Agave v4.4.1 transaction-status: TransactionStatusMeta (logs, inner instructions, balances) (checked 2026-11-18)
- Yellowstone gRPC geyser.proto (commit 1efaf08): account, transaction and block updates (checked 2026-11-18)
- Solana RPC docs: getBlock, getTransaction, getAccountInfo (checked 2026-11-18)
- Solana RPC docs: WebSocket subscription methods (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.