Coin Control in Sparrow Wallet: Label and Freeze UTXOs So You Never Merge KYC and No-KYC Coins (2026)

Short answer: Coin control in Sparrow lives in the UTXOs tab. Open your wallet, click UTXOs, and you see every individual coin you own as a separate row. To stop the single most common self-inflicted privacy leak — merging a KYC-exchange coin and a no-KYC coin in the same transaction — do three things: (1) label every UTXO by its source the moment it arrives, (2) freeze coins you must never spend by accident (dust, tainted, or wrong-bucket coins) by right-clicking the coin and choosing Freeze UTXO (the menu reads Freeze UTXOs when several are selected), and (3) when you send, pre-select your inputs in the UTXOs tab — tick coins from a single source bucket and click Send Selected — then read the transaction before signing to confirm the actual inputs are all from that one bucket. That is the entire discipline. Everything below is the exact procedure and a decision framework for the one hard question: when consolidating coins is fine versus when it is a privacy own-goal.

This page assumes you already know what a UTXO is and why on-chain privacy matters. If you do not, start with the UTXO privacy management primer and come back. Here we are doing, not defining.

Why coin control is now your main privacy tool (the post-CoinJoin 2026 reality)

For most of the last decade, the privacy advice was "run your coins through a CoinJoin." That advice is largely dead. After the April 2024 arrests of the Samourai Wallet developers and the subsequent shutdown of the Wasabi coordinator, the two dominant collaborative-mixing services for ordinary users went dark. The remaining options are fewer, more technical, and carry their own caveats — we cover what is left in CoinJoin methods compared and the deeper UTXO segregation analysis.

What did not go away is the thing CoinJoin was always sitting on top of: disciplined coin control. Mixing never removed the need to keep coins separated by source and to choose inputs deliberately — it just papered over sloppy habits. With easy mixing gone, that paper is gone too. In 2026, for a self-custody user running a normal wallet, manual UTXO labeling, freezing, and coin selection is the default, everyday privacy practice — not an advanced afterthought. Sparrow is the wallet most of this audience already runs, and its UTXOs tab gives unusually granular coin control — per-UTXO labeling, freezing, and manual input selection in one view. So this is where the work happens now.

The one mistake this prevents: merging KYC and no-KYC UTXOs in a single transaction

Chain-analysis firms lean heavily on one heuristic: the common-input-ownership heuristic. When a transaction spends multiple inputs, the safe assumption is that all of those inputs are controlled by the same entity. That assumption is usually correct, and it is the backbone of clustering. See how surveillance firms operationalize it in our taint analysis and surveillance guide.

Here is the failure in concrete terms. Suppose you have:

• A coin you bought on a KYC exchange. The exchange knows your name, address, and that this coin is yours.
• A coin you acquired privately — earned, gifted, or bought peer-to-peer with no identity attached.

As long as those two coins never appear as inputs in the same transaction, the on-chain link between your real identity and your private coin does not exist. The moment your wallet automatically selects both as inputs to pay for one purchase, you have published — permanently, on a public ledger — that the same entity controls the KYC coin and the no-KYC coin. The private coin is now deanonymized to anyone who can subpoena or already holds the exchange's records. There is no undo. This is the leak coin control exists to prevent, and a wallet on automatic input selection will do it to you without warning.

Turn on the UTXO view in Sparrow (where coin control actually lives)

Open Sparrow and select your wallet in the left sidebar. The wallet has several tabs down the left side of the wallet pane — Transactions, Send, Receive, Addresses, UTXOs, Settings. Click UTXOs. (UI labels here match recent Sparrow releases; confirm the exact wording in your version.)

This tab is the entire point. Instead of a single account balance, you see a table with one row per unspent coin. Each row shows when the coin arrived, its editable label, the receiving address, the amount, and the coin's output (the txid:vout outpoint):

