Privacy & Analysis
Transaction batching: cheaper fees, more disclosure
Protocol referenceSource: Bitcoin Developer Guide, TransactionsNo market data is used on this page; the size and fee behaviour described follows the protocol documentation.
What a batch is
A transaction has a fixed part and a variable part. The fixed part — the version, the locktime, the input and output counts — is paid for once regardless of how much the transaction does. The variable part grows with each input and each output. Paying three recipients in three separate transactions pays the fixed cost three times; paying them in one transaction pays it once and adds two extra outputs. Since an output is small compared with the overhead of a whole transaction, the batch is cheaper per payment.
The saving is largest when the payments share inputs. A service that pays many customers from one pool of coins can spend a single set of inputs and create one output per customer, so it avoids duplicating both the input signatures and the transaction overhead. This is why batching is standard practice for exchanges and payment processors: it is a straightforward cost reduction, and it is the reason large transactions with many outputs are common on the chain.
The mechanism is entirely ordinary. There is no batching flag and no special transaction type; a batch is simply a transaction with more outputs than usual. That is also why it is hard to identify with certainty. A transaction with twenty outputs might be a batch, or a consolidation, or a CoinJoin, or a single payment to a service that splits funds internally. The form does not say which.
What the batch reveals
The recipients of a batch are now connected to each other. They share a transaction, and an observer can see that they were paid at the same moment from the same inputs. For a business paying unrelated suppliers, that connection is usually harmless and often already public. For a business paying staff, it publishes the payroll: the number of employees, the timing, and — if the amounts are not equal — the relative pay of each. For an individual paying several people, it publishes that those people are connected to the same payer.
The inputs are the more sensitive side. A batch spends a set of outputs together, so the common-input heuristic merges them into one cluster, which is correct here because they really do share an owner. The problem is that the cluster is now also connected to every recipient in the batch. If any one of those recipients is later identified, the identification reaches back through the transaction to the payer's entire input set. A batch is therefore a single point of disclosure for everything it touches.
There is a subtler effect on the recipients' side. If a recipient receives a payment in a batch and later spends it, the spend is linked to the batch, and the batch is linked to every other recipient. Two recipients who have no relationship with each other can end up in the same cluster through their common payer. This is the same transitive merging that makes any shared input dangerous, and it applies even when the recipients did nothing wrong.
When batching helps and when it does not
Batching helps when the recipients are already publicly associated with the payer. A company paying its own operating expenses, an exchange processing withdrawals, a mining pool distributing rewards — in each case the relationship is known or discoverable, and the batch saves fees without disclosing anything new. The recipients' privacy is not improved by splitting the payments, because the payer's identity is not in question.
Batching hurts when the recipients are not otherwise connected. A person paying two friends, a business paying contractors who do not know each other, a donation processor distributing to several causes — here the batch creates a link that did not exist. The fee saving is real but small, and the disclosure is permanent. The correct comparison is not "batch versus no batch" but "batch versus separate transactions", and the separate transactions cost more precisely because they disclose less.
There is a middle path that some wallets take: batch only payments that are already linked, and keep unrelated payments in their own transactions. That requires the wallet to know which recipients belong together, which in turn requires labelling. The coin control page covers the labelling discipline that makes this possible, and the consolidation page covers the case where the inputs, rather than the outputs, are the thing being combined.
Sources
- Bitcoin Developer Guide, Transactions — how inputs and outputs are counted and how transaction size is composed.
- Bitcoin Developer Guide, Transaction fees and change — why the fee scales with the number of inputs and outputs rather than the amount transferred.
- Kristov Atlas, BIP 69: Lexicographical Indexing of Transaction Inputs and Outputs — the ordering standard that keeps a batch from fingerprinting the wallet that built it.
Related reading
- Privacy & AnalysisWhat the public ledger reveals, and the practices that change it.
- Anonymous vs PseudonymousWhy Bitcoin is pseudonymous, and what an address actually identifies.
- How Transactions Are TracedThe heuristics chain analysis applies, and where they break down.
- Address ReuseWhy reusing an address links every payment to it, and what wallets do instead.
- Coin ControlHow choosing which outputs to spend changes what an observer can infer.
- Change AddressesWhy a transaction sends value back to the sender, and how change is identified.