THREE DOORS A TRANSACTION HAS TO GET THROUGH
A default node holds 300 MB of unconfirmed transactions before it starts throwing them away, and after 336 hours it forgets you ever paid, at any fee rate. Neither number describes a queue: every node keeps its own candidate list, its operator sets the thresholds, and miners answer to none of them. This piece follows one transaction along its whole path and names, at each door, who may decide and who has no standing to.
300 MB, 336 Hours, and No Queue to Stand In
A default Bitcoin Core node keeps 300 MB of unconfirmed transactions, and when the pool crosses that line it does not slow down or ask anybody — it finds the cheapest package it holds and deletes it whole. The other number is 336 hours: when that deadline passes the node drops your transaction, and no fee rate is high enough to buy an exemption. Paying more does not make you permanent. It makes you expensive and, eventually, forgotten.
Both are parameters, not physics. -maxmempool defaults to 300 MB and can be configured down to 5 MB; a node run with -blocksonly never keeps more than 5 MB, its operator having opted out of the waiting-room business. -mempoolexpiry is 336 hours, and in practice most expired transactions get rebroadcast by the wallet that cares — the network has no memory, the sender usually does.
The waiting room is finite, local, and run by a stranger who owes you nothing.
There Ain’t No Such Thing as a Global Mempool
The Bitcoin Core community has a fixed phrase for this: “There ain’t no such thing as a global mempool.” Every full node maintains its own, nothing forces two to converge, and they can stay different indefinitely — agreeing about unconfirmed transactions is not part of the job.
This is the load-bearing claim of the piece, in the form that is useful: “the mempool” is not a queue — it is one candidate list per node, and a fee does not buy you a position in a line but a good rank each time an individual miner independently sorts his own list.
what a node keeps before it starts throwing packages away
after this a node forgets you paid anything at all
how many unconfirmed parents one chain of transactions may have
The consequences are not academic:
- A block explorer shows one node’s mempool, or a merge of a handful. A sample, not a census.
- A transaction can be refused by every node you can reach and still be mined, if the miner heard of it elsewhere.
- A transaction can be held by every node you can reach and still never be mined.
Internalize that last pair and most “why is my transaction stuck” questions answer themselves: the asker is imagining a single queue.
Door One: Policy Is Not Consensus
The first door is not the pool but a bouncer in front of it, and he works from a rulebook that is not the consensus rules. A transaction can be legal, correctly signed and spend valid outputs, and still be refused — not relayed, not stored — purely because of that node’s policy.
Here is the part people get wrong in both directions: the moment a miner puts it into a valid block, every node accepts the block, and the policy objection dies. Policy governs what is unconfirmed and nothing that is confirmed. The severity difference is the point: violating a consensus rule makes the block invalid, network-wide, forever, while violating a policy rule only means this node won’t accept it or relay it. Different categories of failure, not degrees of it.
Bitcoin Core caps a standard transaction at 400,000 weight units (roughly 100,000 vbytes), and that ceiling is nowhere in the consensus rules. Dust works the same way: DUST_RELAY_TX_FEE, 3,000 sat/kvB, defines what output is too small to be worth writing into the UTXO set. The reasoning sits in UTXO versus the account model; the principle is that the UTXO set is a global cost paid forever, so policy charges for it at the door.
-minrelaytxfee=100 # sat/kvB, the admission fee rate (0.1 sat/vB)
-maxmempool=300 # MB, the size of the waiting room
-mempoolexpiry=336 # hours, after which nothing survives
-limitancestorcount=25 # unconfirmed ancestors, itself included
-datacarriersize=83 # bytes; the old default for a data carrier output
Defaults are people. Core 30.0 (October 2025) raised the default cap on a single data carrier output from 83 bytes to 100,000 bytes, keeping -datacarriersize=83 for operators who wanted the old behaviour. The argument ended in a relay policy statement signed by 31 contributors — about relay policy, never consensus. Bitcoin Knots ships deliberately stricter defaults, and that is a choice, not a fork. When someone says “Bitcoin doesn’t allow X,” make them say whether they mean consensus or one implementation’s default.

