How Crypto Transactions Work: From Send to Settled

There is a strange moment in every crypto transfer. You press send, the screen shows a spinner, and your money is somewhere in between: it has left your balance but has not landed anywhere you can see. Bank apps hide that plumbing. Crypto does the opposite. Every stage of the journey happens in public, and once you know what each stage means, a pending transaction stops being a mystery and becomes something you can read like a tracking number.

This guide walks through the full life of a crypto transaction in five stages: building and signing, broadcasting to the network, waiting in the mempool, getting included in a block, and stacking up confirmations until the network treats the payment as settled. We will use Bitcoin and Ethereum as the main examples because they are the largest networks and their official documentation spells out how each step works. The same ideas carry over, with different numbers, to most other chains. One honest note before we start: none of this is investment advice, and nothing here guarantees how fast any particular transfer will go through. Networks get busy, fees swing, and exchanges set their own crediting rules.

The five stages at a glance

Think of a crypto transaction like a letter moving through a postal system that anyone can watch. You write and sign the letter. A courier photocopies it to thousands of post offices at once. It sits in a sorting room until a sorter picks it up, usually choosing the letters with the best postage first. Once it is loaded onto an outgoing truck, every checkpoint the truck passes makes it less and less plausible that anyone could pull your letter back out, until the system treats it as delivered.

Each stage answers a different question you might have while staring at a pending transfer. Who authorized this payment? That is signing. Has the network seen it? That is broadcast. Why is it waiting? That is the mempool and the fee market. Is it on the blockchain yet? That is block inclusion. Can it still be undone? That is confirmations and finality.

Stage one: your wallet builds and signs the transaction

Before anything touches the network, your wallet software assembles a small package of data. At minimum it says who is sending, who is receiving, how much is moving, and what fee you are offering. Then it signs that package with your private key, the cryptographic proof that the real owner of the funds authorized this exact payment. If the idea of keys is fuzzy, our guide to public and private keys covers it in plain English.

The details differ by chain. On Ethereum, every transaction carries a nonce, which the official documentation describes as a sequentially incrementing counter that marks the transaction number from your account, according to ethereum.org. The nonce forces your transactions to process in order and prevents the same payment from being replayed twice. The transaction also carries a gas limit, which caps how much computation you are willing to pay for; a simple transfer of ether uses 21,000 gas units, per the same documentation.

Bitcoin works differently under the hood. Instead of account balances, a Bitcoin transaction spends specific chunks of previously received coins, called unspent transaction outputs, and creates new chunks for the recipient and usually some change back to you. If you want the deeper story, see our explainer on Bitcoin UTXOs.

It is worth being precise about what signing does and does not establish. A signature locks the contents of that exact package: change a single character of the recipient address or the amount and the signature no longer matches, so nobody can quietly edit a signed transaction. But signing alone does not make a transaction valid. Nodes still independently check that the funds exist, that an Ethereum nonce is the right next number for your account, and that every other network rule is satisfied. And a signed transaction that has not yet confirmed is not set in stone, because the same private key can sign a competing transaction that replaces it. On Ethereum, a new transaction reusing the same nonce with a higher fee supersedes the pending one, and the replacement can carry a different amount or even a different recipient, as MetaMask's support documentation explains. Many Bitcoin wallets offer a similar replace by fee mechanism.

What becomes practically irrevocable is a payment that has confirmed and been buried under further blocks. As bitcoin.org puts it, a Bitcoin transaction cannot be reversed, it can only be refunded by the person receiving the funds. There is no fraud department to call. That is why the moment before you press send remains the single most important checkpoint in the journey: once your payment is deep in the chain, the network will treat it as history whether or not the address was the one you meant.

Stage two: broadcast, or telling the whole network at once

When you press send, your wallet hands the signed transaction to a node, a computer running the network's software. That node checks the transaction for validity: the signature must match, the funds must exist, and the format must follow the rules. If it passes, the node announces it to its peers, who verify it themselves and pass it along. The Bitcoin Developer Guide describes this relay process in detail: valid transactions cascade across the network node by node.

Within seconds, thousands of computers around the world hold a copy of your unconfirmed transaction. This is the first comfort worth internalizing: once broadcast succeeds, your transaction no longer depends on your wallet, your phone, or your internet connection. You can close the app. The network has it.

At this point a block explorer will usually show your transaction as pending or unconfirmed. If you have never used one, our walkthrough of block explorers shows how to paste in a transaction ID and watch your own transfer move through the stages in this article. It is the crypto equivalent of package tracking, and it works for anyone, not just the sender.

