How a wallet finds your coins

Here is a scenario that plays out constantly, and almost never means what the person experiencing it thinks it means. You restore your seed words into a different wallet than the one you set up with. The words are accepted without complaint. The wallet opens. The balance is zero.

The overwhelmingly likely explanation is not that your bitcoin is gone. It is that the wallet is looking in the wrong place — and understanding why requires knowing what your seed words actually produce, which is not a wallet but a tree.

1One seed, an unlimited tree of keys

Your twelve or twenty-four words encode a single large number. From that number, a defined procedure produces a master key, and from the master key an endless branching structure of child keys — a hierarchical deterministic wallet, universally shortened to HD.

Deterministic is the important half. Nothing is random after the seed. Anyone starting from the same words and walking the same route through the tree arrives at exactly the same keys, every time, on any software. That is what makes a backup of twelve words sufficient to restore a wallet holding thousands of addresses.

Branching is the half that causes the trouble. The tree is enormous, and your coins are on one specific branch of it. Restoring the seed gives a wallet the whole tree. It still has to be told, or has to guess, where to look.

2Reading a derivation path

The route through the tree is written as a derivation path. You will have seen one, probably without being told what it meant:

m/84'/0'/0'/0/0

Read left to right, each segment is a turn:

• m — the master key derived from your seed. The root.
• 84' — the purpose, which in practice means the address type. 44′ is legacy, 49′ is wrapped SegWit, 84′ is native SegWit, 86′ is Taproot.
• 0' — the coin. Zero is bitcoin.
• 0' — the account number, so one seed can hold several separately-tracked wallets.
• 0 — the branch: 0 for addresses you hand out, 1 for change coming back to you.
• 0 — the index, counting up as you generate address after address.

Change any one of those numbers and you land somewhere else entirely — a valid, empty wallet with no relationship to the one you were looking for. This is the same silent-failure shape as a mistyped passphrase: nothing errors, because nothing is wrong. You simply asked a different question and got its correct answer.

A bare winter tree photographed from directly beneath the trunk, branches splitting overhead into hundreds of forks against a flat pale sky.

Image to come

3The gap limit

Even on the correct branch, a wallet does not check infinitely many addresses. It works forward from index zero, and it stops after a run of consecutive empty ones — conventionally twenty. That run is the gap limit.

It exists for a sensible reason: each address has to be checked against the chain, and scanning forever would make restoring impossibly slow. But it creates a specific and genuinely alarming failure.

Suppose you generated thirty fresh receiving addresses while experimenting, used none of them, and then received a payment on the thirty-first. On restore, the wallet checks addresses 1 through 20, finds nothing, concludes the wallet ends there, and reports a zero balance. Your coins are ten addresses past the point where it stopped looking.

• Most wallets let you raise the gap limit manually. Setting it to a few hundred and rescanning costs some time and finds the coins.
• Avoid generating large numbers of addresses you never use — this is the main way people end up beyond the default.
• If a restore comes back empty, raising the gap limit is the second thing to try, after checking the derivation path.

4The xpub, and what it gives away

At the account level of the tree sits an extended public key — an xpub. From it, anyone can derive every address in that account, past and future, but no private keys and therefore no ability to spend.

This is what makes watch-only wallets possible: your phone or laptop can track balances and build unsigned transactions while the keys stay on a device in a drawer. It is genuinely useful, and it carries a privacy cost worth stating plainly.

• An xpub reveals every address in the account, so anyone holding it can see your complete balance and transaction history, forever, without you being able to revoke it.
• Handing an xpub to a service, a block explorer, or a friend's node hands over exactly that. It cannot take your bitcoin; it can watch all of it.
• This is one of the strongest arguments for pointing your wallet at your own node rather than someone else's server.

5Descriptors: writing it down properly

Derivation paths on their own are an incomplete description, which is why the modern replacement bundles everything into one string. An output descriptor states the script type, the key, and the path together:

wpkh([d34db33f/84'/0'/0']xpub6C.../0/*)

That says: native SegWit, this key, this path, this branch, all indexes. There is nothing left for the receiving wallet to assume. Descriptors also handle multisig and more complex conditions, which plain paths cannot describe at all.

The practical advice follows directly: when your wallet offers to export a descriptor, save it with your backup. It is not secret in the way your seed is — it contains public keys only — but it is the difference between a restore that works immediately and one that starts with guesswork.

6What to do when a restore comes back empty

Work through it in this order, and do not do anything drastic before finishing the list.

• Stop. Do not re-enter the seed anywhere unusual, and do not type it into a website offering to help. A quiet empty wallet is not an emergency; a leaked seed is.
• Check the address type. Try the other purpose values — 44′, 49′, 84′, 86′. Good software offers this as a dropdown during import.
• Check the account number. Some wallets create account 1 in situations where others use account 0.
• Raise the gap limit to several hundred and rescan.
• Ask whether a passphrase was ever set. A forgotten passphrase produces this exact symptom, and produces it permanently.
• Check a known address instead of the balance. If you have an address you know received coins, searching a block explorer for it tells you whether the money is still there — which is a separate question from whether this wallet can see it.

Almost every case resolves at step two or four. The point of testing your recovery before you need it is that you discover which of these applies to you on a calm afternoon rather than during a crisis.

The short version

Seed words are the root of a deterministic tree, not a wallet. Finding your coins takes the words plus the route: address type, account, and enough patience to scan past the gap. Record the derivation path or, better, the descriptor alongside your backup, and a future restore becomes a two-minute job instead of an afternoon of dread.