• Date — when the coin was received.
• Label — editable; this is where your discipline lives.
• Address — the receiving address that holds the coin.
• Amount (BTC/sats) — the value of that individual UTXO.
• Output — the coin's outpoint (txid:vout); right-clicking here is the documented way to freeze the coin. (Exact columns can vary by Sparrow version.)

Two habits make this view trustworthy:

1. Use a fresh receive address every time. Sparrow shows the next unused address on the Receive tab by default — always use the one presented and never paste an old address back into someone else, since reusing an address merges unrelated payments into one cluster before coin control can help.
2. Know where your change goes. When a spend leaves a remainder above the dust threshold, Sparrow sends change to a new internal change address in the same wallet/account. A full-value spend (sweep), or one whose remainder is below dust and absorbed into the fee, produces no change output. Change inherits the privacy posture of the inputs that produced it — that is why bucket-pure spending matters (next section).

A labeling convention that scales: tagging every UTXO by source

A label you write three months from now is too late — by then you have forgotten where the coin came from. Label at the moment of receipt, on the Transactions or UTXOs tab, by double-clicking the Label cell. The schema below is deliberately boring and machine-greppable. Boring scales; clever does not.

Rules that keep the system honest:

• One bucket per label. A coin is never both KYC and NOKYC. If you genuinely cannot remember a coin's source, do not fold it into either bucket: give it its own UNKNOWN: quarantine label and freeze it. Never consolidate an unknown-origin coin into your KYC bucket — that would voluntarily link a possibly-private coin to your identity, which is the exact leak this guide prevents. Treat unknown origin as untouchable until you can establish its source, not as KYC to be merged.
• Change inherits the input bucket. Spend only NOKYC inputs and the change is NOKYC. Spend only KYC inputs and the change is KYC. Never spend across buckets, because that is exactly the merge you are avoiding — and the resulting change would belong to no clean bucket at all.
• Back up your labels. Labels live in your Sparrow wallet file, not on-chain. Back them up via File → Export Wallet → Wallet Labels (BIP-329 .jsonl format; restore with File → Import Wallet → Wallet Labels), and store that export as carefully as the rest of your backup material — it is privacy-sensitive, so encrypt it at rest. Labels are the map; lose them and you are back to guessing.

Freezing UTXOs: how to lock a dusted or tainted coin so it can never be spent by accident

Freezing is the safety net under your labels. A frozen UTXO is excluded from automatic coin selection and cannot be added to a transaction at all — not by automatic selection and not by hand — until you deliberately unfreeze it. It does not move, hide, or alter the coin — it just makes the wallet refuse to spend it until you explicitly release it.

To freeze a coin: go to the UTXOs tab, select one or more rows (Ctrl/Cmd-click for multiple), right-click the coin's Output, and choose Freeze UTXO (the menu reads Freeze UTXOs when several rows or a whole address are selected). Frozen coins are shown in gray in the list. The gray is subtle, so do not rely on color alone — the real protection is the hard block: a frozen coin cannot be added to a transaction until you unfreeze it. To reverse it, right-click and choose Unfreeze UTXO.

Sparrow also helps here: it attempts to detect likely dust UTXOs and will suggest freezing them, so watch for that prompt and accept it. Still, treat any unexpected tiny inbound payment as dust regardless. Freeze on sight in three cases:

1. Dust you did not request. A tiny unexpected payment to one of your addresses is the classic dust attack: an adversary sprays trivial amounts hoping your wallet later spends that dust together with a real coin, linking the two. The most damaging variant, sometimes called forced address reuse, sends dust to an address you have already used to bait you into respending it — another reason to never reuse addresses. Freezing the dust removes the bait. Do not spend it; do not consolidate it.
2. Wrong-bucket coins during a send. When paying from NOKYC funds, freezing your KYC coins for the duration of the send is belt-and-suspenders insurance against a mis-click adding them.
3. Coins under a cloud. Anything with origin you are unsure about, or that you are deliberately quarantining, stays frozen until you decide what to do with it.

Sending with manual coin selection: choosing inputs, controlling change, and verifying before broadcast