Door Two: 100 sat/kvB and 25 Relatives
Admission has a price, and the price is a default. -minrelaytxfee is 100 sat/kvB (0.1 sat/vB), and it used to be ten times that — 1,000 sat/kvB (1 sat/vB) — until Core 30.0 shipped in October 2025. Years of “the minimum is 1 sat/vB” folk knowledge became wrong on a release date, not by consensus change.
Fee rate is not the only shape limit here. A transaction may not drag an arbitrarily long tail of unconfirmed relatives into the pool: DEFAULT_ANCESTOR_LIMIT and DEFAULT_DESCENDANT_LIMIT are 25 each, itself included, with a size ceiling of 101 kvB. The purpose is DoS resistance — otherwise someone could force every node to redo unbounded work each time a new link arrives.
Recent versions switch the unit to clusters: DEFAULT_CLUSTER_LIMIT is 64 transactions, DEFAULT_CLUSTER_SIZE_LIMIT_KVB is 101 kvB. I won’t claim the old counting is gone, since the ancestor limits still ship as defaults — but the direction matches everything else here: an operator chooses, for his own machine, what shapes of unconfirmed transaction graph he will hold.
Door Three: Eviction Is a Descendant-Feerate Contest
The pool is full. What gets thrown out? Not the oldest, and not the absolutely cheapest. TrimToSize finds the descendant package with the lowest combined feerate and deletes the whole package — the transaction plus everything in the pool that spends from it.
Then the node raises its own floor: after an eviction, mempoolminfee becomes the evicted package’s feerate plus -incrementalrelayfee (default 100 sat/kvB), and decays over time. That increment is not decoration — without it the evicted transaction walks back in at the same rate and gets evicted again, forever. The floor always sits above -minrelaytxfee, never below.
Send at a marginally competitive rate and the node does not hold you “a bit longer” — it holds you until the room gets crowded, then deletes you first and charges more for readmission. The tail risk of frugality is not a delay. It is a deletion.
Door Four: The Miner Sorts by Ancestor Feerate
Elsewhere a miner builds a block template. He is not reading your node’s mempool and is not bound by your node’s policy; if he heard of a transaction directly, he can include it even though every relay node refused it.
He sorts by ancestor feerate: a transaction plus its unconfirmed ancestors, scored as combined fee over combined size. That is why chains score as units rather than links, and it is the opposite aggregation direction from eviction.
for cluster in mempool_clusters_sorted_by_feerate_desc:
if ancestor_feerate(cluster) <= 0: continue
if template_size + cluster.size > block_limit: continue
if cluster.ancestor_count > 25 or cluster.size_kvb > 101: continue
template.add(cluster) # ancestors are pulled in as one unit
That pseudocode is a simplification — real template construction works over a linearized cluster ordering. But the load-bearing part is real, and it is what people miss: the unit of selection is a package, not a transaction, and the score is a ratio, not a fee. A large transaction with a large absolute fee loses to a small one with a better ratio, every time. Once the template is full, how Bitcoin mining works takes over.

