Data quality · November 18, 2026 · 6 min read

Landed but failed: why a transaction in a block may have done nothing

A transaction can be packed into a block, pay its fee and still change nothing else. Raw shreds show it exactly like a successful one. Here is why that happens, how often it happened in one busy program on the day we checked, and how to keep it out of your figures.

Solana failed transactions in blocks are normal: a leader includes a transaction, the runtime executes it, an instruction returns an error, and every state change is rolled back except the fee. The transaction stays in the block. Shreds carry it before execution, so a decoder sees a failed swap exactly as it sees a successful one.

Why failed transactions are still in blocks#

The leader packs transactions before it knows how each will end. Execution happens as the block is built and replayed, and if any instruction fails, the whole transaction is reverted. The fee payer has still asked the network to do work, so the fee is charged and the transaction keeps its place in the block as a record of that.

So "it is in the block" answers one question (did it land?) and leaves the other open (did it work?). Shreds only ever answer the first, and only provisionally, because the slot itself can still be skipped.

One failed transaction, read two ways#

Take transaction 53P3bNLF…EZTgu in slot 470,909,851, linked in the sources. Read it the way a shred decoder does, then the way RPC reports it:

What you checkFrom shredsFrom RPC after execution
Signatures and signerpresentpresent
Instructions and their datapresentpresent
Programs calledpresentpresent
Statusnot availablefailed: instruction 3 returned custom error 6001
Fee chargedcomputable from the transaction10,008 lamports, taken from the payer
Token movementsdeclared intent onlynone: execution stopped at instruction 3, before the buy ran

The fee line is the useful surprise. With one signature, the base fee is 5,000 lamports, and the rest is the priority fee the transaction declared. You can compute that number from the raw bytes, so you can book the cost of a transaction even before you know whether it worked.

How common failure is in busy programs#

To see whether this is a corner case, we pulled the 200 most recent finalized signatures that touched the Pump.fun program on 18 November 2026. 110 of them carried an error. That is one sample, from one program, at one moment, so do not treat it as a rate to plan around. It does show that in contested programs, a decoder that counts every included transaction as executed can be wrong more often than right.

Run the same check on the programs you care about: getSignaturesForAddress returns an err field for each signature, which makes the measurement cheap.

Correcting volumes, alerts and balances later#

Treat every decoded transaction as pending until RPC returns its status, then correct downstream data:

  1. Volumes. Record early volume as provisional. When a swap's status comes back failed, subtract it, or rebuild the figure from successful rows only.
  2. Alerts. Send an early alert labelled as pending, then a follow-up when the status arrives. A failed transfer deserves a "did not go through" message, not silence.
  3. Balances. Never move a balance on a decoded transfer alone. Wait for a successful status, or read post-balances from the confirmed transaction.
  4. Fees. Book the fee in every case: the payer loses it on success and on failure alike.

Signals that a transaction may fail#

Some patterns raise the odds of failure without proving anything:

  • Tight slippage limits on a swap in a busy pool, where an earlier transaction in the same block can move the price.
  • Many transactions from one signer aimed at the same account in the same slot, where the first one can change the state that the later ones depend on.
  • A high priority fee on a contested launch, which tells you the sender expects competition.

None of these is a verdict. Use them to rank what to watch, and let the status from RPC settle it.

Questions about failed transactions#

Does a failed Solana transaction still pay a fee?#

Yes. The fee is charged even when an instruction fails, and every other change is rolled back.

Can a decoder tell from the raw bytes that a transaction failed?#

No. Failure is decided during execution, after the transaction was packed. The raw bytes look the same either way.

Should failed transactions be deleted from my tables?#

Keep them, with their status set to failed. They explain fees paid, and they tell you how often early data overstated activity.

What you cannot know from the raw transaction#

From the transaction alone you cannot know whether it succeeded, which instruction failed, the error code or what it would have moved. If your product shows executed trades or settled balances the moment it receives data, raw shreds are not enough on their own, and you need execution results from RPC or a stream of executed transactions.

Keep failures out of your numbers#

What your decoder cannot see lists every execution field that shreds lack. Status checks against RPC shows how to fetch outcomes in batches, and the status model for early rows gives them a home. For downstream effects, read wallet alerts without false alarms and early DEX volume. To work out what a transaction paid before it ran, see working out the priority fee, and for the window in which a pending transaction can still land, blockhash expiry. Start with the quickstart to decode your first transactions.

Failed creates are one reason counting new tokens from raw data needs a confirmation step before anything is reported.

The Pump.fun launch walk-through shows a create that succeeded, for comparison with the failures above.

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.

Read nextFilter early, filter cheap: placing the program filter in your pipeline