Home / Crypto & Blockchain / Wallet, Security & Tax / Recovery Phrase Entropy from Word Count

Formula & Calculator

Recovery Phrase Entropy from Word Count

This approximates the security strength of common BIP-39 recovery phrase lengths. Each word in a 2,048-word list contributes about 11 bits of entropy, so a 12-word phrase has roughly 132 bits, and a 24-word phrase has 264 bits. It shows why longer seed phrases are exponentially more secure. Even a 12-word phrase is practically unbreakable, but 24 words gives an extra safety margin against future quantum computing threats. It is a useful security heuristic for wallet users.

Crypto Security Wallet Management
VORZEP · CRYPTO SECURITY TOOLS

Recovery Phrase Entropy Calculator

Estimate how much real security a BIP-39 style seed phrase actually carries. Solve Security ≈ Words × bits-per-word for any of its three unknowns — total entropy, word count, or effective bits per word — with step-by-step math, a live word-accumulation schematic, and crack-time estimates across attacker budgets.

Security ≈ Words · 10.3 bits
Solve for
Total Entropy (S) The total number of bits of uncertainty in the phrase — the base-2 logarithm of the size of the search space an attacker must exhaust. 64 bits means 2⁶⁴ ≈ 1.8 × 10¹⁹ possibilities; 128 bits means 3.4 × 10³⁸. This is what actually protects the wallet; word count is only a proxy for it. A standard 12-word BIP-39 phrase carries 128 bits.
bits
Entropy must be greater than zero.
Word Count (W) How many words are in the phrase. Standard BIP-39 phrases come in 12, 15, 18, 21 and 24 words — corresponding to 128, 160, 192, 224 and 256 bits of entropy. A 12-word phrase is the default in almost every wallet. Anything below 12 words should be treated as a toy, and a hand-picked phrase of any length is far weaker than its word count suggests.
words
Word count must be greater than zero.
Bits per Word (B) How much entropy each word actually contributes. BIP-39 uses a fixed 2,048-word list, so log₂(2048) = 11.0 bits per word nominally. The conservative 10.3 used here accounts for checksum overhead, the fact that the final word is partly determined by the earlier ones, and real-world bias in wallet RNG. Diceware-style lists are larger: a 7,776-word list gives log₂(7776) ≈ 12.9 bits per word. A short custom list of 64 words gives only 6 bits.
bits/word
Bits per word must be greater than zero.
TOTAL ENTROPY (S)
123.6 bits
—
ADEQUATE — MEETS ABSOLUTE MINIMUM
S = W · B
Step-by-step solution
Entropy vs. word count
Current bits/word 10.3 (conservative) 12.9 (Diceware)
Entropy vs. bits per word
Current word count W × 0.5 W × 1.5
Sensitivity
Companion security metrics
Entropy accumulating word by word — live schematic
RECOVERY PHRASE ENTROPY · S = W · B WORD COUNT 12 words in phrase × BITS PER WORD 10.3 effective entropy per word = TOTAL ENTROPY 123.6 bits search space 2¹²³·⁶ ENTROPY ACCUMULATION each segment = one word = 10.3 bits ADEQUATE — meets the absolute minimum, below the 128-bit standard S = 12 × 10.3 = 123.6 bits
Word count multiplied by entropy per word Accumulated entropy with threshold markers Resulting search-space size
What the entropy estimate really measures
Stotal entropy
=
Wwords
×
Bbits per word

Entropy is not the same as word count

The number of words in a phrase tells you nothing on its own. What matters is how the words were chosen. Twelve words drawn uniformly at random from a 2,048-word list carry about 128 bits of genuine entropy, because an attacker who knows the list still has 2¹²⁸ equally likely candidates to try. Twelve words you picked yourself from a poem, a song lyric, or your own memory carry perhaps 20–40 bits, because an attacker who knows anything about you can guess them in a tiny fraction of the space. The formula assumes uniform random selection — if that assumption fails, the estimate is worthless no matter how many words you use.

