UTXO (Unspent Transaction Output)

What Is a UTXO?

A UTXO (Unspent Transaction Output) is an individual piece of Bitcoin that has been received but not yet spent. Think of it like a physical coin or bill: you can't tear a $20 bill in half to pay $10. Instead, you hand over the full bill and receive $10 in change. Bitcoin works the same way. Each UTXO is a whole unit that must be consumed entirely when spent, with any excess returned as a new UTXO (change output).

The UTXO model is the accounting system that underpins Bitcoin and several other blockchains. Unlike the account model used by Ethereum, where each address has a running balance that gets incremented and decremented, Bitcoin has no concept of "balances" at the protocol level. A wallet's balance is simply the total value of all UTXOs that its private keys can unlock. For a deeper comparison of these two approaches, see the UTXO model vs. account model research article.

Every UTXO originates from either a coinbase transaction (the reward a miner receives for creating a block) or as an output of a regular transaction. Once a UTXO is used as an input to a new transaction, it ceases to exist: it is "spent" and replaced by the new outputs that transaction creates.

How It Works

A Bitcoin transaction is fundamentally a data structure that consumes one or more existing UTXOs (inputs) and produces one or more new UTXOs (outputs). The sum of input values must be greater than or equal to the sum of output values, with the difference going to the miner as a transaction fee.

UTXO Structure

Each UTXO consists of two core components:

• Value: the amount of Bitcoin (in satoshis) stored in this output
• Locking script (scriptPubKey): a Bitcoin Script that defines the conditions required to spend this output. Common types include Pay-to-Public-Key-Hash (P2PKH), Pay-to-Script-Hash (P2SH), and Pay-to-Witness-Public-Key-Hash (P2WPKH)

A simplified representation of a UTXO within a transaction:

// Transaction output (becomes a UTXO until spent)
{
  "txid": "a1b2c3...f4e5d6",
  "vout": 0,                    // Output index within the transaction
  "value": 50000,               // Amount in satoshis (0.0005 BTC)
  "scriptPubKey": {
    "type": "witness_v0_keyhash",
    "address": "bc1q..."        // The address that can spend this UTXO
  }
}

Transaction Flow

When you send Bitcoin, the wallet assembles a transaction by following these steps:

1. Select one or more UTXOs from your wallet whose combined value covers the desired payment plus fees
2. Create inputs that reference each selected UTXO by its transaction ID and output index
3. Provide unlocking scripts (witnesses or scriptSigs) that satisfy each input's locking conditions
4. Define new outputs: one paying the recipient, and (usually) one returning change back to your own wallet
5. Broadcast the signed transaction to the network for inclusion in a block

Here is a simplified example of a transaction spending one UTXO and producing two new ones:

// Sending 30,000 sats with a 1,000-sat fee
// Input UTXO: 50,000 sats

Inputs:
  [0] txid: a1b2c3...f4e5d6, vout: 0   // 50,000 sats (consumed)

Outputs:
  [0] 30,000 sats -> bc1q_recipient...  // Payment to recipient
  [1] 19,000 sats -> bc1q_change...     // Change back to sender

// Fee: 50,000 - 30,000 - 19,000 = 1,000 sats

After confirmation, the original 50,000-sat UTXO no longer exists. Two new UTXOs have been created: one controlled by the recipient (30,000 sats) and one controlled by the sender as change (19,000 sats).

UTXO Selection Algorithms

When a wallet needs to fund a transaction, it must choose which UTXOs to use as inputs. This decision, called "coin selection," has significant implications for fees and privacy. Common strategies include:

• Largest-first: picks the biggest UTXO that covers the amount. Simple but tends to create large change outputs and can link high-value UTXOs to small payments
• Branch and bound: searches for a combination of UTXOs that exactly matches the target amount (plus fees), avoiding change outputs entirely when possible. Used by Bitcoin Core
• Random selection: picks UTXOs randomly to improve privacy by making spending patterns harder to analyze. Trades fee efficiency for reduced traceability
• FIFO (first-in, first-out): spends the oldest UTXOs first. Useful for reducing the overall size of the UTXO set over time

For multi-party transactions or complex spending conditions, wallets often construct PSBTs (Partially Signed Bitcoin Transactions) that allow multiple signers to collaboratively select and authorize UTXO inputs before broadcasting.

Use Cases

Payment Channel Funding

Lightning Network channels are opened by locking a UTXO into a 2-of-2 multisig output. The value of this funding UTXO determines the channel capacity. When the channel closes, the final state is settled back on-chain as new UTXOs distributed according to the latest balance. Techniques like splicing allow channels to add or remove funds by restructuring the underlying UTXO without closing the channel.

