You hit send on a crypto payment. Your wallet flips to “pending.” A minute passes, then five, and nothing moves. So where exactly is your transaction sitting in the meantime?
The answer is the mempool — the waiting room every transaction passes through before it lands on the blockchain. It’s one of those pieces of plumbing most people never think about until a transfer gets stuck. Once you understand it, a lot of crypto suddenly clicks: why fees spike, why some transfers confirm in seconds while others crawl, and why bots may be watching your trade before it’s ever mined.
This guide works from the basics up to the parts developers and traders actually care about. We’ll cover what a mempool is, how a transaction moves through one, and how Bitcoin and Ethereum handle theirs very differently.
What Is a Mempool?
Let’s start simple. Mempool is short for “memory pool.” It’s the holding area where valid but unconfirmed transactions wait to be picked up and written into a block.
Mempool (memory pool): a temporary, in-memory queue kept by blockchain nodes that stores broadcast transactions after they pass validation but before a miner or validator includes them in a block.
When you send a transaction, it doesn’t hit the blockchain instantly. First it’s broadcast to the network, checked for validity, and dropped into this pool. There it waits — sometimes for seconds, sometimes for hours — until a block producer selects it.
It’s Not One Room — It’s Thousands
Here’s the part that trips people up. There is no single, central mempool. Every node on the network keeps its own local copy, and those copies are never perfectly identical.
A transaction spreads peer to peer, node to node, the way gossip moves through a crowd. Well-connected nodes converge on roughly the same set of pending transactions within seconds, but at any given instant, two nodes may hold slightly different views. That detail matters more than it sounds — it’s the reason transaction ordering is contestable, which we’ll come back to.
Why Every Blockchain Needs One
A mempool exists to solve a timing problem. Blocks are produced on a schedule — roughly every 10 minutes on Bitcoin, every 12 seconds on Ethereum — but transactions arrive continuously, around the clock.
The pool is the buffer between those two rhythms. It also does real work along the way: nodes use it to filter out invalid transactions before they waste block space, and block producers treat it as the menu they build the next block from. Without it, there’d be nowhere for a transaction to live between “sent” and “confirmed.”
How Your Transaction Travels Through the Mempool
Every transaction follows the same basic path, whether you’re sending Bitcoin or calling a smart contract on Ethereum. The mempool sits right in the middle of it.
- Broadcast. Your wallet signs the transaction and sends it to the nodes it’s connected to.
- Validate. Each receiving node checks it — valid signature? enough funds? correct format? does it meet the minimum fee? Anything invalid is rejected on the spot.
- Wait. If it passes, the node adds it to its mempool and relays it onward. Now it’s pending, competing with everything else for a place in the next block.
- Confirm. A miner or validator selects it, includes it in a block, and that block joins the chain. The transaction then leaves every mempool and becomes permanent.
This is critical: a transaction in the mempool is not final. Until it’s in a block, it can be replaced, dropped, or left waiting indefinitely. “Pending” simply means “not yet real.”
The Bitcoin Mempool, Explained
Bitcoin’s mempool is the classic example, and the easiest to picture. At heart it runs as a fee auction — plain and simple.
The Fee Auction
Block space on Bitcoin is scarce. Each block holds a fixed amount of data — about 4 million weight units, which works out to roughly 1 to 4 MB depending on the transactions inside — and a new one arrives only every 10 minutes or so.
Miners want the most value for that limited space, so they sort pending transactions by fee rate, measured in satoshis per virtual byte (sat/vB), and fill the block from the highest bidder down. Pay a competitive rate and you’re likely in the next block or two. Pay below the going rate and you wait. This is why fees climb during congestion: when demand for block space outruns supply, users bid each other up.
The 300 MB Ceiling
A node’s mempool can’t grow forever — it lives in RAM, which is finite. Bitcoin Core, the reference software, sets a default cap of 300 MB (Bitcoin Core documentation).
When the pool hits that limit, the node starts evicting the lowest-fee-rate transactions to make room for better-paying ones. There’s a time limit too: by default, a transaction left unconfirmed for 14 days (336 hours) is dropped entirely. An evicted transaction isn’t lost — your wallet can rebroadcast it, ideally with a higher fee — but it’s a reminder that sitting at the bottom of the pool is a precarious spot.
Rescuing a Stuck Transaction
So your transaction is stuck behind higher bidders. You have two well-worn options.
Replace-by-fee (RBF) lets you resend the same transaction with a higher fee, replacing the original. Child-pays-for-parent (CPFP) works from the other direction: you or the recipient spend the stuck transaction’s output in a new transaction carrying a fee high enough to make miners want both at once. Either way, the fix is to raise the effective fee. Getting the fee right before you broadcast is far simpler than untangling it afterward — a tool like mempool.space shows live congestion and fee estimates so you’re not guessing.
The Ethereum Mempool
Ethereum’s mempool — often called the transaction pool, or txpool — does the same job but carries more weight. Its transactions aren’t just payments; they’re smart contract calls, token swaps, NFT mints, and more. That complexity opens doors Bitcoin’s simpler design never does.
Pending vs. Queued
Ethereum splits its pool into two parts. The pending pool holds transactions ready to execute — their nonce matches the account’s current state. The queued pool holds ones that aren’t executable yet, usually because they’re waiting on an earlier transaction from the same account to go first.
This matters because each Ethereum account processes transactions in strict nonce order. A gap in that sequence parks later transactions in the queue until the missing one shows up. And instead of a simple fee rate, Ethereum uses gas to prioritize: validators favor transactions offering to pay more per unit of computation.
A “Dark Forest” of Bots
Here’s where Ethereum gets genuinely adversarial. Because the public mempool is visible to everyone, anyone can watch what you’re about to do — and act on it first.
In a widely cited 2020 essay, Dan Robinson and Georgios Konstantopoulos of the research firm Paradigm described Ethereum’s public mempool as a “dark forest” — a place where predatory bots lie in wait, ready to pounce on any profitable transaction the moment it appears. Those bots hunt for what’s known as MEV (Maximal Extractable Value) — profit captured by reordering, inserting, or censoring transactions in a block. The term (originally “miner extractable value”) was coined in 2019 by researcher Phil Daian and co-authors in the paper Flash Boys 2.0.
The most common attack is the sandwich: a bot spots your large swap in the mempool, buys ahead of you to push the price up, lets your trade execute at the worse price, then sells right after for a profit — all extracted from your slippage. This isn’t fringe. By one commonly cited research estimate, MEV bots pulled upwards of $675 million out of Ethereum between January 2020 and September 2022 alone, with Flashbots tracking the running totals since.
How the Ethereum Mempool Is Changing
The response to all this has reshaped how transactions even reach Ethereum. Many users and traders now skip the public mempool entirely, routing transactions through private endpoints that hand them straight to block builders. Services like Flashbots Protect and MEV Blocker do exactly this, and each already serves millions of wallets.
Under the hood, block production now runs through Proposer-Builder Separation (PBS): specialized builders assemble blocks, and validators simply pick the highest-paying one. More than 90% of Ethereum blocks are already built this way. The upcoming Glamsterdam upgrade, expected in the second half of 2026, will bake a version of this directly into the protocol as enshrined PBS (ethereum.org). Encrypted mempools — which hide a transaction’s contents until its order is locked in — are further out but actively being built. The throughline is clear: much of Ethereum’s roadmap is about taming what happens inside that waiting room.
Worth noting: not every chain even has a public mempool. Solana, for one, streams transactions straight to the current block leader, which reshapes the MEV picture entirely.
Who Actually Watches the Mempool?
The mempool isn’t just infrastructure humming in the background. Plenty of people watch it closely, for very different reasons.
- Everyday users check it to time transactions and avoid overpaying on fees.
- Traders and searchers monitor it for opportunities — and to defend against them.
- Developers read it to surface pending activity, estimate fees, or trigger app logic the instant a transaction appears.
- Analysts treat mempool size as a live gauge of network health: a persistently bloated pool signals congestion, a thin one signals quiet.
How to Watch the Mempool Yourself
Watching it yourself is straightforward. For Bitcoin, an explorer like mempool.space visualizes the entire pool in real time — fee tiers, the pending count, and how full the next block is shaping up to be. For Ethereum, nodes expose the pool programmatically through methods like txpool_content and txpool_status, and a WebSocket subscription can stream new pending transactions the moment they land.
Reaching the Mempool Through NOWNodes
Every one of those approaches depends on the same thing: a live connection to a node. You can run and sync your own, but that means babysitting client software, storage, and uptime around the clock — before you’ve written a line of the app you actually set out to build.
NOWNodes takes that off your plate. You sign up, generate an API key, and connect straight to Ethereum, Bitcoin, or any of 120+ other chains through one hosted endpoint — no servers to maintain. Standard methods work unchanged, so you can broadcast transactions with eth_sendRawTransaction and read blockchain data exactly as you would against your own node.
A few things make it a fit for mempool work in particular:
- WebSocket streams push pending transactions in real time — the backbone of any bot, dashboard, or fee estimator that needs to react the instant a transaction appears.
- Multi-chain coverage lets you watch the Bitcoin and Ethereum mempools (and plenty more) through a single provider instead of wiring up several.
- A free START plan gives you 100,000 requests a month, and there are even public endpoints you can hit with no API key at all — handy for a quick look before you commit to anything.
- Testnet endpoints let you rehearse the whole flow on a testnet before risking real funds on mainnet.
Conclusion
The mempool is the crossroads every crypto transaction passes through — the gap between hitting send and getting confirmed. Understand it, and the rest of the network stops feeling like a black box.
A few things are worth carrying with you. Every node keeps its own copy, so there’s no single global queue. Fees decide priority, which is why they climb the moment the network gets busy. Bitcoin runs a clean fee auction with a 300 MB pool; Ethereum’s is a more complex, more contested space where bots hunt for value and much of the roadmap is aimed at reining them in. Whether you’re sending your first transaction or building an app on top of one, the mempool is where the action quietly happens — and now you know how to read it.
And if you’re building on top of that waiting room rather than just watching it, the connection underneath matters. NOWNodes hands you reliable access to Ethereum, Bitcoin, and 120+ other networks through one API — free to start, with nothing to sync or maintain yourself.
FAQ
What is a mempool in simple terms?
It’s the waiting room for crypto transactions. After you send one, it sits in the mempool — a queue of unconfirmed transactions — until a miner or validator picks it up and adds it to a block. Only then is it final.
Where is the mempool located?
There isn’t one central mempool. Every node on the network keeps its own copy in memory, and they sync by relaying transactions to one another. Well-connected nodes hold nearly the same set of pending transactions, though never a perfectly identical one.
Why is my transaction stuck in the mempool?
Almost always because its fee is too low. Miners and validators prioritize higher-paying transactions, so a low fee leaves yours waiting behind better bidders. On Bitcoin you can fix this with replace-by-fee (RBF) or child-pays-for-parent (CPFP), both of which effectively raise the fee.
How is the Bitcoin mempool different from the Ethereum mempool?
Bitcoin’s is a straightforward fee auction, with transactions ranked by satoshis per virtual byte. Ethereum’s transaction pool is more complex: it handles smart contract calls, splits into pending and queued transactions, prices by gas, and is a hotspot for MEV bots.
Can transactions be removed from the mempool without confirming?
Yes. If the pool fills past its limit (300 MB by default on Bitcoin), nodes evict the lowest-fee transactions first. Unconfirmed transactions also expire after roughly 14 days. In both cases the transaction can be rebroadcast, usually with a higher fee attached.
What does mempool size tell you?
It’s a real-time read on congestion. A large, growing mempool means more transactions are arriving than getting confirmed, so fees rise and waits stretch out. A small one means the network is quiet and transactions should confirm quickly and cheaply.
Is it safe to broadcast a transaction to the public mempool?
For a simple transfer, generally yes. But on Ethereum, large trades exposed in the public mempool can be targeted by MEV bots through sandwich attacks. That’s why many traders route sensitive transactions through private endpoints that bypass the public pool.
How do I access or monitor the mempool programmatically?
You need a connection to a node. Rather than running your own, you can use a provider like NOWNodes: generate an API key, connect to Ethereum, Bitcoin, or 120+ other chains, and use standard methods to broadcast transactions or subscribe to pending ones over WebSocket. The free START plan covers 100,000 requests a month, and public endpoints are available with no key at all.
