A Bitcoin output can offer several ways to spend it without publishing every condition up front. Taproot's two spending routes reveal different parts of that arrangement.
For readers inspecting a transaction or a privacy claim, Taproot key-path versus script-path spending is a question about evidence. A key-path signature does not reveal an alternative script tree. A script-path spend reveals a selected script and evidence connecting it to the output. Neither observation makes a transaction anonymous.
This explainer follows the current BIP341 and BIP342 specifications. The diagrams and byte counts below are conceptual examples, not a signing guide or a decoded live transaction.
One output key, two possible spending routes
BIP341 defines Taproot's version-1 native SegWit output with a 32-byte witness program. That program encodes the Taproot output key. The commitment construction can combine an internal public key with a root committing to script leaves.
Keep the output key and internal key separate. The output carries the former. The script-path proof reveals the latter as part of checking the commitment. They are related by the Taproot construction, not interchangeable labels for a wallet address.
The output can be spent through the key path with a valid signature for its output key, or through a permitted script path with the necessary evidence and applicable validation. This does not mean every wallet exposes both routes, or that every output has a usable alternative script.
Taproot is deployed on Bitcoin mainnet; BIP341 records activation at block 709632. That is historical deployment information, not a new announcement or proof of a named wallet's feature support.
Read the witness after accounting for the annex
The witness holds the input's spending data. BIP341 first handles an optional annex: when there are at least two witness elements and the last begins with 0x50, that element is treated as the annex and removed for the following route classification. It remains covered by the signature and contributes to weight.
After that step, the distinction is:
| Remaining witness elements | Route | What the verifier reads |
|---|---|---|
| Exactly one | Key path | A signature for the Taproot output key |
| At least two | Script path | The last two elements are the selected script and control block; earlier elements supply its initial stack |
An empty witness fails the specified validation. Merely counting elements without first identifying the annex can misclassify the route. This is an explanation of the parsing rule, not a recommendation to construct an annex or a witness.
The basic key-path signature is 64 bytes. A 65-byte form appends an explicit permitted, nonzero sighash type; the 64-byte form implies the default mode. Those are signature-element sizes, not complete transaction sizes or universal fee estimates.
A key-path spend leaves the alternative scripts undisclosed
The key-path verifier checks the signature against the output key under BIP341's signature-message rules. It does not need the internal public key, script leaves or their Merkle branches to be supplied in that spend.
An observer therefore cannot read an unused script policy directly from a key-path witness. Nor can that witness alone establish whether a usable script alternative existed. The construction permits outputs that do not offer a usable script spending route.
A single signature also does not reliably count the people involved. BIP341 discusses aggregate and threshold arrangements that can produce a single-key-looking result. A signature element is evidence for the specified verification question, not a participant list or proof that one person acted alone.
A script-path spend reveals one whole selected leaf
A script-path spend supplies the selected script, a control block, and any initial stack elements needed by that script. BIP341 checks the script's commitment against the output before applying the relevant script rules.
The control block includes a byte carrying leaf-version and output-key parity information, the 32-byte internal public key, and the sibling hashes needed along the selected Merkle path. It is not the entire script tree.
There are two distinct checks to understand:
- Commitment: does this leaf, together with its proof and internal key, reconstruct the commitment to the output key?
- Spending validity: does the input satisfy the applicable validation rules for that revealed script and its data?
A matching commitment alone does not establish that every required signature or condition is satisfied. Conversely, a plausible script printed in an explorer is not proof that it was committed to this output.
The entire selected leaf script is disclosed, including any code branches within that script that were not executed. “Only the used condition is revealed” is too loose if it makes readers imagine that unexecuted bytes inside the revealed leaf become invisible. Separate, unrevealed leaves are a different matter.
A small tree makes the proof size visible
Imagine three invented script leaves, A, B and C. First combine A and B into a subtree, then combine that subtree with C. Suppose the script path using B is selected.
The proof for B needs the sibling hash for A and the sibling hash for C. It does not need to disclose the full scripts A and C. B's complete selected script remains visible, along with its initial stack data and control block.
BIP341 defines the control-block length as 33 + 32m bytes, where m is the number of sibling hashes, from 0 through 128 inclusive.
| Sibling hashes m | Control-block arithmetic | Length |
|---|---|---|
| 0 | 33 + 32 × 0 | 33 bytes |
| 1 | 33 + 32 × 1 | 65 bytes |
| 2 | 33 + 32 × 2 | 97 bytes |
Our B path has two siblings, so its control block is 97 bytes. This excludes the selected script, its initial stack elements, witness serialization overhead and any annex. It is not the total witness size.
The 33-byte fixed portion is one control byte + 32 bytes of internal key. Each additional sibling adds 32 bytes. This is a structural count; we have not created real scripts, hashes, keys, signatures or a spendable output.
Taproot sorts sibling hash pairs before combining them, so the proof does not need a separate left/right direction bit at each step. Its tagged leaf, branch and tweak hashes have different roles. Do not substitute the block header's transaction Merkle root: our Bitcoin inclusion-proof explainer owns that separate question.
BIP342 supplies the initial tapscript rules
BIP342 defines the initial script language for leaf version 0xc0, called tapscript. It changes signature checking to use Schnorr rules, disables the older CHECKMULTISIG opcodes and introduces CHECKSIGADD, among other changes.
Script-path spending is therefore more than proving membership in a tree. The leaf version selects the relevant rules. The specifications also contain upgrade mechanisms, including future leaf versions and OP_SUCCESSx behavior. A generic statement that every possible leaf is evaluated as an ordinary current tapscript would miss those distinctions.
No opcode recipe or executable script is supplied here. A protocol specification is also not a wallet-support directory; the availability of a particular policy needs separate, current evidence about the actual software.
Less policy disclosure is not universal anonymity
The privacy advantage is specific: a key-path spend avoids revealing an alternative script policy, while a script-path spend avoids publishing every separate leaf merely to use one.
That still leaves useful clues. A revealed script can show its spending conditions. The control block reveals path depth; BIP341's security section explains how depth and repeated keys or branches can help identify constructions or cluster activity. An unrevealed script is not automatically impossible to infer from outside information or weak construction choices.
The transaction's public context does not disappear. Inputs, outputs, amounts, timing and separately disclosed information can still matter. A key-path label is not an anonymity certificate; a script-path label does not establish why that route was selected or identify every participant.
Transaction identity is another layer. Our txid and wtxid explainer separates witness data from the identifiers that commit to transaction serializations. Neither identifier names a Taproot policy by itself.
Ask what the visible evidence actually proves
When interpreting a Taproot record, establish the spent output and its witness version, account for the annex, then identify the spending route. For a script path, distinguish the revealed leaf, its commitment proof and the applicable validation rules.
Also separate these findings from transaction inclusion and later confirmations. A valid spending condition does not reserve space in a block. Bitcoin locktime covers timing conditions; it does not make the other permitted routes or validation requirements disappear.
Taproot's two routes answer the same broad question—how an output is authorized to be spent—while exposing different evidence. Read that evidence at its actual scope before turning a compact witness into a claim about privacy, signers or software support.
Sources
Complete current BIP341 and BIP342 text checked November 4, 2026, including rationale, security discussion, validation, code examples and deployment sections. Their assigned date is January 19, 2020; mainnet activation at height 709632 is historical. No new launch, live chain height or wallet availability is claimed.
A, B, C and the tree arrangement are fictional. The 33/65/97-byte control-block arithmetic was checked locally. No real hash or key was derived, script assembled, node queried, wallet connected, signature created, transaction broadcast or privacy/security experiment performed. The illustration is fictional, not captured transaction evidence.
See something wrong? Brokzi logs material changes. Prepare a correction note.