Why 10.3 and not 11.0?

BIP-39 uses a fixed list of 2,048 words, and log₂(2048) = 11.0 exactly, so each word nominally carries 11 bits. The conservative 10.3 figure used here bakes in several real-world haircuts: the final word contains checksum bits and is not free to be anything (for 12 words, 4 of the 132 bits are checksum, giving 128 bits across 12 words — an effective 10.67 bits per word); wallet RNG is rarely perfectly uniform; and some implementations have historically had entropy bugs. Using a lower per-word figure is the safe direction to err. Nominal 11.0 is what the spec promises; 10.3 is closer to what you can count on in practice.

Crack times are astronomically large — by design

The point of 128 bits is that no realistic attacker can search the space. At a trillion guesses per second — a serious offline attack against a leaked hash — 2¹²⁸ takes roughly 10¹⁹ years, about a billion times the age of the universe. At 64 bits the same attacker finishes in about 6 months. That is the entire difference between a phrase that protects your life savings and one that does not, and it explains why 128 bits became the modern floor and why 12 words is the smallest phrase any serious wallet will generate.

The real risk is never brute force

In practice, no one has ever had a properly generated 12-word phrase brute-forced. Every real-world loss comes from somewhere else: the phrase was photographed and the photo synced to cloud storage; it was typed into a phishing site; it was stored in a password manager that was itself breached; it was spoken aloud near a smart speaker; it was written on paper that a housemate found; or it was generated by a wallet with a broken RNG. Entropy math tells you the phrase is unbreakable — it says nothing about whether you will leak it. Treat the phrase as the single most sensitive secret you own and assume that anything digital can be copied.

How to Use This Calculator

The entropy estimate links three quantities: total bits of security, the number of words in the phrase, and the effective entropy each word contributes. Choose which one you want the tool to solve, then fill in the other two.

1. Choose what to solve for

Pick total entropy, word count, or bits per word. The calculator rearranges S = W × B automatically for whichever variable you select.

2. Set the bits-per-word assumption

The default 10.3 is deliberately conservative. Switch to 11.0 for the nominal BIP-39 figure, 10.67 for the checksum-adjusted effective value, or 12.9 for Diceware-style 7,776-word lists.

3. Enter your word count

Standard BIP-39 phrases are 12, 15, 18, 21 or 24 words. Presets cover all of them plus a 6-word example so you can see how quickly security falls off. Anything below 12 words should not be trusted with real funds.

4. Read the result and verdict

The result card shows total bits plus the log₁₀ search space, the nearest standard BIP-39 word count, and the equivalent number of random printable ASCII characters. A colour-coded verdict classifies the phrase from critical through maximum.

5. Check the schematic and charts

The schematic draws each word as an equal segment accumulating toward the total, with threshold markers at 80, 128 and 256 bits. The chart shows how entropy grows with word count at three different bits-per-word assumptions.

6. Switch to Advanced for depth

Advanced mode adds an entropy-vs-bits-per-word chart, a sensitivity check on a +1% input change, crack-time estimates across three attacker budgets, and companion metrics including dice-roll and password equivalents.

What This Tool Offers

Built around the classic entropy estimate S ≈ Words × bits-per-word — the number that actually determines whether a seed phrase is safe.

Three-way solving

Solve for total entropy, word count, or effective bits per word. The calculator rearranges the formula for whichever variable you choose.

Multiple entropy models

Switch between the conservative 10.3, the BIP-39 effective 10.67, the nominal 11.0, and Diceware's 12.9 bits per word — and see how much the answer moves.

Security-class verdict

Each result is classified from critical (trivially brute-forceable) through very weak, weak, marginal, adequate, strong, very strong and maximum, with a coloured badge.

Word-accumulation schematic

A live diagram that draws each word as an equal segment accumulating toward the total, with reference markers at 80, 128 and 256 bits drawn to scale.

Dual comparison charts

