When you send Bitcoin, you're not actually moving a coin from one place to another. You're constructing a message that says: "Here is proof I can spend this previous payment, and here is where the funds should go next." The part of that message that provides the proof is called a Bitcoin input. It's the foundation of every transaction on the network, and understanding it unlocks how Bitcoin actually works under the surface.
What a Bitcoin input actually is
A Bitcoin input is a reference to a previous unspent transaction output. It points back to an earlier transaction, names a specific output from that transaction, and includes a cryptographic signature proving that the sender is authorised to spend it.
Think of it like this. When you receive Bitcoin, what you actually receive is an output: a locked parcel addressed to your public key. That parcel sits in the network's memory as an unspent transaction output, or UTxO. When you want to spend it, your wallet creates a new transaction. The input in that transaction is your claim on the parcel, unlocked with your private key signature.
Without inputs, a transaction has nothing to spend. Without valid inputs, the network rejects it outright.
What's inside a Bitcoin input
Each input in a transaction contains four core pieces of data:
- Transaction ID (txid): the unique identifier of the earlier transaction that created the output being spent.
- Output index (vout): a number (starting at zero) that points to the exact output within that earlier transaction.
- scriptSig or witness data: the unlocking script that satisfies the conditions set by the output's locking script. For newer address types, this is held in the witness field rather than the scriptSig.
- Sequence number: a field used for advanced features like replace-by-fee and timelocks.
Together, the txid and vout act like coordinates: row and column in a spreadsheet. They pinpoint exactly which UTxO is being consumed. The scriptSig or witness data is what actually proves you're allowed to spend it.
How inputs connect to outputs
Every Bitcoin transaction consumes one or more inputs and creates one or more outputs. The inputs must add up to at least as much value as the outputs, with any leftover going to the miner as a fee. This is why understanding what a Bitcoin UTxO is and how it affects your wallet matters so much: inputs and UTxOs are two sides of the same coin.
When a transaction is broadcast and confirmed, the inputs it references are marked as spent. They can never be used again. The outputs it creates become new UTxOs, waiting to be used as inputs in a future transaction. This chain of inputs pointing back to previous outputs is what gives Bitcoin its audit trail. Every satoshi can be traced from its creation in a coinbase transaction all the way to its current resting place.
Why a transaction can have multiple inputs
Your wallet doesn't hold one big balance. It holds a collection of UTxOs of different sizes, from different past transactions. If you want to send 0.05 BTC but your wallet holds two UTxOs of 0.03 BTC each, it creates a transaction with two inputs and combines them. This is entirely normal. A single transaction can carry dozens of inputs if necessary.
The trade-off is size. More inputs mean a larger transaction in bytes, which means a higher fee at the same fee rate. Wallet software chooses inputs to minimise this cost while satisfying the payment amount. The selection strategy, called coin control, is one of the subtler arts of Bitcoin transaction construction.
How the input's signature proves ownership
The scriptSig (or witness data, for SegWit and Taproot transactions) contains a digital signature produced with your private key. The network checks that signature against the public key embedded in the original output's locking script. If the signature is valid, the input is accepted. If it's not, the transaction fails.
This is what makes Bitcoin trustless. No bank verifies your identity. The math does. The signature can only be produced by whoever controls the private key that corresponds to the address that received the funds. No key, no spending.
It's also why your address type matters. Older legacy address formats include the full unlocking script in the scriptSig, making inputs larger and more expensive. Newer formats like SegWit move the signature into a separate witness field, reducing the weight of each input and cutting fees. Understanding what a Bitcoin SegWit address is and how it works gives you a clearer picture of why this upgrade was so significant for everyday transaction costs.
What happens if an input is invalid
Nodes validate every input in every transaction before accepting it. An input fails validation if the referenced UTxO doesn't exist, if it's already been spent, or if the unlocking script doesn't satisfy the locking conditions. Any one of these failures causes the entire transaction to be rejected. It's not confirmed, it doesn't appear in a block, and no funds move.
This strict validation is what prevents double-spending. Once a UTxO is consumed by a confirmed transaction, it's gone from the UTXO set. Any subsequent transaction trying to reference the same output is invalid by definition, because the output no longer exists as unspent.
Inputs in the context of raw transactions
If you've ever looked at the hex data of a raw transaction, the input section appears right after the version number and the input count. Each input is encoded in sequence: txid (reversed byte order), vout (4 bytes, little-endian), scriptSig length and data, then the sequence number. The structure is compact and precise, optimised for machine parsing rather than human readability.
Most Bitcoin users never need to interact with raw transaction data directly. But knowing what's in an input helps when something goes wrong: a stuck transaction, a missing output reference, or a fee that's too low to get confirmed. The input is where most of those problems originate.
Bitcoin's design keeps inputs simple by design. Each one is just a reference and a proof. The elegance is in how billions of those references chain together across the entire history of the network, building an unbroken ledger from the genesis block to today's most recent confirmation.