ScriptPubKey (Locking Script)

A ScriptPubKey, also known as a locking script, is the piece of Bitcoin Script placed on a transaction output (TXO) that specifies the conditions that must be met to spend the funds it holds. It acts as a cryptographic lock, and only a transaction input containing a valid ScriptSig (unlocking script) that, when combined and executed, returns a TRUE result can unlock and spend the output. This mechanism is the foundation of Bitcoin's programmable money system, enabling various spending conditions beyond simple key ownership.

The most common type is the Pay-to-Public-Key-Hash (P2PKH) script, which locks funds to a specific Bitcoin address. Its format is OP_DUP OP_HASH160 <Public Key Hash> OP_EQUALVERIFY OP_CHECKSIG. To spend it, the spender must provide a signature and the full public key that hashes to the specified value. Other standard forms include Pay-to-Script-Hash (P2SH), which locks to the hash of a redeem script, and Pay-to-Witness-Public-Key-Hash (P2WPKH), the SegWit version of P2PKH that moves the signature data (witness) outside the base transaction.

The execution of a spending attempt involves concatenating the unlocking script (ScriptSig or witness data) with the locking ScriptPubKey and processing the combined script with Bitcoin's stack-based virtual machine. The script can encode complex conditions using opcodes for multi-signature requirements (OP_CHECKMULTISIG), hash locks, time locks (OP_CHECKLOCKTIMEVERIFY, OP_CHECKSEQUENCEVERIFY), or even simple arithmetic. If the final stack contains a single, non-zero TRUE value, the spend is valid.

Understanding ScriptPubKey is essential for developers building wallets, smart contracts, or analyzing the blockchain. It reveals the intended recipient and spending logic of every transaction output. Advanced protocols like Lightning Network channels and discreet log contracts use custom, non-standard locking scripts to enable off-chain agreements and oracles, demonstrating the flexibility of this fundamental Bitcoin primitive.

The term ScriptPubKey is a compound word derived from Script and Public Key. It originates from Bitcoin's scripting system, Script, a Forth-like, stack-based programming language used to define spending conditions. The "PubKey" portion specifies that a primary condition for unlocking the funds is the provision of a valid digital signature from the corresponding private key. A ScriptPubKey is also commonly called a locking script or output script, as it is the script attached to a transaction output that "locks" the value, dictating who can spend it in the future.

The concept emerged directly from Satoshi Nakamoto's Bitcoin whitepaper and the initial codebase, where the pay-to-public-key-hash (P2PKH) transaction type became the standard. In this model, the ScriptPubKey contains a cryptographic hash of the recipient's public key (the address) and opcodes that require a signature and public key to validate. This design decouples the public-facing address from the on-chain script, enhancing privacy and security. The evolution to Pay-to-Script-Hash (P2SH) and later Taproot (P2TR) introduced more complex ScriptPubKey structures that commit to scripts rather than exposing their full logic on-chain.

Understanding the ScriptPubKey is fundamental to grasping the Unspent Transaction Output (UTXO) model. Every UTXO is essentially defined by its ScriptPubKey and a value. When a new transaction is created to spend that UTXO, it must provide a ScriptSig (or witness in SegWit) that, when combined and executed with the referenced ScriptPubKey, results in a TRUE evaluation. This two-script validation system—comparing the locking script (ScriptPubKey) with the unlocking script (ScriptSig)—is the mechanism that enforces ownership and authorization on the blockchain without a central authority.

A ScriptPubKey (also known as a locking script) is the piece of Bitcoin Script attached to a transaction output that defines the conditions required to spend the bitcoin it controls. It acts as a cryptographic lockbox, specifying the rules that a future spender must satisfy, typically by providing a valid digital signature from the rightful owner. This mechanism is the foundation of Bitcoin's programmable money system, enabling not just simple payments but also complex smart contracts.

The most common ScriptPubKey is the Pay-to-Public-Key-Hash (P2PKH) script, which locks funds to a specific Bitcoin address. Its structure requires a spender to provide two pieces of data in a corresponding ScriptSig (unlocking script): a valid digital signature and the original public key. The script validates these by hashing the provided public key and checking it matches the hash in the lock, then verifying the signature. Other standard types include Pay-to-Script-Hash (P2SH) and Pay-to-Witness-Public-Key-Hash (P2WPKH), each with different operational logic and efficiency characteristics.

When a new transaction attempts to spend an output, the Bitcoin node's script interpreter executes a process called script validation. It concatenates the unlocking script (ScriptSig) from the new input with the locking script (ScriptPubKey) from the referenced output and runs the combined script. The spend is only valid if the final execution leaves a single TRUE value on the stack. This deterministic evaluation ensures that only the party who can satisfy the cryptographic conditions can move the funds, enforcing the security model of the UTXO (Unspent Transaction Output) system.

Beyond simple payments, ScriptPubKeys enable advanced functionalities. They can require multi-signature schemes (multisig), where M-of-N signatures are needed. They can also create timelocks using OP_CHECKLOCKTIMEVERIFY or OP_CHECKSEQUENCEVERIFY, making funds unspendable until a certain block height or time has passed. These building blocks allow for escrow, payment channels, and other complex conditional logic, showcasing the flexibility of Bitcoin's scripting language within its intentionally limited design scope.

Understanding ScriptPubKeys is essential for developers building wallets, analyzing blockchain data, or implementing advanced Bitcoin protocols. Each output's script defines not just ownership but also the path to spending, creating a transparent and auditable chain of custody. As the ecosystem evolves with Taproot and Schnorr signatures, the structure and capabilities of locking scripts continue to advance, enabling more private and efficient transaction types while maintaining backward compatibility with this core locking mechanism.

A ScriptPubKey (also known as a locking script) is the segment of a Bitcoin transaction output that specifies the conditions required to spend the funds it holds. It is a small program written in Bitcoin's stack-based scripting language that acts as a cryptographic lock, and it is the counterpart to the ScriptSig (unlocking script) presented in a future spending transaction. The network validates a spend by executing the ScriptSig and ScriptPubKey together; if the final result is TRUE, the transaction is valid. Common types include the Pay-to-Public-Key-Hash (P2PKH) script, which locks funds to a specific Bitcoin address, and the Pay-to-Script-Hash (P2SH) script, which defers complex logic to a separate redeem script.

To visualize its structure, consider a standard P2PKH ScriptPubKey: OP_DUP OP_HASH160 <Public Key Hash> OP_EQUALVERIFY OP_CHECKSIG. This script encodes a precise verification sequence: it duplicates the public key from the unlocking script, hashes it, compares it to the embedded public key hash, and finally verifies the cryptographic signature. The <Public Key Hash> is the 20-byte RIPEMD-160 hash of the recipient's public key, which is also the core data encoded in a legacy Bitcoin address. This design ensures that only the holder of the corresponding private key can produce a valid ScriptSig to satisfy these conditions.

Beyond simple payments, ScriptPubKeys enable advanced functionalities. A Pay-to-Script-Hash (P2SH) ScriptPubKey, like OP_HASH160 <Redeem Script Hash> OP_EQUAL, locks funds to the hash of a more complex redeem script, enabling multi-signature schemes, timelocks, and other smart contracts. The actual spending conditions are only revealed when the funds are spent. Similarly, Pay-to-Witness-Public-Key-Hash (P2WPKH) and Pay-to-Witness-Script-Hash (P2WSH) are SegWit-native versions that separate the witness data (signatures) from the transaction data, improving scalability and enabling more complex script upgrades like those used in the Lightning Network.