Entropy vs. word count at three bits-per-word assumptions, plus an advanced entropy-vs-bits-per-word chart for three phrase lengths.

Reference tables & crack times

A full lookup grid, the standard BIP-39 word-count table with checksums, crack-time estimates across attacker budgets, and a variable reference.

Reference Tables & Conversions

A crack-time snapshot, an entropy lookup grid, the standard BIP-39 table, and a variable reference.

Crack-time snapshot

Attacker rate (guesses/sec)
guesses/s
Target security floor (bits)
bits
Phrase generation cost
USD

Entropy Lookup Grid

Computed from S = W × B. Rows are word counts, columns are bits per word. Values are total bits of entropy.

Standard BIP-39 Word Counts

The five valid BIP-39 phrase lengths, their entropy, and the checksum bits appended to each. Total bits is entropy plus checksum.

WordsEntropy (bits)Checksum (bits)Total (bits)Effective bits/wordSecurity class
12128413210.67Strong — modern minimum
15160516510.67Very strong
18192619810.67Very strong
21224723110.67Excellent
24256826410.67Maximum — 256-bit

Entropy Sources Compared

How common generation methods stack up, in bits per unit and typical total.

MethodBits per unitTypical totalNotes
BIP-39 (2,048 words)11.0 nominal / 10.67 effective128–256 bitsStandard for virtually all wallets
Diceware (7,776 words)12.9 per word78–155 bits6–12 words typical; longer list, fewer words
Coin flips1.0 per flip128–256 bitsTruly random if the coin is fair
Six-sided dice2.585 per roll128 bits ≈ 50 rollsCommon offline entropy source
Ten-sided dice3.322 per roll128 bits ≈ 39 rollsFaster than six-sided for the same entropy
Random printable ASCII6.55 per character128 bits ≈ 20 charslog₂(94); hard to write down reliably
Hex string4.0 per character128 bits = 32 hex charsHow the raw entropy is often stored
Base64 string6.0 per character128 bits ≈ 22 charsCompact but case-sensitive
Hand-picked words~2–5 effectiveHighly variableNever rely on this — attacker dictionaries are vast

Variable Reference

SymbolMeaningTypical rangeUnits
STotal entropy40 – 512bits
WWord count6 – 48words
BBits per word6 – 13bits/word
2SSearch space size10¹² – 10¹⁵⁴combinations
rAttacker guess rate10⁹ – 10¹⁸guesses/s
tExpected search time2S ÷ rseconds
ηChecksum overhead4 – 8bits

What Does Recovery Phrase Entropy Measure?

Entropy is the measure of how much an attacker does not know. A recovery phrase with 128 bits of entropy is one drawn from a space of 2¹²⁸ ≈ 3.4 × 10³⁸ equally likely possibilities, and an attacker with no additional information must search that entire space to be certain of finding it. The formula here — total entropy equals word count times the entropy each word contributes — is the simplest useful estimate of that quantity, and it is accurate whenever the words were selected uniformly at random from a known list. Everything else about seed-phrase security is a footnote to that assumption.

The Entropy Formula

The defining relationship is:

Security ≈ Words × Bits per Word

Rearranged to solve for the other two unknowns:

Words = Security ÷ Bits per Word
Bits per Word = Security ÷ Words

With the standard conservative assumption of 10.3 bits per word, a 12-word phrase gives 123.6 bits, a 15-word phrase gives 154.5 bits, and a 24-word phrase gives 247.2 bits. With the nominal BIP-39 figure of 11.0, the same phrases give 132, 165 and 264 bits.

Entropy Variables

SymbolMeaningNotes
STotal entropyBits of uncertainty; the log₂ of the search-space size
WWord countNumber of words in the phrase; 12–24 for standard BIP-39
BBits per wordlog₂ of the wordlist size, adjusted down for real-world factors
2SSearch spaceTotal number of phrases an attacker must consider
rAttacker rateGuesses per second; 10¹² is a realistic offline budget
ηChecksum bits4 bits for 12 words, 8 for 24; reduces effective bits per word

