2 sat/vB your bid→38 sat/vB the clearing rate
Two satoshis per byte looked fine at 2am. By morning the cheapest seat in a block costs forty. Nothing about the transaction broke: it is valid, signed, and still sitting in most mempools. It is simply losing an auction you did not know you had entered.
I have watched people conclude, at this exact moment, that the network is congested, that the wallet is broken, or that the coins are gone. All three are wrong. The transaction is fine. The bid is not.
Block space is sold by the byte, not by the dollar
The first intuition to unlearn is that a bigger payment deserves priority. A block is not a queue sorted by value. It is a container with a byte budget, and the only price that matters is satoshis per virtual byte.
A transfer of forty thousand dollars in one input and two outputs occupies about 141 virtual bytes. A transfer of forty dollars in the same shape occupies the same 141 virtual bytes. A miner earns the same from both at the same feerate, so it has no reason to prefer either. This is why “but I moved a lot of money” is not an argument you can make to the network. The network does not know what the money is for. It knows how many bytes you are asking to occupy.
The number that matters is not your feerate in isolation. It is the clearing rate — the marginal rate at which the next block fills. If demand for that space doubles, the clearing rate can move by a factor of twenty inside a day. Your 2 sat/vB was a reasonable bid when you made it. Overnight it stopped being one.

There is a second thing worth internalising before the repair options make sense: nobody can cancel a transaction. Not you, not your wallet, not an exchange. A signed transaction is a valid fact about the UTXO set waiting to be recorded. The only way to remove it is to make it irrelevant — to get a different transaction confirmed that spends the same coins. Every technique below is a version of that one idea.
Who holds the keys decides which door is open
This is the part almost every “how to speed up a stuck transaction” guide skips, and it is the only part that matters when you are the one waiting.
If you sent from your own wallet, you hold the private keys to the inputs. You can build a new transaction that spends the same coins and pays more. That is replace-by-fee.
If the transaction came from an exchange withdrawal, you do not hold those keys. The exchange built the transaction, the exchange signed it, and only the exchange can replace it. Support desks usually will not, because that withdrawal is one line in a batched transaction serving dozens of customers. You have exactly one lever, and it operates from the receiving side: child-pays-for-parent.
So the question “should I use RBF or CPFP” is really the question “am I the sender or the recipient”. Everything else follows.
Door one: replace your own transaction
Replace-by-fee means rebroadcasting a conflicting transaction that spends at least one of the same inputs, pays a higher fee, and therefore competes for the same slot. Only one of the two can ever confirm. A node accepts the swap only if it satisfies a short list of conditions, and those conditions exist to stop replacement from becoming a free denial-of-service channel:
Higher absolute fee
The new transaction must pay more in total than everything it evicts, not merely more per byte.
Incremental relay fee
On top of that it must cover its own relay cost at the node’s rate, 1 sat/vB by default.
No new unconfirmed inputs
It may not pull in unconfirmed coins the original did not already spend.
At most 100 evictions
It may not clear more than 100 transactions at once, counting descendants.
Notice that the first rule is about absolute fee, not feerate. This trips people up constantly. If you shrink a 400 vB transaction to 200 vB at a better rate, the total fee can go down, and a node will reject the replacement even though the new one looks better per byte. Bumping is never a discount.
The signalling story is now history, and most articles have not caught up. Under BIP-125, a sender had to opt in by setting an input’s nSequence below 0xfffffffe, and nodes would refuse to relay replacements for anything that did not flag itself. Merchants leaned on that: an unflagged payment at zero confirmations felt safe. Bitcoin Core 28.0, released in October 2024, changed the default of -mempoolfullrbf from 0 to 1. BIP-125 has since been marked obsolete. Any unconfirmed transaction can now be replaced by a higher-paying version, regardless of how it was built.
That was a correction, not a policy shift. Consensus rules always let a miner include whichever conflicting transaction it preferred. The old relay policy created an appearance of safety that miners were never obliged to honour. The honest summary is blunt: an unconfirmed payment is a proposal, not a settlement.
# The wallet rebuilds the transaction, shaving the extra fee off the change output
bitcoin-cli -rpcwallet=mywallet -named bumpfee fee_rate=25
# If the transaction has no change output left, this fails: there is nothing to shave
# and you must add another input instead
That last comment is the practical trap. A wallet that sent your entire balance has no change output to reduce, so bumping requires adding a new input — which changes the transaction shape and pulls in another UTXO, possibly another signature. This is why “keep a change output” is not just a privacy habit. It is a repair capability.
Door two: pay for it from the other side
Child-pays-for-parent works because a child cannot be mined before its parent. A miner that wants the child’s fee has to take the parent as well, so the two are evaluated together:
20 sat/vB
the package rate a parent and child must reach together, not individually
The arithmetic is simple and worth doing once by hand. Say the stuck parent is 200 vB paying 2 sat/vB, so 400 satoshis of fee. You want the pair mined at 20 sat/vB and your child transaction is 150 vB. The package needs 20 × (200 + 150) = 7,000 satoshis. The parent already contributes 400, so the child must pay 6,600 — which on its own 150 vB is 44 sat/vB. The child is expensive on purpose. That is the whole mechanism: you are not raising the parent’s bid, you are bribing the miner to take a package.

Anyone holding an output of the stuck transaction can do this, which is why it is the recipient’s only move. It also costs one extra transaction, so it is strictly less efficient than RBF when you have the keys.
| Replace-by-fee | Child-pays-for-parent | |
|---|---|---|
| Who can do it | whoever signed the original | anyone holding one of its outputs |
| What changes | the stuck transaction itself | a new transaction spending its output |
| Extra cost | one replacement, no new transaction | one extra transaction on chain |
| Extra requirement | a change output to shave, or another input | an unspent output you control |
| Failure mode | rejected if the absolute fee drops | child sits behind a parent no miner wants |
What changed in 2026, and why it matters less than it sounds
Bitcoin Core 31.0, published on 19 April 2026, rebuilt the mempool around clusters: connected sets of related transactions, capped at 64 transactions and 101,000 virtual bytes. Inside a cluster, transactions are ordered by the rate at which the group would realistically be mined, which makes CPFP reasoning far more accurate than the old per-transaction ancestor accounting.
Replacement got stricter at the same time. A replacement is now accepted only if it leaves the mempool’s overall fee-rate profile strictly better than before, which closes cases where a replacement could make the mempool worse for the next miner. For a standalone transaction the practical test is unchanged: pay more in total and more per byte than what you are replacing.

The same release added private broadcast over Tor or I2P. One change from slightly earlier matters just as much if you run Lightning: version-3 transactions under BIP-431 became standard in 28.0, alongside key-less anchor outputs. An anchor is a small, cheap UTXO whose only job is to be spent at a high feerate when you need to bump a commitment transaction. Fee bumping stops being an emergency and becomes a designed step.
What I actually do now
- Before signing, look at the clearing rate for the next two or three blocks, not the “recommended” number, and add a margin if the payment is time-sensitive.
- Always leave a change output. It is the difference between a bumpable transaction and a stuck one.
- Know who holds the keys. If it is an exchange withdrawal, plan for CPFP from the receiving wallet instead of waiting on support.
- Treat zero-confirmation acceptance as a business decision with a price, because the network will not enforce it for you.
None of this is exotic. It is just the difference between treating a fee as a tip and treating it as a bid in a market that clears every ten minutes. The market does not care how much you meant to send. It only reads your number.
(The End)


