A webhook is enough when a person reads the alert, when the event must already have succeeded, or when you have no server that can hold a UDP port open. Raw shreds earn their extra work only when software must act on a transaction before it settles, and you are ready to run a receiver and decoder.
How a webhook reaches you#
A webhook service watches the chain for you and sends an HTTP request to your endpoint when a matching event happens. You register the addresses or event types you care about, expose one URL, and write a handler. The provider runs the nodes, the parsing and the matching.
Two properties shape everything downstream. First, the event comes from a transaction the network has already processed, so the notification can say whether it worked. Second, delivery is HTTP with retries, which means duplicates are possible: provider documentation warns that a retried delivery can arrive twice, so your handler should be idempotent (see the source list for one example).
How a raw shred feed reaches you#
A shred feed sends UDP datagrams to an IPv4 address and port you control. Each datagram is a piece of a block the leader is still producing. Your receiver collects the pieces, rebuilds the entries and pulls out signed transactions, then your own code decides what matters.
What arrives is the transaction as submitted, with no outcome attached. Success or failure, balances and logs are produced later by execution and never travel in shreds (E4 tech facts X-01, X-02). A transaction you see this way can still fail, or its slot can be skipped (X-04), so a raw feed gives you an early signal that you confirm afterwards.
Follow the questions#
Will a person read the result rather than a program?#
Choose a webhook. People read an alert after the fact, and a notification that already knows the outcome avoids telling someone about a transfer that later failed.
Must the event be known to have succeeded before you act?#
Choose a webhook or a confirmed stream. Raw shreds cannot tell you that, and you would rebuild the same confirmation step yourself.
Does your code act on a transaction before the block settles?#
Consider raw shreds. This is the one case where seeing the transaction early changes what your software can do, as long as it can handle the ones that fail.
Do you control a machine that can receive UDP on a port you choose?#
If not, stop at a webhook. A raw feed needs a receiver on a reachable IPv4 address, listening on a port you pick, and serverless functions or managed app platforms usually cannot do that.
Do you have someone to own a decoder?#
If not, choose a webhook or a managed stream. A raw feed hands you bytes, and turning them into program events is ongoing work.
The work each option leaves on your side#
| Task | Webhook | Raw shred feed |
|---|---|---|
| Run something that listens | An HTTPS endpoint | A UDP receiver on a server you control |
| Turn data into events | Done by the provider | Your decoder, including lookup tables and program layouts |
| Know whether it succeeded | Included in the event | A later check against RPC or a confirmed source |
| Handle repeats | Make the handler idempotent | Deduplicate by transaction signature |
| Handle gaps | The provider retries | Nothing is resent; you fill gaps from RPC |
| Change what you watch | Edit the registration | Change your own code |
Using a webhook and a feed together#
The two fit together well. A trading component reads raw shreds and reacts early, while a webhook or an RPC check feeds the system of record that people look at. The feed answers "is something happening", and the confirmed source answers "did it happen". Keep the two paths separate in your data model, so an early row never looks final; the wallet alert post shows the false alarms that come from mixing them.
Webhook or feed questions#
Are webhooks enough for a wallet app?#
Usually yes. A wallet shows people what happened, and a webhook built on processed transactions already carries the outcome. A raw feed only helps if you want to show incoming transfers as pending before they settle.
Can a webhook arrive twice?#
Yes. Webhook providers retry when your endpoint does not answer, and their documentation warns about duplicates. Store the transaction signature and ignore repeats.
Do raw shreds tell me if a transfer succeeded?#
No. Shreds carry the signed transaction only. The outcome comes from execution and has to be checked separately, for example with a status request to RPC.
Is there a middle option?#
Yes. Polling RPC or a managed stream sits between the two; the polling versus streaming example walks through one.
When raw shreds are overkill#
Skip a raw feed for notifications people read, back-office reconciliation, accounting exports and anything built on serverless functions. The same goes for teams with nobody to maintain a decoder: the feed is only useful once your own code turns packets into transactions, and that code needs care whenever a program you track changes its layout.
Next steps#
If your answers ended at raw shreds, start with the quickstart and the SOL transfer recipe. If they ended at a webhook, the map of Solana data sources helps you choose a provider category, and what a developer needs from a feed is worth a read before you change your mind later.
Sources#
- A webhook provider's documentation: HTTP notifications on on-chain events, retries and possible duplicates (category example) (checked 2026-11-18)
- Agave source: the Entry struct carries transactions with no execution result (checked 2026-11-18)
- Agave docs: commitment levels (checked 2026-11-18)
- Solana RPC docs: getTransaction and transaction status (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.