Introduction
A BIP39 mnemonic generator creates the 12 to 24 words that back every Bitcoin, Ethereum, and Solana wallet. The phrase is not a password. It is a human-readable encoding of random entropy, and anyone who reads it can spend the funds. This BIP39 mnemonic generator runs entirely in your browser using the Web Crypto API, so the entropy, phrase, and derived seed never touch a server. Pick a word count (12, 15, 18, 21, or 24), optionally add a passphrase, and the tool produces the mnemonic, the underlying entropy in hex, and the 512-bit seed that feeds into BIP32 hierarchical deterministic wallets. Paste the result into a hardware wallet setup flow or use it for local testing.
What this tool does
- Generates a BIP39 mnemonic phrase of 12, 15, 18, 21, or 24 words using cryptographically secure randomness from crypto.getRandomValues.
- Displays each word as an individual numbered chip for easy transcription and verification against the 2048-word English wordlist.
- Shows the raw entropy in hexadecimal alongside the phrase, so you can verify the randomness source.
- Derives the 512-bit BIP39 seed (128 hex characters) via PBKDF2-HMAC-SHA512 with 2048 iterations, using an optional passphrase as the salt.
- Provides copy buttons for the phrase and seed, and a security warning about offline backup.
- Runs 100% client-side. No phrase, entropy, or seed is transmitted over the network.
How this tool works
The generator starts by requesting the requested number of random bytes from the browser's Web Crypto API (crypto.getRandomValues), which draws from the operating system's CSPRNG. For a 12-word phrase it pulls 16 bytes (128 bits); for 24 words it pulls 32 bytes (256 bits). It then computes SHA-256 of the entropy and appends the first ENT/32 bits of that hash as a checksum. The combined bit string is split into 11-bit chunks, each indexing into the 2048-word English wordlist to produce the mnemonic.
If you provide a passphrase, the tool feeds the mnemonic and the string "mnemonic" + passphrase through PBKDF2-HMAC-SHA512 with 2048 iterations to derive the 64-byte seed. That seed is the root input for BIP32 HD wallet derivation. The word chips, entropy hex, and seed hex are all rendered locally. Nothing is logged or sent anywhere. You can copy the phrase or seed with the copy buttons and paste it into a hardware wallet, a recovery test, or a development script.
How BIP39 mnemonic phrases work
BIP39 was proposed in 2013 as a standard for encoding wallet entropy into a sequence of human-readable words. The full specification lives in the BIP39 document. The core idea is simple: take random entropy, append a checksum, and map the bits to words from a fixed wordlist.
The wordlist contains exactly 2048 words. Each word encodes 11 bits, which is why word counts are multiples of 3 (33 bits per group of 3 words: 32 bits of entropy plus 1 checksum bit). A 12-word phrase carries 128 bits of entropy and 4 bits of checksum. A 24-word phrase carries 256 bits of entropy and 8 bits of checksum. The checksum is the first ENT/32 bits of the SHA-256 hash of the entropy, which lets a wallet detect a single-word typo before attempting recovery.
The mnemonic alone is not the wallet root key. BIP39 specifies a seed derivation step: the mnemonic (normalized with NFKD) is passed through PBKDF2 with HMAC-SHA512, 2048 iterations, and a salt of "mnemonic" concatenated with an optional passphrase. The resulting 512-bit seed is the input to BIP32, which derives the master key and the tree of child keys. BIP44 then defines derivation paths like m/44'/0'/0'/0/0 for Bitcoin and m/44'/60'/0'/0/0 for Ethereum, so the same seed produces addresses across multiple chains.
The passphrase (sometimes called the "13th word") is not stored anywhere. The same mnemonic with a different passphrase yields a completely different seed and a different wallet. This is useful for plausible deniability and multi-wallet setups, but it also means losing the passphrase makes the funds unrecoverable.
How to use this tool
- Select a word count: 12 (128-bit entropy, the minimum), 15, 18, 21, or 24 (256-bit entropy, the maximum).
- Optionally enter a BIP39 passphrase. This adds a salt to the seed derivation and produces a different wallet from the same phrase.
- Click 'Generate Mnemonic'. The tool pulls random bytes from crypto.getRandomValues and maps them to words.
- Read the numbered word chips carefully. Write the phrase on paper and store it offline. Do not photograph or email it.
- Copy the entropy hex or the derived seed hex if you need them for development or testing. The seed feeds into BIP32 HD wallet derivation.
Real-world examples
Setting up a Bitcoin hardware wallet from scratch
A user buys a Trezor or Ledger and wants to load it with a fresh, self-generated seed rather than using the device's own RNG. They generate a 24-word phrase here, write down all 24 words in order on the recovery card, and enter them into the wallet's recovery import flow. The wallet derives the same BIP39 seed (because the passphrase is empty) and produces identical addresses. The advantage is that the entropy was generated on a machine the user controls, not on a device that might have a compromised RNG. The risk is that if the phrase was ever displayed on a screen with malware capturing it, the funds are exposed. Use a clean, offline machine for this workflow.
Testing a BIP32 HD wallet library in Node.js
A developer is integrating the `bip32` and `bip39` npm packages into a wallet backend. They generate a 12-word phrase here, copy the mnemonic string, and paste it into a test script: `const seed = await bip39.mnemonicToSeed(mnemonic); const root = bip32.fromSeed(seed);`. They then derive the first Bitcoin receiving address at path m/44'/0'/0'/0/0 and compare it against what their backend produces. If the addresses match, the derivation logic is correct. If not, the most common bug is a wrong derivation path or a missing apostrophe (hardened vs unhardened derivation).
Creating a decoy wallet with a passphrase
A user wants plausible deniability: one wallet with a small balance under a known passphrase, and a second wallet with the real balance under a secret passphrase. They generate a single 24-word phrase here, then derive two seeds by entering two different passphrases. Each seed produces a completely different set of addresses. They fund both wallets. If coerced into revealing the passphrase, they surrender the decoy passphrase, and the real wallet remains hidden behind the second passphrase. The catch: forgetting the secret passphrase means the real funds are permanently lost, since the passphrase is never stored or recoverable.
Comparison with similar methods
| Method | Complexity | Typical use |
|---|---|---|
| 12-word mnemonic (128-bit entropy) | 16 bytes random + 4-bit checksum | Standard wallets; adequate security for most users |
| 24-word mnemonic (256-bit entropy) | 32 bytes random + 8-bit checksum | Maximum security; cold storage and institutional custody |
| Raw hex entropy (no mnemonic) | Direct 128-256 bit hex string | Development and testing; not human-transcribable |
| BIP39 + passphrase (25th word) | Mnemonic + PBKDF2 salt | Multi-wallet setups and plausible deniability |
Limitations or considerations
This tool generates entropy using the browser's crypto.getRandomValues, which is a CSPRNG backed by the operating system. That is secure for wallet creation on a clean machine, but if the browser or OS is compromised, the entropy can be intercepted. For high-value wallets, generate the phrase on a hardware wallet or an air-gapped machine. The tool does not store the phrase anywhere, but browser extensions, screen capture malware, or a compromised device can still read it from the DOM. Never use a phrase generated on a public or untrusted device for real funds. The passphrase field is transmitted nowhere, but if you type it on a keyboard logger, it is compromised. BIP39 mnemonics are also not encryption: the phrase IS the key. There is no way to recover a lost phrase or passphrase.
Frequently asked questions
Is it safe to use a mnemonic generated in a browser tool?
On a clean, offline machine it is safe. The tool uses crypto.getRandomValues, which is a CSPRNG. The phrase never leaves the browser. The risk is the environment: browser extensions, malware, or screen capture tools can read the phrase from the page. For high-value wallets, use a hardware wallet's built-in generator or an air-gapped machine. Never generate a phrase on a public computer.
What is the difference between 12 and 24 words?
12 words encode 128 bits of entropy. 24 words encode 256 bits. Both are valid BIP39. 128 bits is sufficient to resist brute-force attacks with current hardware. 24 words is preferred for cold storage and large balances because it provides a 256-bit security margin. The extra words also make transcription errors more likely, so verify carefully.
What does the BIP39 passphrase do?
The passphrase is appended to the salt string in the PBKDF2 seed derivation. The same mnemonic with a different passphrase produces a completely different 512-bit seed and a different wallet. It is sometimes called the '13th word' or '25th word'. If you set a passphrase, you must remember it to recover the wallet. Losing it makes the funds unrecoverable.
Can I recover my wallet with just the entropy hex?
Yes. The entropy hex is the raw random bytes. You can convert it back to a mnemonic using the BIP39 spec (append checksum, map to words) and then derive the seed. The entropy and the mnemonic are two representations of the same data. Keep whichever you stored private.
Why does the checksum matter?
The checksum is the first ENT/32 bits of the SHA-256 hash of the entropy. It lets a wallet detect a typo before deriving keys. If you swap one word for another valid word, the checksum fails and the wallet rejects the phrase. Without it, a typo would silently produce a different wallet and the funds would appear lost.
Conclusion
A BIP39 mnemonic generator is the first step in creating a self-custody wallet. This tool produces the phrase, entropy, and derived seed entirely in your browser, so nothing is transmitted. Use it for testing, development, or wallet setup on a trusted machine. Write the phrase on paper, store it offline, and never share it. For high-value storage, pair the phrase with a hardware wallet and consider a passphrase for an additional layer of security. You can also validate an existing phrase with the seed phrase validator to catch typos before recovery.