UTXO vs Account: Two Ways to Keep Score

A blockchain has exactly one job that everything else is built on: keep an honest, shared record of who owns what. No bank, no referee — just a public ledger that thousands of strangers all agree on. But “track who owns what” turns out to have two very different designs, and which one a chain picks ripples all the way out to its fees, its privacy, and whether it can run smart contracts at all.

Here’s the cleanest way to feel the difference up front. Imagine two ways to hold money. One is cash in your pocket — a fistful of specific bills and coins, each a fixed denomination. The other is a bank account — a single number on a screen that goes up when money arrives and down when it leaves. Both let you spend, but they keep score completely differently. Bitcoin chose cash. Ethereum chose the bank account. That’s the whole lesson in one analogy; the rest is detail.

The Question Every Blockchain Has to Answer

Every chain needs a state: a snapshot of who controls which funds right now. The two dominant ways to represent that state are the UTXO model (used by Bitcoin) and the account model (used by Ethereum and most smart-contract chains). They reach the same destination — you can pay people, the maths always balances — but they take opposite routes to get there. Let’s walk through each, then weigh them against each other.

The UTXO Model: Your Balance Is a Pile of Coins

Start with Bitcoin’s design, because it’s the one that surprises people. In the UTXO model, there is no “balance” stored anywhere. Instead, the chain stores a heap of discrete chunks of money called UTXOs.

UTXO stands for Unspent Transaction Output. Unpack it backwards: every time someone pays you, that payment is an output of their transaction. Until you spend it, it sits on the chain unspent, like an uncashed cheque made out to you. So a UTXO is simply a chunk of money of a fixed amount that has been sent to your address and not yet spent. Think of each one as a single bill or coin: a £20 note, a £5 note, a handful of coins. Your “balance” isn’t a number on the chain at all — your wallet finds every UTXO that points to you and adds them up to show you a total.

The cash analogy goes deeper, and this is the part that trips up newcomers. With cash, you can’t tear a £20 note in half. To pay, you hand over whole notes, and if they add up to more than the price, the cashier gives you change. UTXOs work exactly the same way:

• To send money, you must spend whole UTXOs as the transaction’s inputs. You can’t spend “part of” a UTXO any more than you can spend half a coin.
• If your chosen inputs add up to more than you owe, the transaction creates a new output called change — a fresh UTXO sent back to yourself for the leftover.
• A small slice is skimmed off as the transaction fee for the miners who confirm the payment. That’s the only part that actually leaves you.

So paying 0.3 BTC when your smallest UTXO is worth 0.5 BTC looks just like paying for a £3 coffee with a £5 note: you spend the whole note, and £2 comes back as change (minus a tiny fee). Watch it happen. Hit “Send a payment” below and keep your eye on the two sides. On the left (UTXO), a whole coin lifts out of the wallet toward the recipient, and a smaller change chip floats right back in. On the right (account), nothing so dramatic — a single balance bar just ticks down. Same payment, two entirely different mechanics:

Notice what the left side didn’t do: it didn’t edit a number. It consumed old coins and minted new ones (the change coin is brand-new). The chain’s record of “what you own” is always just the set of UTXOs nobody has spent yet.

The Account Model: One Running Balance

Now flip to Ethereum’s design, which matches how almost everyone already pictures money. In the account model, the chain stores a single balance per account — one number that says exactly how much that account holds. Sending money subtracts from your balance and adds to theirs. Receiving money does the reverse. No coins, no inputs, no change outputs: just a number going up and down, like the ledger a bank keeps for your current account.

It’s beautifully simple. To check what you own, you don’t go scanning the chain for chunks and adding them up — you just read your balance field. To pay, the network checks that field is big enough, then edits two numbers (yours down, theirs up). That’s it.

But that simplicity hides a problem: if a transaction is just “subtract from A, add to B,” what stops someone from grabbing a copy of your signed payment and submitting it ten times, draining your account? Or your wallet accidentally broadcasting the same transaction twice? The account model solves this with a nonce.

A nonce is a simple per-account counter that orders your transactions and stops them from being replayed. Your account starts at nonce 0. Your first transaction must carry nonce 0, your second nonce 1, your third nonce 2, and so on. The network refuses any transaction whose nonce it has already processed. So a copied transaction (same nonce as one already done) is rejected instantly, and the network always knows the exact order your transactions run in. Think of it as numbering your cheques so the bank can tell which came first and never cashes the same number twice.

Trade-offs: Why Pick One Over the Other

Neither model is “better” in the abstract — each buys you something and charges you for it. Here’s the honest balance sheet.

What the UTXO model wins (and costs)

Wins:

• Privacy potential. Because every payment creates fresh outputs, wallets can generate a new address for every UTXO. Done well, this scatters your funds across many addresses, making it harder to link them all back to one person.
• Easy parallel validation. Each UTXO is independent — it either exists and is unspent, or it doesn’t. A node can check many transactions at once without them stepping on each other, because they touch different coins.
• Replay protection is built in. Once a UTXO is spent it’s gone; you literally cannot spend the same coin twice, so there’s no need for a separate counter to stop replays.

Costs:

• It feels stateless and clunky. There’s no balance to read — you reconstruct it every time by scanning unspent outputs.
• Coin selection and change are fiddly. Your wallet has to choose which UTXOs to combine to cover a payment (the “coin selection” problem), then manage the change output it gets back. Pick badly and you overpay on fees or fragment your funds into dust.
• Rich smart contracts are hard. Because there’s no persistent per-account memory, expressing complex, stateful programs (lending pools, exchanges) is awkward.

What the account model wins (and costs)

Wins:

• Dead-simple mental model. One balance, goes up, goes down. Exactly how people already think about money.
• A natural home for smart contracts. This is the big one. In the account model a smart contract is just an account that also has code and storage attached. It can hold a balance, remember things between transactions, and run logic when called — which is why Ethereum became the platform for DeFi. (A smart contract is a program that lives on the chain and runs automatically when its conditions are met.)
• No change outputs to manage. Send exactly what you mean to; the balances just adjust.

Costs:

• You need the nonce. Without UTXOs to consume, the chain needs that explicit counter to order transactions and prevent replays — extra bookkeeping the UTXO model doesn’t.
• Global state is a bottleneck. Because transactions touch shared account balances (especially popular contracts), they can conflict, which makes validating them in parallel much harder than in the UTXO world.
• Naive address reuse leaks more. If you keep using one account for everything, your entire financial history is trivially linkable to that single address.

Why It Matters Downstream

This isn’t trivia — the model a chain picks shapes nearly everything you’ll meet later. Bitcoin and Litecoin are UTXO chains. Ethereum and most smart-contract platforms are account chains. From that single choice flow real consequences:

• Fees. On UTXO chains, fees depend on how many coins your transaction bundles together (more inputs = more data = higher fee). On account chains, fees track how much computation a transaction triggers. Different worlds, different cost structures.
• Privacy. UTXO’s fresh-address-per-output habit makes scattering your funds easier; account chains, with one reused address, make your history easier to trace.
• Smart contracts and DeFi. The account model’s “contract = account with code and storage” design is precisely what makes lending protocols, exchanges, and the whole DeFi ecosystem possible — a thread you’ll pull on hard in later courses.

Putting It Together

Two ledgers, one goal. UTXO tracks money as a pile of discrete coins you spend whole and get change from; the account model tracks it as one running balance you nudge up and down, kept in order by a nonce. Chunk it into one picture:

A mixed recap — it pulls from everything above:

Key Takeaways