Stage three: the mempool, crypto's public waiting room

An unconfirmed transaction lives in what is called the mempool, short for memory pool. Each full node keeps its own collection of valid transactions that are eligible for the next block. Older writeups sometimes describe this pool as purely temporary, wiped clean whenever a node restarts, but that has not been true of the reference software for years. Since version 0.14, Bitcoin Core saves its mempool to a file on shutdown and reloads it at startup, and the Bitcoin Core 0.15.0 release notes confirm this persistence is switched on by default.

Two practical facts follow from the design. First, there is no single official mempool. Every node has its own version, and they mostly overlap but never match perfectly, which is why two explorers sometimes disagree about whether your transaction is pending. Second, nodes can evict transactions: mempools have size limits, and when they fill up, the lowest fee transactions get purged to make room for better paying ones.

Here is the subtlety that trips people up: eviction is a local housekeeping decision by one node, not a cancellation of your payment. The signed transaction remains completely valid. Other nodes may still hold it, and anyone with a copy, including the recipient or your own wallet software, can rebroadcast it at any time. A payment that vanishes from explorers during a congested week can reappear and confirm during a quiet one. If you genuinely need to cancel an unconfirmed payment, the only dependable way is to get a conflicting transaction confirmed first: one that spends the same coins on Bitcoin, or reuses the same nonce on Ethereum, and sends the funds back to yourself with a higher fee. Once that replacement is confirmed and buried under several blocks, the original conflicts with the recorded history and cannot confirm unless the block holding the replacement is itself reorganized away, which becomes less and less likely with each confirmation. In other words, even a cancellation deserves the same confirmation discipline as a payment.

The mempool is also where the fee market lives. Block space is limited, so when more people want to transact than a block can hold, the people offering higher fees effectively move to the front of the line. On Ethereum, the fee has two parts: a base fee that is burned, meaning destroyed rather than paid to anyone, and a priority fee that tips the validator for including you, with any unused gas refunded to the sender, per ethereum.org. If fees are your main concern, our dedicated guide to crypto gas fees goes much deeper.

A clearly hypothetical example makes the waiting room concrete. Imagine the next Bitcoin block has room for about 3,000 transactions and 9,000 are waiting. With a fee in the top third of what is being offered, you will likely ride in the next block or two. With a bottom tier fee, you may wait through many blocks while better paying transactions keep cutting ahead. Nothing is broken in that scenario: you bought a cheaper ticket, and cheaper tickets board last. Those counts are invented for illustration, but the mechanism is exactly how the real queue behaves.

Stage four: a block includes your transaction

Eventually, a block producer assembles the next block. On a proof of work chain like Bitcoin, that producer is a miner who won the race to solve a computational puzzle. On a proof of stake chain like Ethereum, it is a validator chosen by protocol rules. Either way, the producer selects transactions from its mempool, typically favoring those that pay the most per unit of space or computation, and packages them into a block that the rest of the network verifies and adopts.

The tempo differs enormously between chains. Bitcoin produces a new block roughly every 10 minutes on average, but the process is probabilistic. As bitcoin.org explains, an individual block may arrive much sooner or much later than the average, with no guaranteed minimum or maximum delay. The 10 minute figure is a long run average, maintained by a difficulty adjustment that the Bitcoin Developer Guide describes as recalibrating every 2,016 blocks against a two week target.

Ethereum runs on a fixed metronome instead. Time is divided into slots of 12 seconds, with 32 slots forming an epoch, per ethereum.org. One block can be proposed per slot, so a transaction paying a competitive fee is usually picked up quickly. Inclusion, either way, is not the end of the story on either chain, and treating it as the end is the most common mistake newcomers make.

Stage five: confirmations, and why one is not enough

When your transaction is in a block, it has one confirmation. Each additional block built on top adds another. The number matters because of a quirk of how decentralized networks agree on history: occasionally two block producers create competing blocks at nearly the same moment. The Bitcoin Developer Guide notes that multiple blocks can share the same height when this happens, creating an apparent fork. The network resolves it by following the chain with the most accumulated work, and blocks on the losing side become stale and are thrown away.

If your transaction happened to be only in a stale block, it returns to the mempool and must be mined again. Usually it will be, since it is still valid, but a sophisticated attacker could try to exploit that window to spend the same coins twice. Every block buried on top of yours makes that attack exponentially harder, which is why recipients wait for multiple confirmations before treating money as truly received. Settlement on Bitcoin is probabilistic by design: no number of confirmations takes the chance of reversal to exactly zero, it just shrinks it toward the point where everyone is comfortable ignoring it.