This is the live-fire step. Done right, your transaction spends from exactly one bucket and produces clean change. The key is that input selection happens in the UTXOs tab before the Send screen opens — Sparrow has no "manual mode" toggle on the Send tab, so if you start a send without pre-selecting, the wallet picks inputs for you automatically.

1. Select inputs in the UTXOs tab. Go to the UTXOs tab and tick only coins sharing the same source prefix (all NOKYC:, or all KYC: — never a mix; Ctrl/Cmd-click for several). Pick enough to cover the amount plus fee. Frozen UTXOs are excluded from Sparrow's automatic selection and shown in gray, and cannot be added to a transaction until unfrozen — that hard block is the safety net working.
2. Click Send Selected. This pre-loads the Send screen with those coins. Sparrow may still use only a subset of them — its Branch-and-Bound / Knapsack selector can drop inputs it does not need to cover the amount plus fee — so do not treat the selection itself as a guarantee of which coins get spent. As long as every coin you ticked is from the same bucket, any subset Sparrow uses (and the change it creates) stays in that bucket.
3. Enter recipient and amount on the Send screen now that the source-pure input set is locked in.
4. Check the change. If your inputs exceed amount-plus-fee, Sparrow creates a change output back to a new internal address. That change now carries the bucket of your inputs — label it CHANGE: from NOKYC spend <date> after the transaction confirms.
5. Verify before broadcast — this is the load-bearing step. Sparrow does not promise to spend every coin you ticked, so the transaction diagram (inputs on the left) is your source of truth, not the rows you selected. Confirm the actual inputs shown are all one bucket, and that the recipient, amount, and fee are correct. If you sign with a hardware wallet, confirm the same details on the device screen — see the verification discipline in our Sparrow multisig tutorial. Broadcast is irreversible; there is no recall. Only then broadcast.

Done this way, no two buckets were merged as inputs. Note this does not make the spend invisible: the change output is still probabilistically linkable to your cluster via change-detection heuristics (script-type match, round-number amounts, fresh-address use), and the recipient — and any chain observer — learns that this cluster paid this destination. Coin control prevents accidental input-merging; it does not anonymize the spend.

When consolidating UTXOs is fine vs. a privacy own-goal (decision framework)

Consolidation — combining many small UTXOs into one larger UTXO — is sometimes smart (fewer, cheaper inputs to spend later; useful before a fee spike) and sometimes a deanonymization event. The deciding question is never "is consolidation good or bad," it is "do all the coins I am about to combine already belong to the same identity cluster?"

Rule of thumb: consolidate within a bucket, never across buckets, never with unknown-origin coins, and never sweep dust. Time intra-bucket consolidation for a low-fee window, and label the resulting UTXO with the same bucket prefix.

Common coin-control failure modes and how to recover

• You started a send from the Send tab without pre-selecting, and Sparrow auto-picked across buckets. The link is published and permanent — you cannot un-broadcast. Going forward, treat the involved NOKYC coins as KYC-tainted (relabel them) and tighten your process. Make pre-selecting your inputs in the UTXOs tab (Send Selected) — and reading the transaction diagram before signing — your default habit for every spend, so Sparrow never auto-picks across buckets unnoticed.
• You spent a frozen-worthy dust coin alongside a real coin. Same outcome: the dust is now linked. Relabel the change accordingly and quarantine it. Freeze unexpected dust the day it arrives so this cannot recur.
• You lost your labels. Without labels, the UTXO view is just amounts and dates. Rebuild from your transaction history and exchange records, and from now on export your BIP-329 labels alongside every wallet backup.
• Change confusion. You forgot that change inherits the input bucket and later spent it cross-bucket. Always label change immediately with its source bucket so a future you cannot misclassify it.

Where coin control stops and other tools begin

Coin control is necessary but not sufficient. It keeps already-separated coins separate and stops accidental linking — it does not break an existing link, and it does not hide amounts or counterparties from a determined observer of the chain. Know its edges:

