· Checked November 18, 2026

Do you need shreds, or will a webhook do?

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#

TaskWebhookRaw shred feed
Run something that listensAn HTTPS endpointA UDP receiver on a server you control
Turn data into eventsDone by the providerYour decoder, including lookup tables and program layouts
Know whether it succeededIncluded in the eventA later check against RPC or a confirmed source
Handle repeatsMake the handler idempotentDeduplicate by transaction signature
Handle gapsThe provider retriesNothing is resent; you fill gaps from RPC
Change what you watchEdit the registrationChange 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#

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.