Door Five: A Block Arrives, or 336 Hours Pass
At this door the transaction either gets into a block or it doesn’t, and the dominant variable is not money. It is luck.
Ten minutes is an average, not a metronome. A slow stretch stacks the same demand behind fewer blocks; a fast stretch hands out confirmations nobody paid for. Your fate is decided by when blocks land relative to when you broadcast, and no fee influences that. The machinery pulling the average back toward ten minutes is the difficulty adjustment.
That is also why fee estimation is hard in a way no amount of engineering fixes. Estimation is not a table lookup — it is a prediction of what strangers will bid for the next few blocks, and that demand is not observable in advance. Core’s estimator watches how long transactions in each fee rate bucket historically took to confirm, across three timescales, and reports a rate that used to work. Saved estimates expire after 60 hours. When your wallet prints “confirms within 1 block,” it has rounded a probability distribution into a promise without telling you.
If the blocks don’t arrive first, the transaction hits 336 hours and is dropped regardless of fee rate. Most wallets rebroadcast it — which is why “my transaction disappeared” usually resolves itself, and why the disappearance was never a cancellation.
Changing Your Mind: RBF, CPFP, and a Race You Cannot Win by Declaring
People want a cancel button. There isn’t one, and the two substitutes have specific owners.
Replace-by-fee began as opt-in. BIP 125 let a transaction announce its own replaceability with an input nSequence below 0xfffffffe, and shipped in Core 0.12.0 (February 2016). Full RBF, needing no flag, became default in Core 28.0 (October 2024), and 29.0 deleted the switch that turned it off. A wallet saying its transactions can’t be replaced is describing an old default, not a rule.
The modern check matters. Newer Core tests the whole mempool’s feerate diagram: the replaced transaction and its descendants together may not exceed a count (the old ceiling was 100), and the replacement must strictly improve that diagram. With no unconfirmed relatives, this collapses into: pay absolutely more, at a higher fee rate. Note what the rule is: it is the mathematical expression of miner incentive compatibility, not a product promise to users. It exists so a miner who accepts the replacement is never worse off.
RBF has an owner: only whoever holds the private keys for the original inputs can replace — usually the sender.
CPFP (child-pays-for-parent) is the other card, and it belongs to somebody else. Spend one output of the stuck transaction with a high fee; a child cannot confirm before its parent, so a miner who wants the child must take the parent, and the pair scores as combined fee over combined size. The interesting part is ownership: anyone holding one of the outputs can do this, and that is usually the receiver.
Two costs. The child carries the parent’s size in the average, so this is a rescue, not a bargain. And the parent must already sit in the miner’s pool — hence package relay: since Core 28.0 a parent and child can be relayed together opportunistically, and 31.0 widened that beyond the transaction types it originally covered.
No mechanism can cancel a transaction that has been broadcast. A conflicting replacement is a competition, not a deletion. If some miner holds your original and finds a block first, the original confirms and your cancellation arrives too late. The button labelled Cancel is a replacement paying the coins back to you, and it is racing.
Can I cancel a transaction I already broadcast?
No. Nothing can delete a broadcast transaction. A conflict is a race, and if a miner holding the original finds a block first, the original confirms.
Will a higher fee guarantee faster confirmation?
No. It buys a good position on each miner’s private list, not a place in a queue. Nobody owes you inclusion, and losing is not refunded.
What does the Cancel button in my wallet actually do?
It broadcasts a replacement that pays your coins back to yourself. The original stays valid and can still be mined by anyone holding it.
I am the receiver and my payment is stuck — can I fix it?
Often yes, and you may be the only one who can. Whoever holds one of its outputs can spend it at a high fee, and a miner wanting the child must take the parent.
Do all nodes agree on which transactions are waiting?
No. Each node keeps its own list with thresholds its operator chose, and two lists can stay different indefinitely without anything breaking.
What Actually Happens
| The thing people say | What actually happens |
|---|---|
| “My transaction is in the mempool.” | It is in the mempools of the nodes that chose to accept and relay it. No global list exists. |
| “A higher fee buys a place in line.” | It buys a better rank in each miner’s independent sort. Nobody owes you inclusion, and losing is not refunded. |
| “Consensus decides if my transaction is valid.” | A correct transaction can still be refused by node policy; that dies once a block includes it. |
| “The mempool is a queue.” | It is one candidate list per node, each with its own cap and its own fee floor. |
| “I can cancel a transaction I broadcast.” | There is no cancel. A replacement is a race the original can win. |
| “The estimator quotes the price of block space.” | It quotes what worked before; saved estimates expire after 60 hours. |
What I would actually do with all of this:
- Stop thinking in queues — think “which lists am I on, and who is sorting them today.”
- If you are the sender, RBF is your only card, so use it before you need it.
- If you are the receiver, CPFP is your card, and you may be the only one who can play it.
- Treat every fee estimate as a distribution, not a delivery date. A one-block target is a rounded probability.
- Assume the original can win the race. If a payment must not confirm in two forms, don’t send the second.
- Remember expiry is absolute. At 336 hours the fee rate stops mattering; if you still care, rebroadcast.
I am not going to quote you a live pool size or fee rate; both would be stale before you finished this sentence. The structure above is the part that does not go stale.
(The End)