• Acquiring privately from the start beats any post-hoc cleanup. A coin that never touched KYC needs no untangling. P2P acquisition is the highest-leverage privacy move available in 2026.
• PayJoin (BIP-78) breaks the common-input-ownership heuristic for a single payment by having the receiver contribute an input, so the transaction no longer cleanly maps to one owner. Whether you can use it depends on your counterparty exposing a compatible BIP-78 endpoint; treat it as a complement to, not a replacement for, coin control.
• Silent Payments (BIP-352) let you publish one static address that never reuses an on-chain address, killing receiver-side address-reuse leakage at the source — upstream of anything you do in the UTXOs tab. Sparrow supports both sides: sending to Silent Payment addresses arrived earlier (around v2.3.0), and native Silent Payments receiving wallets were added in v2.5.0. Receiving relies on a Silent-Payments-capable Electrum/scanning backend (Frigate); Sparrow can use the public frigate.2140.dev server, which it selects automatically, or you can point it at your own for full sovereignty. Use a current Sparrow version and confirm the exact behavior in your build.

The stack, in order of leverage: acquire private coins; never reuse addresses; label and freeze everything by source; select inputs manually within one bucket and verify the real inputs before signing; reach for PayJoin or Silent Payments where they fit. Coin control is the discipline that holds the rest together.

Frequently Asked Questions

{“@context”: “https://schema.org”, “@type”: “FAQPage”, “mainEntity”: [{“@type”: “Question”, “name”: “Where is coin control in Sparrow Wallet?”, “acceptedAnswer”: {“@type”: “Answer”, “text”: “In the UTXOs tab. Open your wallet and click the UTXOs tab down the left side of the wallet pane — it lists every unspent coin as its own row with date, label, address, amount, and output. From there you label coins (double-click the Label cell), freeze or unfreeze them (right-click the coin’s Output), and select the exact coins that will fund a transaction: tick them and click Send Selected, which pre-loads the Send screen with those inputs. Before signing, read the transaction diagram to confirm which coins are actually being spent.”}}, {“@type”: “Question”, “name”: “How do I freeze a UTXO in Sparrow so it can’t be spent by accident?”, “acceptedAnswer”: {“@type”: “Answer”, “text”: “Go to the UTXOs tab, select one or more coins (Ctrl or Cmd-click for several), right-click the coin’s Output, and choose Freeze UTXO (the menu reads Freeze UTXOs when several rows or a whole address are selected). A frozen coin is excluded from automatic coin selection and cannot be added to a transaction at all until you right-click and choose Unfreeze. Frozen coins are shown in gray, but that cue is subtle — the real protection is the hard block, not the color. Freezing does not move or alter the coin. Freeze unexpected dust and wrong-bucket coins on sight.”}}, {“@type”: “Question”, “name”: “How do I avoid merging KYC and no-KYC coins in one transaction?”, “acceptedAnswer”: {“@type”: “Answer”, “text”: “Label every coin by source the moment it arrives (KYC versus NOKYC), and when you send, select your inputs in the UTXOs tab — tick coins from only one bucket and click Send Selected — then read the transaction diagram before signing to confirm the actual inputs are all from that one bucket. Because spending multiple inputs together publicly signals common ownership, mixing a KYC coin and a no-KYC coin in one transaction permanently links your identity to the private coin. Freezing your KYC coins while paying from no-KYC funds adds a hard safety net against a mis-click.”}}, {“@type”: “Question”, “name”: “Is consolidating UTXOs bad for privacy?”, “acceptedAnswer”: {“@type”: “Answer”, “text”: “Only when you consolidate across identity clusters. Combining coins that already belong to the same source — for example several KYC withdrawals already tied to you — is fine and saves future fees. Combining no-KYC coins from different unrelated private sources, or combining any KYC coin with any no-KYC coin, voluntarily links things that had no on-chain connection and shrinks your anonymity set. Never fold an unknown-origin coin into another bucket, and never sweep up dust into your real coins. Rule: consolidate within a bucket, never across buckets, and time it for a low-fee window.”}}]}