BIP85 child seed phrases: how to preserve the path and recovery settings
Learn how BIP85 derives child mnemonics, which path, language, length and index to retain, and what a compromised parent seed exposes.

BIP85 lets one BIP32 root deterministically derive entropy that another application can turn into distinct BIP39 mnemonics. It can simplify recovery of several wallets, but it does not make a compromised root safe or make every wallet compatible automatically. To regenerate the same child mnemonic, you must preserve the parent root, any BIP39 passphrase, compatible implementation and every BIP85 application parameter.
What BIP85 solves
One backup does not always fit every wallet. Different applications may use a BIP39 mnemonic, an application-specific format, an extended key or different initialization rules. BIP85 proposes deriving deterministic entropy from a BIP32 root and feeding that entropy into the format required by each application. It is not a wallet, a network or a way to import any seed into any product.
The BIP85 specification is currently marked Deployed and Informational, version 2.1.0. That status describes a deployed specification; it does not mean that every wallet implements it or that a particular application accepts its results. Before relying on it, check the documentation and software version you will use to create and recover the child wallet.
How a child wallet is derived
BIP85 starts with one BIP32 private root key. For each application, it derives a child private key using a fully hardened path and transforms that key with HMAC-SHA512. The result is entropy; it is then truncated to the amount required by the application. The specification's general path is schematically m/83696968'/{application}'/{index}'.
For the BIP39 application, the path adds language and length: m/83696968'/39'/{language}'/{words}'/{index}'. A safe documentation example would be m/83696968'/39'/0'/12'/0': it describes English, twelve words and the first index, but contains no seed and cannot recover funds on its own. Do not publish paths alongside secret material without considering what your inventory reveals.
The apostrophe on each component denotes hardened derivation. In BIP32, hardened derivation requires private parent material; the BIP32 specification distinguishes this branch from public non-hardened derivation. BIP85 also applies an HMAC transformation so the entropy result is not treated as a key reused for another purpose.
Which parameters to keep
There are two recovery routes. If you retain the child mnemonic, you can restore it in a compatible BIP39 wallet without BIP85 support; its passphrase and wallet settings still apply where required. Regenerating it from the parent also needs the BIP85 configuration. Keep a private inventory that distinguishes these routes:
- The BIP32 root or the primary mnemonic that reconstructs it, together with its exact BIP39 passphrase if one exists. An omitted or changed passphrase, including a different space, produces another root.
- The BIP85 application. For a BIP39 mnemonic it is
39'; do not confuse that number with an account, network or later receiving path. - The BIP85 language code. The specification assigns, among others, English to
0'and Spanish to3'; do not assume that the wallet interface language changes this value. - The length: the BIP85 table covers 12, 15, 18, 21 and 24 words, with 128, 160, 192, 224 and 256 bits of material respectively before the BIP39 checksum. Check which options your implementation supports.
- The exact index. Changing
0'to1'selects another valid child mnemonic; it is not a way to repair a missing word. - The child wallet's BIP39 passphrase, if you used one. It is not part of the BIP85 path and must be kept separately, along with the network, account, address type and path that the wallet applies afterward.
The BIP39 length guide distinguishes the size of encoded material from the security provided by its source. BIP85 can produce a deterministic 24-word output, but that length adds no independent randomness to a weak or exposed root.
The impact of a compromise
The root is the main security boundary. If someone obtains the BIP32 private root or primary mnemonic and its passphrase, they can repeat the BIP85 paths and calculate the child mnemonics you used. The descendant mnemonics are then exposed; assess migration using each wallet's procedure. An independent child passphrase is not automatically derived from the root, but its protection also needs review. Changing the index does not revoke a child already used.
The reverse direction should not be assumed. BIP85 uses hardened paths and transforms the derived key before producing entropy; its design aims to prevent an exposed child from reconstructing the root. With a correct implementation and a root resistant to attacks, exposure of one child should not let someone calculate its siblings through this process. It does put wallets depending on that child at risk; also assess their passphrases, implementation bugs and duplicated backups.
A root backup needs stricter custody than an isolated child backup: anyone who obtains it may derive the entire BIP85 inventory. Document the relationship so you can locate it, but keep secrets offline and separate from public instructions. Never paste a mnemonic, passphrase or private key into a website, chat, QR reader or checking service.
Compatibility is not universal
Two products accepting BIP39 does not prove that they share BIP85. To regenerate the same mnemonic from the parent, the BIP85 rules, application, language, word count and index must match; the original brand is not required if another compatible implementation exists. After that, the child wallet may still require its own network, account, derivation path, script type, passphrase and recovery policy. An import that opens an empty wallet does not prove that the result is wrong or that funds have disappeared.
Record which product created each child and its official recovery procedure. Rehearse the flow with a practice wallet holding no funds. That teaches the steps but does not verify your real backup. Never enter real words into online services. Before moving funds, compare a complete known public address under the same network, account, format, path and index. The explanation of why one seed can show different addresses covers settings that BIP85 does not choose.
How this relates to SeedAddress
SeedAddress derives a deterministic BIP39 mnemonic in the browser from selected coordinates, an input password, word-list language and word count. Locations are public and the process adds no independent random entropy; therefore 24 words do not guarantee 256 random bits of security, and the inherited five-character minimum is compatibility, not password advice.
SeedAddress does not implement BIP85 or turn those inputs into a BIP32 master root for multiple wallets. Do not assume its password is the BIP39 passphrase for a later wallet. If you plan to protect funds with a new wallet, read the guide to migrating from a deterministic derivation, use random entropy generated by a trusted tool and keep an independent backup. The SeedAddress recovery guide explains the exact inputs required by its own method.
Checklist before relying on BIP85
- Confirm that the specific wallet implements BIP85 BIP39 and record its version.
- Keep the parent root and any separate passphrase offline; do not put secrets in an inventory you share.
- Record the application, language, length, index and later wallet configuration for each child.
- Regenerate a child with synthetic data and verify the procedure in the official environment.
- Check the real backup separately using the wallet's official, controlled procedure; a known address helps identify the wallet but does not validate the entire backup.
- If the parent root is exposed, treat every derived child as affected and plan a migration; choosing another index is not enough.