Polling asks an RPC node for each finished block and filters it yourself, so it is simple but always behind and bound by request limits. Streaming receives the block while the leader is still producing it, so the wallet watcher sees activity first, at the cost of a receiver, a decoder and a confirmation step you now own.
The task: watch one wallet#
The job is plain on purpose: notice every transaction that touches one wallet address, record it, and mark it as settled once the network agrees. Both versions below do exactly this, so the differences you see come from the data source, not from the feature list.
Version A: polling the getBlock RPC method#
The shape of the code#
A loop asks the getBlocks RPC method which slots produced blocks since the last run, then calls the getBlock RPC method for each one and scans every transaction for the wallet. The request must set a maximum supported transaction version high enough to cover v1, or the whole request fails for any block that contains a v1 transaction (E4 tech facts T-01). The getBlocks documentation lists only confirmed and finalized as commitment choices, so the slot list this loop walks always trails the newest blocks.
Request limits#
Every slot is at least one full block request, and most of each response is transactions you throw away. With 200 ms slots the loop makes several block requests per second just to keep pace, and RPC providers cap request rates, so a busy watcher spends its effort on fetching rather than on the wallet itself.
Missed and skipped slots#
Slots without a block simply do not appear in the getBlocks list, so the loop has to trust the list rather than count slot numbers. If the poller stops for a while, it catches up by walking the range again, which is the one thing polling does better than a live feed.
Version B: moving the same watcher to a stream#
- Pick a machine you control, open one UDP port on its reachable IPv4 address, and have the shred feed sent there.
- Run a receiver that rebuilds entries and extracts transactions; the quickstart does this for a first transaction.
- Check each transaction's static account keys for the wallet, and resolve lookup tables for v0 transactions before deciding it is not a match.
- Store each match as provisional, keyed by its first signature, because a transaction seen in shreds has no outcome yet (E4 tech facts X-01, X-04).
- Every few seconds, send the pending signatures, up to 256 per request, to the getSignatureStatuses RPC method and mark each row confirmed, failed or dropped, as the reconcile guide shows.
- Keep Version A's catch-up code: if the receiver was down, walk the missing range with getBlock, because a live feed never resends.
The two versions side by side#
| Version A: polling | Version B: streaming | |
|---|---|---|
| When you first see the transaction | After the block is confirmed and served | While the leader is producing the block |
| RPC use in steady state | One block request per slot, mostly wasted | Small status checks for matched signatures only |
| What you run | A loop and an HTTP client | A UDP receiver, a decoder and a reconcile loop |
| Outcome known at first sight | Yes, the block includes results | No, it arrives with the status check |
| After downtime | Walk the missed range | Walk the missed range with RPC too |
| Skipped slots | Absent from the slot list | No complete block appears; pending rows are dropped by reconcile |
Where polling stays the right tool#
Polling is the correct way to backfill history, rebuild a table after a schema change, and audit a day of activity. It is also fine for low volume watchers where a delay of a few blocks does not matter. Most production systems keep both: a stream for the live edge and block requests for history, joined carefully as the backfill post explains.
Polling and streaming questions#
Why does getBlock fail on some newer transactions?#
The request has to declare the highest transaction version it can handle. If it does not cover v1, blocks containing v1 transactions are rejected.
How do I avoid requesting slots with no block?#
Ask the getBlocks RPC method for the range first. It returns only the slots that produced a confirmed block.
Does streaming remove the need for RPC?#
No. You still need RPC to confirm outcomes and to fill gaps, but the volume drops to status checks for the transactions you care about.
Is block height the same as the slot number?#
No. Skipped slots make them drift apart; the explainer on slot versus block height covers which one to store.
When the stream is not worth switching to#
Stay with polling if you only need settled history, if your watcher can lag by several blocks without harm, or if you cannot run a UDP receiver. A stream adds a decoder and a reconcile loop that must be maintained, and that work buys nothing when nobody acts on the early signal. For notifications read by people, a webhook is simpler still; see webhooks or shreds.
Make the switch#
Version B starts with a feed and a receiver. The plans and prices page lists both options, and the quickstart shows how you decode a first transaction once packets arrive.
Sources#
- Solana RPC docs: getBlock (commitment, transactionDetails, maxSupportedTransactionVersion) (checked 2026-11-18)
- Solana RPC docs: getBlocks returns confirmed block slots in a range; commitment confirmed or finalized (checked 2026-11-18)
- Solana RPC docs: getSignatureStatuses (checked 2026-11-18)
- Solana improvement document 0385, the v1 transaction layout (checked 2026-11-18)
- Agave source: the Entry struct (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.