Solana streaming: gRPC, Shred stream, Firehose or WebSocket?
Last updated:
Compare the four Solana streams
Start with what your consumer must know. A signature and fee can power an activity counter, but cannot explain a swap or an account balance. A pre-execution transaction is an early signal, but cannot tell you the result. The table compares the channels on the same API key; each linked page owns its connection details and full limits. For where each stage sits in a slot, read how ledger entries become shreds.
| Channel | What arrives | Relative to execution | Filters | Replay | Transport | From plan | Limit |
|---|---|---|---|---|---|---|---|
| Solana gRPC (Yellowstone) Yellowstone gRPC: streams per plan and endpoint | Account, transaction, block and slot updates; execution metadata | After execution (processed, confirmed or finalized) | Server-side SubscribeRequest filters | None | gRPC over HTTP/2 | Pro ($249/mo) | 8 streams on Pro; 20 streams on Business, per key |
| Shred stream Shred stream: transactions before they execute | Deshredded transactions; no execution status, logs or balances | Before execution | Account list: required on Pro, optional on Business | None | WSS | Pro ($249/mo) | 2 streams on Pro; 4 streams on Business, per key |
| Firehose Firehose: every non-vote transaction, no filters | Non-vote, non-failed transactions: slot, signature and fee; stats | After execution | None; fixed feed | None | WSS | Pro ($249/mo) | No per-key connection cap; separate from the gRPC stream limit |
| WebSocket (Pub/Sub) Solana WebSocket API methods by plan | Standard JSON-RPC subscription notifications | After execution | Per-subscription parameters | None | WSS | Free trial for accountSubscribe and signatureSubscribe; other methods by plan | Per-method plan gates |
Shred stream account lists allow up to 50 accounts on Pro and 200 on Business. Shred stream has no data-volume quota. Firehose connections do not count toward the 8/20 gRPC stream limits. Pub/Sub begins with the 7-day trial; method availability is not the same as access to every streaming product.
Pick in four questions
- Do you need transactions before execution? Choose Shred stream: transactions before they execute. The deshredded feed avoids running a raw UDP receiver and deshredder. Confirm the outcome separately: the stream has no status, logs or balances and a transaction may not land.
- Do you need server-side filters and execution metadata? Choose Yellowstone gRPC: streams per plan and endpoint. Filter accounts or transactions on the server, and select processed, confirmed or finalized commitment. Size the plan for concurrent subscriptions rather than treating every update as a new stream.
- Do you want the whole feed for counting or sampling? Choose Firehose: every non-vote transaction, no filters. Compact slot, signature and fee frames suit dashboards and triggers for subsequent reads. Client-side filtering still requires receiving the feed; it does not reduce incoming traffic.
- Are you following a few accounts or signatures, including from a browser? Use Solana WebSocket API methods by plan. Standard JSON-RPC subscriptions fit this task without a Yellowstone client. Check the plan for each method before subscribing; account notifications and block notifications have different gates.
gRPC or WebSocket on Solana?
Native gRPC uses HTTP/2 and typed Yellowstone messages, making it a fit for backend pipelines that need server-side filters and execution metadata; the messages come from the validator's Geyser plugin interface. WebSocket describes a transport shared by three different products here: Shred stream, Firehose and JSON-RPC Pub/Sub. They have different payloads and subscription rules. Sending a Yellowstone request to Firehose will not turn it into a filtered stream. Choose the data contract first, then the client library. For a broader transport comparison, read SSE, WebSocket and gRPC across chains.
One key, flat price
Pro ($249/mo) includes 8 gRPC streams, 2 Shred streams, Firehose and the Pub/Sub method set. Business ($499/mo) includes 20 gRPC streams and 4 Shred streams with an optional account filter. JSON-RPC follow-up reads have their own budgets: 200 Solana read RPS on Pro and 600 on Business. No per-GB charge does not remove those request-rate limits.
- Solana gRPC (Yellowstone):
https://grpc.triport.io, native gRPC over TLS. - Shred stream:
wss://triport.io/ws/sol-preexec. - Firehose:
wss://triport.io/ws/sol-stream. - WebSocket (Pub/Sub):
wss://triport.io/ws/sol.
Send the same API key as x-token call metadata for gRPC or as a WebSocket upgrade header. Authorization: Bearer is also accepted. Browser WebSocket clients cannot set custom headers; the WebSocket references document the query-key form. Use https://triport.io/sol for follow-up JSON-RPC reads. Create a key in the API key dashboard and check plan limits.
Choosing a provider
Once the transport fits, compare concurrent stream counts, mandatory filters, traffic billing, replay and regions. A provider offering raw UDP shreds solves a different integration task from a managed deshredded WebSocket feed. For Yellowstone, distinguish the number of connections from filter capacity and ask how missed data is recovered. For gRPC, compare Yellowstone gRPC providers by streams and metering; for pre-execution data, compare shred stream providers after Jito (raw UDP per IP versus deshredded WebSocket). RPC plans are in the RPC provider comparisons; use a representative workload from your own region before committing to a plan.
What we do not offer
Triport does not provide raw UDP shreds, a replay cursor or automatic historical backfill on these live channels. Persist your processing checkpoint and recover missed ranges over JSON-RPC, for example with getBlock. Reconnecting alone does not retrieve updates sent while you were offline.
When Triport is the wrong choice
Choose another setup if your application requires stream-native replay, raw shreds for your own validator pipeline, or a standard-plan region outside eu and us. More than 20 concurrent gRPC streams requires Enterprise terms. Firehose has no per-key connection cap, but that does not make its delivery lossless: a consumer that cannot keep up may miss frames.
FAQ
- Which Solana stream arrives before execution?
- Shred stream carries transactions reassembled from leader shreds before execution. Yellowstone gRPC and Firehose carry post-execution data. This is a difference in data stage, not a measured latency ranking. Measure arrival times from your region; a pre-execution transaction may still fail or never land.
- Do streams cost extra?
- Yellowstone gRPC, Shred stream and Firehose are included from Pro ($249/mo); Business is $499/mo. There is no per-GB charge or credit accounting. Stream counts, account-filter limits and JSON-RPC request-rate budgets still apply. WebSocket Pub/Sub availability depends on the method and plan.
- Can I use gRPC from a browser?
- Use native Yellowstone gRPC on your backend. A browser WebSocket cannot connect to the gRPC endpoint, and Triport does not expose a gRPC-Web endpoint. For a browser application, choose WebSocket Pub/Sub or relay the relevant updates through your own backend.
- Is there a Solana mempool stream?
- Solana has no public mempool equivalent to Ethereum's. Shred stream exposes transactions reconstructed from leader shreds before execution; it is not a pending-transaction pool and does not guarantee inclusion. See the Shred stream product page for its data and limits.