How many is enough? Bitcoin.org offers a widely cited rule of thumb: one confirmation is somewhat reliable, three are mostly reliable, and six are the minimum recommendation for high value transfers, with far more suggested in unusual emergency situations. Many exchanges and merchants build their own policies around numbers like these, so always check what your specific platform requires before assuming a deposit will credit at a certain time.

A fun piece of trivia shows how seriously the protocol itself takes this logic: newly mined bitcoins from a block reward cannot be spent at all until the block has 100 blocks built on top of it, per the developer documentation. The network forces its own miners to wait far longer than it asks of ordinary users.

Finality: when settled really means settled

Bitcoin's security model is often called probabilistic finality. There is no official moment when a transaction becomes mathematically irreversible; instead, reversal becomes so expensive and unlikely with each confirmation that everyone agrees to treat the payment as final. Six confirmations, roughly an hour on average, is the conventional threshold for large amounts, but it is a convention rather than a protocol rule.

Ethereum added an explicit finality mechanism when it moved to proof of stake. Validators vote on checkpoints at the start of each epoch. When at least two thirds of all staked ether agrees on a pair of checkpoints, the more recent one becomes justified and the earlier one becomes finalized, according to ethereum.org. An epoch spans 32 slots of 12 seconds, about 6.4 minutes, and finalizing a block requires checkpoint votes across two epochs. It is tempting to multiply that out to 12.8 minutes and call it the answer, but a transaction can land anywhere within an epoch, so the wait depends on the block's position. The Ethereum Foundation describes the network's current finality time as between 13 and 19 minutes under normal conditions.

Even finality is a very strong economic assurance rather than an absolute mathematical guarantee, and it rests on the consensus system working as designed. Ethereum.org discusses reversal attacks directly: reverting a finalized block would require an attacker to commit to losing at least one third of all staked ether, a stake worth many billions of dollars, because the protocol destroys the collateral of validators who try to rewrite finalized history. That is what people mean by economic finality: reversal remains theoretically possible under extreme attacks on the consensus layer, but it is engineered to be ruinously expensive, so the whole ecosystem treats finalized blocks as settled.

Be careful, though, with sweeping comparisons to bank transfers. Traditional rails play by different rules from one another: some interbank systems settle with no reversal window at all, while card payments can be disputed and charged back under consumer protection rules. Crypto finality is a statement about the ledger itself. It does not come bundled with the refund and dispute machinery that banking regulations attach to certain products, and that cuts both ways: harder for a fraudster to claw back, and harder for you to recover from a mistake.

Finalized is not the same as paid: check that the transaction succeeded

Here is a trap that catches even experienced users, and it deserves its own section. On Ethereum, inclusion and finality tell you that a transaction is recorded with the strongest assurance the network can offer. They do not tell you that it did what the sender intended. An Ethereum transaction can fail during execution, for example because a smart contract rejected the call or the gas limit ran out, and that failed transaction is still included in a block, still finalized along with everything around it, and still charges the sender gas. What it does not do is move the funds.

The protocol makes this distinction explicit. Every processed transaction produces a receipt, and under EIP-658, the Ethereum specification that defines the receipt status field, that receipt carries a status code: 1 indicating success and 0 indicating failure due to any operation that caused the transaction to revert. Block explorers surface the same field as a Success or Fail label near the top of the transaction page. A reverted transaction with status 0 can sit in a finalized block indefinitely, looking fully settled to anyone who only counts confirmations, while having transferred nothing at all.

So if you are the one receiving money, never treat a payment as received, and never release goods or credit a customer, on the strength of inclusion or finality alone. Verify three things, in order. First, the receipt status shows success. Second, the transfer actually landed where it was supposed to: the explorer should show your exact address receiving the exact amount you agreed on. This matters doubly for stablecoins and other tokens, where the transaction is technically a call to the token contract, and you need to confirm the token transfer itself credited your address rather than just noting that some contract call went through. Third, your confirmation or finality threshold has passed. Finality tells you the record is about as settled as the network can make it, short of a consensus level attack the protocol is designed to make ruinously expensive; the receipt and the transfer details tell you what the record actually says.

Bitcoin does not have an equivalent failure mode, because a transaction that breaks the rules is simply never accepted into a block in the first place. But the recipient side discipline is the same: before crediting a payment, check that a confirmed transaction output pays your address the amount you expected, not just that some transaction with a familiar ID exists.

When things go wrong: stuck, replaced, and misdirected transactions