How Each Variable Affects Security

Word count scales the total linearly, but the effect on attacker effort is exponential. Adding one word at 10.3 bits per word multiplies the search space by 2¹⁰·³ ≈ 1,260. Adding three words multiplies it by roughly two billion. This is why the jump from 12 to 24 words is so dramatic — it does not double the difficulty, it raises it to the power of about 10³⁷. There is no realistic attacker who can bridge that gap, which is why 24-word phrases are considered overkill for almost all purposes and 12 words is the practical standard.

Bits per word is the input people most often get wrong. The figure depends entirely on how large the wordlist is and how uniformly the words are drawn from it. A 2,048-word BIP-39 list gives 11 bits nominally; a 7,776-word Diceware list gives 12.9 bits; a 64-word custom list gives only 6 bits. But the far more important failure is non-uniform selection. If you choose words yourself, the effective bits per word collapses to something like 2–5 bits, because attacker wordlists are built from exactly the kinds of phrases people invent. A twelve-word hand-picked phrase may look impressive and carry less than 40 bits of real entropy.

The checksum overhead is a small but real haircut. BIP-39 appends 4 to 8 checksum bits to the entropy, and because the total must divide evenly into 11-bit word indices, the last word is partly constrained by the earlier ones. For a 12-word phrase, 128 bits of entropy plus 4 checksum bits gives 132 bits spread over 12 words — 10.67 effective bits per word rather than 11.0. That is why the calculator offers 10.67 as a middle option between the conservative 10.3 and the nominal 11.0.

Finally, the crack-time calculation turns bits into intuition. Expected search time is 2S ÷ r, where r is the attacker's guess rate. At r = 10¹² guesses per second — a realistic offline attack against a leaked hash — 64 bits takes about six months, 80 bits takes about 38,000 years, 100 bits takes about 4 × 10¹³ years, and 128 bits takes about 10¹⁹ years. The universe is about 1.4 × 10¹⁰ years old. This is the cliff that separates phrases worth using from phrases worth discarding.

Entropy Calculation Examples

Given: W = 12 words, B = 10.3 bits/word — solve for total entropy
S = 12 × 10.3 = 123.6 bits
Given: W = 24 words, B = 10.3 bits/word — solve for total entropy
S = 24 × 10.3 = 247.2 bits
Given: S = 128 bits, B = 10.3 bits/word — solve for word count
W = 128 ÷ 10.3 = 12.43 words → 13 words, or use a standard 15-word phrase
Given: S = 128 bits, W = 12 words — solve for bits per word
B = 128 ÷ 12 = 10.67 bits/word — the BIP-39 effective figure
Given: S = 123.6 bits at r = 10¹² guesses/sec — solve for crack time
Search space = 2¹²³·⁶ ≈ 1.55 × 10³⁷ combinations
Expected time = 1.55 × 10³⁷ ÷ 10¹² = 1.55 × 10²⁵ seconds
= ≈ 4.9 × 10¹⁷ years — about 35 million times the age of the universe
Given: S = 128 bits — equivalent random printable ASCII characters
Chars = 128 ÷ log₂(94) = 128 ÷ 6.55 = ≈ 19.5 characters

Frequently Asked Questions

A properly generated 12-word BIP-39 phrase carries 128 bits of entropy, which is far beyond what any attacker can brute-force. At a trillion guesses per second it would take roughly 10¹⁹ years to exhaust the space — about a billion times the age of the universe. For every practical purpose, 12 words is safe. The reason some people prefer 24 words is not that 128 bits is weak; it is defence in depth. A 24-word phrase gives 256 bits, which means that even if a future cryptanalytic advance or a side-channel leak reduced the effective entropy by a large factor, there would still be plenty of margin left. It also means the phrase remains safe even if an implementation has a subtle bias that shaves 20 or 30 bits off the theoretical maximum. The trade-off is that 24 words is harder to write down accurately and easier to make a transcription error on. If you are generating with a reputable hardware wallet, 12 words is genuinely fine; if you want maximum margin and can store 24 words reliably, take 24.