Multisig Custody

UTXOs can be locked behind multisignature scripts, requiring multiple private keys to spend. This is the foundation of multisig wallets used by institutions, DAOs, and security-conscious individuals. Each UTXO in a multisig wallet requires coordinated signing, often facilitated through PSBTs.

Batch Payments

Exchanges and payment processors consolidate multiple payments into a single transaction with many outputs. This creates one transaction that consumes a few large UTXOs and produces dozens of smaller UTXOs, each paying a different recipient. Batching reduces on-chain footprint and fees compared to sending individual transactions.

Anchor Outputs in Lightning

Anchor outputs are small UTXOs attached to Lightning commitment transactions that allow either channel party to fee-bump the transaction using child-pays-for-parent (CPFP). These UTXOs are deliberately kept small (typically 330 satoshis) and exist purely to enable fee adjustment after broadcast.

UTXO Set and Node Requirements

The UTXO set is the complete collection of all unspent transaction outputs across the entire Bitcoin network at any given moment. Every full node must maintain this set in memory (or fast storage) to validate new transactions: when a transaction arrives, the node checks that each input references a UTXO that actually exists and has not already been spent.

As of early 2026, the UTXO set contains roughly 180 million entries and requires several gigabytes of storage. Growth in the UTXO set increases the hardware requirements for running a full node, which has implications for network decentralization. If the set grows too large, fewer participants can afford to run nodes, concentrating validation power.

Transactions that create more outputs than they consume expand the UTXO set, while transactions that consolidate many inputs into fewer outputs shrink it. Protocol-level mechanisms like ephemeral dust policies discourage the creation of tiny, uneconomical UTXOs that bloat the set without practical utility.

Consolidation and Splitting Strategies

UTXO management is an ongoing concern for any wallet holding multiple outputs. Two primary strategies exist:

Consolidation

Consolidation combines many small UTXOs into a single larger one. This is typically done during low-fee periods to reduce the number of inputs needed for future transactions (more inputs means larger transaction size and higher fees).

// Consolidation transaction
Inputs:                          Outputs:
  [0]  5,000 sats                  [0] 95,000 sats -> your address
  [1]  8,000 sats
  [2] 12,000 sats
  [3] 25,000 sats
  [4] 15,000 sats
  [5] 32,000 sats
                                   // Fee: 2,000 sats
// 6 UTXOs become 1 UTXO

The tradeoff: consolidation transactions link all input UTXOs together on-chain, revealing that they belong to the same owner. This is a significant privacy cost.

Splitting

Splitting breaks a large UTXO into several smaller ones. This is useful when you expect to make many future payments and want to avoid creating change outputs each time, or when you need UTXOs of specific denominations for Lightning channel funding.

Risks and Considerations

Privacy and UTXO Linkage

The UTXO model creates a transparent chain of ownership. Chain analysis firms trace the flow of funds by following UTXO inputs and outputs across transactions. Common heuristics include:

• Common-input-ownership: if multiple UTXOs are spent in the same transaction, they likely belong to the same person
• Change detection: the smaller or "round number" output is often identified as change, revealing which output went to the sender
• Address reuse: spending from the same address multiple times makes it trivial to link transactions

Techniques like CoinJoin, PayJoin, and Taproot help mitigate these privacy leaks by making transaction structures less distinguishable.

Dust Attacks

A dust attack sends tiny, nearly worthless UTXOs to a target wallet. If the victim later spends these dust UTXOs alongside their regular funds, the attacker can use the common-input-ownership heuristic to link the victim's UTXOs together and deanonymize their holdings. The best defense is to avoid spending unrecognized dust outputs.

Fee Overhead from Small UTXOs

Every UTXO used as a transaction input adds bytes to the transaction, increasing the fee. If a UTXO is worth less than the fee required to spend it, it becomes economically unspendable. These "stranded" UTXOs are a permanent cost to the holder. During high-fee environments, wallets with many small UTXOs may find that a large portion of their balance is effectively frozen.

UTXO Set Bloat

Protocols and applications that create excessive numbers of small outputs contribute to UTXO set growth. This externality increases the cost of running a full node for everyone on the network. Bitcoin's dust limit (a minimum output value, currently 546 satoshis for P2PKH) exists specifically to prevent the creation of outputs that are uneconomical to spend and would only bloat the UTXO set.

Layer 2 solutions like the Lightning Network and Spark help address UTXO scalability by moving frequent, small-value transfers off-chain. Instead of creating a new UTXO for every payment, thousands of transactions can be settled through a single channel or virtual UTXO, dramatically reducing on-chain footprint.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.