The most common problem is the stuck transaction: you attached a fee that looked fine ten minutes ago, the network got busy, and now you are deep in the queue. You have three honest options. You can wait, since fee spikes often subside within hours and your transaction stays valid in the meantime. You can speed it up: on Ethereum your wallet signs a replacement reusing the same nonce with a higher fee, per MetaMask's documentation, and on Bitcoin replace by fee does the equivalent job if your wallet supports it. Or you can actively cancel by confirming a replacement that sends the funds back to yourself.

What you should not do is simply wait for the transaction to fall out of mempools and assume that counts as a cancellation. Eviction is local and invalidates nothing. Until a conflicting transaction confirms and settles, your original signed payment can be rebroadcast by anyone holding a copy and may confirm at any point, sometimes long after you stopped watching for it. You should also never panic send a second, separate transaction for the same purpose. If the network later processes both, you have paid twice, and settled payments have no undo. Check a block explorer first and act on what you see rather than on the spinner in your app.

The more painful failure is user error at signing time: sending to a mistyped address, to an address on the wrong network, or to a scammer. The protocol cannot distinguish a mistake from an intention. Be especially wary of one habit that feels careful but is not: glancing at only the first and last few characters of an address. In a scam called address poisoning, attackers generate a lookalike address that deliberately matches the beginning and end of an address you have used before, then send you a tiny transfer so the fake shows up in your transaction history, hoping you will copy it later, as MetaMask's address poisoning guidance explains. Partial checks are exactly the blind spot this scam is built around. The reliable defense is to verify the entire address, character by character, against a trusted record of the destination, such as a saved and verified contact in your wallet's address book or the address shown to you directly by the recipient, and to avoid copying addresses out of your transaction history at all. Use QR codes or verified address books rather than typing, and send a small test amount before moving anything significant, then pay the same verified address rather than a fresh copy from history. The test costs one extra fee and a few minutes; the mistake it prevents can cost everything you sent.

Finally, remember that what an exchange shows you is its own ledger, not the blockchain. A deposit may be fully confirmed on chain while the exchange still shows it as processing, because its crediting policy requires extra confirmations or a manual review. The reverse also happens: a withdrawal can show as complete internally before the on chain transaction has confirmed. When the two views disagree, the blockchain is the ground truth, and the explorer is how you read it.

Practical habits that make every transfer calmer

You do not need to memorize protocol parameters to use crypto safely. A short set of habits covers almost everything this article explains. Verify the full destination address character by character against a trusted source, not just its first and last characters, and confirm you are on the right network before signing. Check current fee conditions in your wallet or on an explorer, and if your transfer is not urgent, consider waiting out obvious congestion. Save the transaction ID your wallet gives you, because that string lets anyone track the payment independently. Know your recipient's confirmation policy before you promise anyone that money has arrived. And for any amount that would hurt to lose, send a small test first.

Fee awareness also compounds in a way that is easy to underestimate. Here is a purely hypothetical illustration, not a forecast and not based on any real fee data: suppose that by batching transfers, avoiding peak congestion, and skipping unnecessary on chain moves, someone trims an average of 25 dollars per month in avoidable network fees and invests that savings instead. The calculator below lets you play with assumptions like that. The math is generic compounding, and real returns vary and can be negative.

One more habit deserves its own sentence: treat anything still in the mempool as not yet real, and on Ethereum, treat anything without a success status on its receipt as not a payment at all. Do not release goods, consider a debt repaid, or celebrate a sale until the transaction shows successful execution, the funds show up at the intended address, and the confirmation or finality threshold you care about has passed.

The bottom line

A crypto transaction is not a single event but a journey with five legs: it is signed in your wallet, broadcast to thousands of nodes, queued in the mempool fee market, included in a block, and then buried under enough subsequent blocks, or formally finalized, that the network treats it as settled history. Bitcoin reaches that comfort point through probability, with six confirmations in roughly an hour as the traditional benchmark for large sums, while Ethereum reaches it through an explicit finality vote that the Ethereum Foundation says normally completes in about 13 to 19 minutes. Neither route produces a mathematically absolute guarantee; both produce a record that would take an extraordinarily costly attack to rewrite, which is why the world treats it as settled.

Once you can name the stage your transaction is in, the anxiety mostly evaporates. A pending transfer is not lost money; it is a letter in a sorting room you can watch in real time. The skills that matter are all front loaded: verify the whole address before you sign, pay a sensible fee for your urgency, and before you act on money received, confirm that the transaction actually succeeded and paid the right address, not merely that it was recorded. Master those, and the plumbing that scares most beginners becomes one of crypto's most reassuring features, because for once in finance, you can see exactly where your money is.