Because 11.0 is the theoretical maximum and real-world phrases rarely achieve it. The BIP-39 wordlist has exactly 2,048 entries, and log₂(2048) = 11.0, so each word drawn uniformly from that list contributes exactly 11 bits. But three things eat into that. First, the checksum: BIP-39 appends 4 to 8 bits of checksum, and the total bit string must divide evenly into 11-bit indices, so the last word is partly determined by the preceding ones. For 12 words that gives 128 bits of entropy across 12 words — 10.67 effective bits per word, not 11.0. Second, wallet RNG is not perfectly uniform; implementations have shipped with entropy bugs more than once. Third, users sometimes intervene in the generation process, which further reduces entropy. The 10.3 figure is a deliberately conservative estimate that leaves margin for all three. If you want to see the nominal figure, switch the preset to 11.0; the tool will show you how much the answer changes.

This is the single most dangerous mistake in seed-phrase security. A phrase you invent carries far less entropy than its word count suggests, because you are not a uniform random source. Your choices are shaped by your vocabulary, your interests, the books you have read, and the phrases that happen to feel memorable — and attacker wordlists are built from exactly those biases. Research on password cracking shows that human-chosen sequences typically carry only 2–5 bits of effective entropy per word rather than 11. A twelve-word phrase you composed yourself might carry 30 bits instead of 128, which an attacker with a good dictionary and a trillion guesses per second can exhaust in minutes. Always let the wallet's hardware random number generator produce the phrase. Never edit it, never reorder it, never substitute a word you like better.

Longer than the universe has existed, by a very large margin. A 12-word BIP-39 phrase has 2¹²⁸ ≈ 3.4 × 10³⁸ possible combinations. A well-funded attacker with custom silicon might manage 10¹² guesses per second against a single target. Dividing gives 3.4 × 10²⁶ seconds, which is about 10¹⁹ years. The universe is roughly 1.4 × 10¹⁰ years old, so the search would take about a billion times the current age of the universe. Even at an absurd 10¹⁸ guesses per second — a rate no real system achieves — the answer is still 10¹³ years, roughly a thousand times the age of the universe. The numbers only become tractable below about 80 bits, and they become genuinely alarming below about 60 bits: 64 bits at 10¹² guesses per second is about six months, and 50 bits is about thirteen days. That is the cliff.

Neither, strictly speaking — it is an error-detection mechanism, not a security mechanism, and it slightly reduces the effective bits per word. BIP-39 appends 4 bits of checksum to a 128-bit entropy value for 12-word phrases, 5 bits for 15 words, and so on up to 8 bits for 24 words. The checksum lets a wallet detect a mistyped or misremembered word immediately, which is genuinely valuable for usability and prevents funds being sent to an address derived from a corrupted seed. But it does not add entropy: the checksum is fully determined by the entropy, so an attacker who guesses the entropy automatically gets the checksum right. The practical effect is that a 12-word phrase has 128 bits of entropy packed into 132 bits of encoded data, giving 10.67 effective bits per word rather than 11.0. That is the only sense in which the checksum "costs" anything.

Modern practice treats 128 bits as the floor for anything holding real value, and 256 bits as the ceiling worth bothering with. Below 128 bits you are still in territory where a sufficiently determined and well-resourced attacker — a nation-state, or a well-funded group with custom ASICs — could plausibly mount a search, especially if the target is known to be valuable. Between 80 and 100 bits is the legacy zone: it was the standard in the 1990s and early 2000s, and it is no longer considered adequate for long-lived secrets. Below 64 bits, a well-equipped attacker finishes in days to months, and below 40 bits it is a matter of hours or minutes. The reason 128 bits is the floor rather than, say, 100 is margin: you want the secret to remain safe for decades even if cryptanalysis advances, even if the generation had a flaw, and even if the attacker is far better resourced than anything we can currently imagine.

