BIP39 Passphrase Generator

Generate a BIP39 mnemonic from entropy

Pick a language, generate secure entropy, and copy values instantly — all in your browser

Last updated: January 23, 2026
Frank Zhao - Creator
CreatorFrank Zhao

Introduction / overview

This BIP39 Passphrase Generator creates and validates BIP39 mnemonics in multiple languages. It’s useful when you need a test mnemonic for development, you want to confirm a mnemonic is valid for a specific wordlist, or you’re comparing outputs across languages.

Security note: a real seed phrase is sensitive. Treat it like a password you can’t reset. Avoid generating or pasting real wallet mnemonics on an untrusted device.

Who is this for?

  • Developers writing wallet tooling or test suites.
  • Security reviewers validating that a mnemonic matches a language wordlist.
  • Crypto learners who want to understand how entropy becomes words.

If you’re working with tokens, hashes, or encoded values, you might also like our Hash Text tool, bcrypt (for password hashing demos), or Encrypt / Decrypt Text.

How to use / quick start

1

Pick a language wordlist

Choose the wordlist that matches your target wallet or ecosystem. A mnemonic that is valid in one language wordlist is typically not valid in another.

2

Generate entropy and a mnemonic

Click the refresh icon to generate fresh entropy. The mnemonic updates automatically when the entropy is valid.

3

Paste a mnemonic to validate it

You can edit the mnemonic field directly. If it’s valid for the selected language, the tool derives the corresponding entropy.

4

Copy only what you need

Use the copy buttons next to each field. If you share a link, consider turning off “include results”.

Terminology tip

Many people say “passphrase generator” when they mean “mnemonic generator”. In BIP39, a separate optional “passphrase” (sometimes called the 25th word) may also exist. This tool generates the mnemonic phrase, not the optional passphrase.

Step-by-step examples

Example 1: why a 12-word mnemonic is common

A standard BIP39 mnemonic is derived from entropy plus a checksum. If you start with 128128 bits of entropy:

CS=ENT/32CS = ENT/32==128/32128/32==44 bits\text{ bits}
Total bits=ENT+CS\text{Total bits} = ENT + CS==128+4128 + 4==132132
Words=(ENT+CS)/11\text{Words} = (ENT + CS)/11==132/11132/11==1212

In this calculator, entropy is entered as hex. Because 11 hex character is44 bits, a 128-bit entropy value corresponds to128/4=32128/4 = 32 hex characters.

Example 2: 24 words from 256-bit entropy

If you use ENT=256ENT = 256 bits (64 hex characters), thenCS=256/32=8CS = 256/32 = 8 bits. Total bits:256+8=264256 + 8 = 264, and264/11=24264/11 = 24 words.

ENTENT==256256\RightarrowEntropy hex length=256/4=64\text{Entropy hex length} = 256/4 = 64

Practical takeaway: the “number of words” is determined by the entropy size. If you paste a 24-word mnemonic, this tool derives the matching entropy (if valid for the selected language).

Real-world examples / use cases

1) Creating deterministic test fixtures

Background: you’re writing a wallet import flow and need stable test data.

Inputs: pick a language, then paste a mnemonic from a known test vector.

Result: the tool derives entropy EE and confirms the mnemonic is well-formed. You can then hash derived keys with our Hash Text tool for debugging.

2) Checking language wordlists

Background: a user reports “my seed phrase is rejected” in a specific UI.

Inputs: choose the suspected language and paste the mnemonic.

Result: if it fails here, the phrase likely contains a word outside that wordlist, wrong spacing (common with Japanese), or an invalid checksum.

3) Learning how mnemonics encode entropy

Background: you want intuition for how “random words” are structured.

Inputs: generate entropy, then toggle words by changing entropy characters.

Result: you’ll see the mnemonic change in ways consistent with the checksum and 11-bit word indices.

4) Preparing safe demo content

Background: you’re recording a tutorial video and need a fake mnemonic that looks real.

Inputs: generate a new mnemonic in your chosen language.

Result: you get a syntactically valid phrase. If you later need to demonstrate encoding or hashing text, pair it with Encrypt / Decrypt Text.

Common scenarios / when to use

Checksum sanity-check

Quickly verify if a mnemonic is structurally valid for a specific language wordlist.

Language mismatch debugging

Confirm the mnemonic’s words belong to the intended wordlist (especially when users copy across apps).

Test automation support

Generate safe, random mnemonics for unit tests, then validate round-trip conversions.

Demo wallets

Create a realistic mnemonic for tutorials and product demos without exposing real funds.

Copy-safe formatting

Copy entropy or mnemonic cleanly and consistently when moving between tools.

Entropy inspection

Confirm entropy looks correct (hex-only, correct length) before feeding it into another library.

When this tool may not be appropriate:

  • Generating a real wallet seed on a device you don’t fully trust.
  • Deriving private keys (that requires BIP32/BIP44 derivation, not just BIP39).

Tips & best practices

  • Prefer longer entropy when you can: 256256 bits yields a2424-word mnemonic.
  • For Japanese mnemonics, spacing rules matter. Copy/paste can introduce non-standard whitespace.
  • If you share a link, do not include results unless it’s disposable test data.
  • If you need encryption for storing notes, use Encrypt / Decrypt Text rather than inventing a new scheme.

Calculation method / formula explanation

BIP39 converts entropy into a list of words by appending a checksum and then splitting the bitstring into1111-bit chunks. Each chunk is an index into a 2048-word list.

Key relationships

CS=ENT/32CS = ENT / 32
Words=(ENT+CS)/11\text{Words} = (ENT + CS) / 11

Where ENTENT is the entropy size in bits, and CSCS is the checksum size in bits.

Hex input interpretation

In this calculator you enter entropy as a hex string. That corresponds to bits viabits=4×hex characters\text{bits} = 4 \times \text{hex characters}. So a 32-hex entropy value is 128128 bits, and a 64-hex entropy value is256256 bits.

Related concepts / background info

Mnemonic vs seed vs passphrase

  • Mnemonic: the word sequence produced by BIP39.
  • Seed: a binary value derived from the mnemonic (and optional passphrase) using PBKDF2.
  • Passphrase: an optional extra string used with the mnemonic to derive the seed.

Where BIP39 fits

BIP39 covers the mnemonic encoding step. Wallets usually combine it with BIP32 (HD keys) and BIP44 (derivation paths). If your goal is to generate addresses, you’ll need those additional layers.

Frequently asked questions (FAQs)

Is a mnemonic the same as a private key?

No. A mnemonic encodes entropy plus a checksum. Wallets derive a seed and then keys from that.

Why does my mnemonic fail in another language?

Because each language has its own 2048-word list. If even one word isn’t in that list, validation fails.

What entropy lengths does this tool accept?

Entropy must be hex, between 1616 and 3232 characters, and a multiple of 44.

Can I safely share a generated mnemonic?

Only share disposable test mnemonics. Never share a phrase that protects real funds.

Does this tool generate the optional BIP39 passphrase?

No. It generates the mnemonic phrase. The optional passphrase is a separate input used later during seed derivation.

Limitations / disclaimers

Important safety note

  • This calculator is for education and tooling support, not professional security or financial advice.
  • Never generate or paste a real wallet recovery phrase on a device you don’t fully trust.
  • Always follow your wallet vendor’s official guidance for secure seed generation, backup, and recovery.
  • This page focuses on BIP39 mnemonics; it does not derive BIP32/BIP44 keys or addresses.

External references / sources