Because brute-forcing the entropy is not how anyone loses crypto. Every real-world seed-phrase theft comes from a leak, not a crack. The common failure modes: photographing the written phrase and having the photo sync to iCloud or Google Photos; typing the phrase into a phishing site that mimics a wallet restore screen; storing it in a notes app, a cloud document, or a password manager that is later breached; entering it on a compromised computer infected with a keylogger; saying it aloud near a smart speaker or on a phone call; writing it on paper that is then photographed, thrown away, or found by someone in the house; and generating it on a device with a compromised or poorly implemented random number generator. The entropy calculation tells you the phrase is uncrackable. It says nothing about whether you will hand it to someone. Treat the phrase as the single most sensitive secret you will ever hold, and assume that anything connected to the internet can and will be copied.

Only if the additional words are also drawn from the uniform random source. A 24-word phrase generated properly has 256 bits and is stronger than a 12-word phrase. A 24-word phrase where the last twelve words were chosen by a human carries no more effective entropy than a 12-word phrase plus twelve near-certain guesses — the attacker simply tries the human-chosen portion first, because dictionaries of common phrases are small. The same logic applies to any scheme where part of the phrase is derived from a passphrase, a PIN, or a pattern: the entropy of the whole is only as large as the weakest component, and a four-digit PIN adds at most 13.3 bits regardless of how long the rest of the phrase is. Length is a proxy for entropy, not a substitute for it.

Estimating...

Variables

Symbol Quantity Unit
Security Level Approximate security strength bits
Word Count Number of words in the recovery phrase

What it means

Each word in a BIP‑39 seed phrase adds about 10.3 bits of entropy (log₂(2048)). This is used to estimate the security level. Understanding this helps users evaluate the security of their recovery phrase.

Worked example

Recovery Phrase Entropy – Two Detailed Examples

Real‑World
Scenario: A user creates a 12‑word BIP‑39 recovery phrase from a 2048‑word list. The approximate security level is 12 × 10.3 ≈ 124 bits (actually 128 bits with checksum). This level is considered secure for most personal wallets. The user understands that their funds are protected by an astronomically large number of possible combinations.
ParameterValue
Word Count12
1Security Level ≈ 12 × 10.3 = 124 bits (actual BIP‑39 is 128 bits with checksum)
Result ~124 bits ✓ Secure
Scenario: An institutional user opts for a 24‑word phrase, giving 24 × 10.3 ≈ 247 bits (256 bits with checksum). This ultra‑high security level is recommended for large funds and enterprises. The custodian ensures that the phrase is stored in multiple secure locations to prevent loss.
ParameterValue
Word Count24
1Security Level ≈ 24 × 10.3 = 247 bits (actual BIP‑39 is 256 bits with checksum)
Result ~247 bits ✓ Ultra secure
Insight: The security level of a BIP‑39 recovery phrase is determined by the number of words. More words provide exponentially more combinations, making brute‑force attacks infeasible. 12 words offer 128 bits of security, while 24 words offer 256 bits.

Common mistakes

  • Recovery phrase entropy (approx): Word count × 10.3 bits per word (BIP‑39).
  • 10.3 bits: Derived from log₂(2048) ≈ 11 bits, but BIP‑39 has checksum bits.
  • Approximation: 12 words ≈ 128 bits, 24 words ≈ 256 bits.
  • Security level: Should be sufficient for cryptographic security.

Applications

Recovery phrase entropy from word count approximates the security level of a seed phrase based on the number of words, using the BIP‑39 standard (about 10.3 bits per word). This is a quick way to estimate the security of different seed lengths. Users can use it to compare 12‑word and 24‑word phrases. Understanding this entropy helps in choosing a sufficiently secure recovery phrase.

  • Evaluating the security of seed phrases
  • Choosing between 12‑word and 24‑word seeds
  • Security education for crypto wallets
  • Understanding the importance of word count
  • Educational understanding of seed phrase security