Missing Seed Phrase Word: 12 vs 24 Words Math
When one word of a BIP-39 recovery phrase is missing and you know which position it filled, the checksum narrows the 2,048 possible words to 128 valid candidates for a 12-word phrase and 8 for a 24-word phrase. The counts are exact when the gap is the final word. For any other position they average the same, with some spread.
The difference between 128 and 8 does not come from the extra twelve words. It comes from four extra checksum bits. A 12-word phrase carries 128 bits of entropy plus a 4-bit checksum, and a 24-word phrase carries 256 bits plus an 8-bit checksum. One missing word is 11 unknown bits in either case, so the only thing separating the two lengths is how many wrong candidates the checksum can throw away: 15 of every 16 for 12 words, 255 of every 256 for 24 words.
Every complete phrase printed below is an official BIP-39 test vector, taken from the python-mnemonic vectors file that the BIP's own "Test vectors" section links to. Those phrases are public, they appear in wallet documentation and test suites, and they are labelled test-only wherever they occur. No real recovery phrase is used here, and none should be typed into any website, chat or form to check anything. The counts come from one script that implements the BIP-39 checksum with SHA-256 and the official English wordlist, and that script reproduces all 24 official English vectors before any count is used.
One limit applies to everything that follows. The numbers describe what the BIP-39 arithmetic allows. They do not recommend a phrase length, a backup method, a recovery tool or a wallet, and they say nothing about how to store a phrase. Where the text turns to passphrases, scams and offline handling, each statement is tied to a number or to a quoted source, and nothing goes further than that. Choosing between 12 and 24 words involves backup handling, device support and personal circumstances that arithmetic cannot weigh.
What 12 and 24 Words Actually Encode
BIP-39 describes the construction of a phrase in one paragraph:
"First, an initial entropy of ENT bits is generated. A checksum is generated by taking the first ENT / 32 bits of its SHA256 hash. This checksum is appended to the end of the initial entropy. Next, these concatenated bits are split into groups of 11 bits, each encoding a number from 0-2047, serving as an index into a wordlist. Finally, we convert these numbers into words and use the joined words as a mnemonic sentence."
The same section gives the lengths the specification allows. The allowed size of ENT is 128 to 256 bits, in multiples of 32, and the checksum length is CS = ENT / 32.
| Entropy (ENT) | Checksum (CS) | ENT + CS | Words (MS) |
|---|---|---|---|
| 128 bits | 4 bits | 132 bits | 12 |
| 160 bits | 5 bits | 165 bits | 15 |
| 192 bits | 6 bits | 198 bits | 18 |
| 224 bits | 7 bits | 231 bits | 21 |
| 256 bits | 8 bits | 264 bits | 24 |
Source: BIP-39, "Generating the mnemonic" (bitcoin/bips on GitHub). The relation MS = (ENT + CS) / 11 holds in every row.
Because CS is one thirtysecond of ENT and each word holds 11 bits, a phrase of MS words always has MS / 3 checksum bits: 4 for 12 words, 8 for 24. The 2,048-word English list that supplies the words is sorted, contains 2,048 distinct entries of 3 to 8 letters, and has the property the BIP asks of it: the first four letters of every word are unique, so four letters identify a word. The two lengths at the ends of the table behave like this.
| Quantity | 12-word phrase | 24-word phrase |
|---|---|---|
| Entropy bits | 128 | 256 |
| Checksum bits | 4 | 8 |
| All word sequences of that length | 2^132 | 2^264 |
| Sequences whose checksum is correct | 2^128 | 2^256 |
| Share of sequences that pass | 1 in 16 | 1 in 256 |
| Bits in the final word (entropy + checksum) | 7 + 4 | 3 + 8 |
| Valid final words when every other word is fixed | exactly 128 | exactly 8 |
All values computed from the BIP-39 construction; the last row is also confirmed by exhaustive count on the official test vectors, described below.
A sequence that fails the checksum can still be turned into a seed, because the seed is derived from the words themselves rather than from the entropy. The BIP says as much: "Although using a mnemonic not generated by the algorithm described in "Generating the mnemonic" section is possible, this is not advised and software must compute a checksum for the mnemonic sentence using a wordlist and issue a warning if it is invalid." A wrong checksum is therefore a warning from the software, not a mathematical impossibility. A phrase produced by the algorithm in the BIP passes by construction, which is what makes the checksum useful for narrowing a search: if your phrase came from a wallet that follows the BIP, it is one of the sequences that pass.
The Checksum Test, Step by Step
The whole test fits in six steps and needs no network, no wallet and no key.
A script that does exactly this was checked against the 24 official English vectors in the file that the BIP points to. For every vector it rebuilt the published phrase from the published entropy, found the checksum correct, and, using the PBKDF2 method the BIP specifies with the passphrase "TREZOR", reproduced the published 64-byte seed. Eight of the 24 vectors are 12 words long and eight are 24 words long. Every other count here comes from the same script, run on those public phrases only.
The Last Word Carries the Checksum
The final word of a phrase is built differently from the others. It holds 11 bits, and the last CS of them are the checksum. In a 12-word phrase that leaves 7 free entropy bits in the final word; in a 24-word phrase, 3.
Suppose the first 11 words are known. They fix 121 of the 128 entropy bits. The final word can only choose the remaining 7 bits, so there are 2^7 = 128 possible entropy values. Each one has its own SHA-256 hash and therefore its own 4-bit checksum, and that checksum has to match the last 4 bits of the word. So every one of the 128 entropy values yields exactly one valid final word, and every other word in the list is wrong. The count does not depend on which 11 words came first. For 24 words the same argument gives 2^3 = 8.
| Official test vector (test only) | Words known | Valid final words out of 2,048 |
|---|---|---|
| 12 words, entropy 00000000000000000000000000000000 | "abandon" repeated 11 times | 128, one of which is "about" |
| 24 words, entropy of 64 zero hex digits | "abandon" repeated 23 times | 8, one of which is "art" |
The complete 12-word vector is: abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about. Source: python-mnemonic vectors.json, linked from the BIP-39 "Test vectors" section. Test only: this phrase is public and must never hold funds.
A second vector shows that the count is not special to the all-zero case. The phrase beginning "legal winner thank year wave sausage worth useful legal winner thank" ends in "yellow", and again exactly 128 of the 2,048 words complete it with a correct checksum. This phrase is also a public test vector, for test use only. Across all eight 12-word vectors the count for the final position was 128 every time, and across all eight 24-word vectors it was 8 every time.
Passing the checksum makes a word a candidate. It does not make it yours. If 128 words pass, 127 of them lead to a different wallet that the arithmetic cannot distinguish from the right one. Telling them apart takes outside information, such as an address you know the wallet used or the history of the chain, and the checksum cannot supply that.
A Missing Word in Any Other Position
When the gap is not the final word, the argument changes. A word in the middle contributes 11 entropy bits, and replacing it changes the entropy, which changes the SHA-256 hash, which re-rolls the checksum. Each of the 2,048 candidates then passes as if by a 1-in-16 draw for a 12-word phrase, or a 1-in-256 draw for a 24-word phrase. The average is 2,048 / 16 = 128 for 12 words and 2,048 / 256 = 8 for 24 words. The actual count for a given phrase is a random-looking number near that average, and the spread of a binomial draw is about 10.95 for 12 words and 2.82 for 24 words.
The official vectors let that be tested directly. For each vector and each position, every one of the 2,048 words was tried in the gap with the other words held fixed.
| Gap position | 12-word phrases (8 vectors) | 24-word phrases (8 vectors) |
|---|---|---|
| Final word | 128 every time (8 of 8 vectors) | 8 every time (8 of 8 vectors) |
| Any other position | mean 130.07, from 104 to 158 (88 gaps) | mean 8.95, from 2 to 17 (184 gaps) |
Exhaustive count over the official English test vectors. The gap count is 11 non-final positions × 8 vectors for 12 words and 23 × 8 for 24 words.
So a missing middle word of a 12-word phrase left between 104 and 158 candidates in the vectors, and a missing middle word of a 24-word phrase left between 2 and 17. Neither is a fixed figure, and both are small. The vectors include repetitive phrases and random-looking ones, and the counts behaved the same way for both.
The BIP lists the weakness of its own checksum among the shortcomings: "The checksum is short. This means it only gives modest odds of catching random errors (1-in-256 errors will be missed). It is also not able to provide any assistance in correcting errors." The 1-in-256 figure matches the 8-bit checksum of a 24-word phrase. With the 4-bit checksum of a 12-word phrase, a random wrong word slips through 1 time in 16, which is the reason 128 of 2,048 survive. The second sentence of the quote is the one that matters for recovery: the checksum can reject a candidate, but it can never point at the right word.
One, Two, Three and Four Missing Words
Each additional missing word multiplies the raw combinations by 2,048, which is 11 more bits, while the checksum removes the same fixed 4 or 8 bits whatever the number of gaps. With the positions of the gaps known and every other word correct, the valid candidates number about 2^(11k − CS) for k missing words.
| Missing words (k) | Combinations before the checksum | Valid, 12-word phrase | Valid, 24-word phrase |
|---|---|---|---|
| 1 | 2,048 (2^11) | about 128 (2^7) | about 8 (2^3) |
| 2 | 4,194,304 (2^22) | about 262,144 (2^18) | about 16,384 (2^14) |
| 3 | 8,589,934,592 (2^33) | about 536,870,912 (2^29) | about 33,554,432 (2^25) |
| 4 | 17,592,186,044,416 (2^44) | about 1,099,511,627,776 (2^40) | about 68,719,476,736 (2^36) |
Positions known, all other words correct and in order. The 12-word column is always 16 times the 24-word column. Counts are exact when the final word is among the missing and averages otherwise.
The two-word row was checked by brute force. All 4,194,304 pairs were tested for three pairs of positions in an official 12-word vector and three in an official 24-word vector.
| Phrase length | Missing positions | Valid pairs found | Average expected |
|---|---|---|---|
| 12 words | 3 and 7 | 262,218 | 262,144 |
| 12 words | 5 and 10 | 262,651 | 262,144 |
| 12 words | 11 and 12 (final word included) | 262,144 | 262,144 |
| 24 words | 3 and 7 | 16,281 | 16,384 |
| 24 words | 11 and 21 | 16,457 | 16,384 |
| 24 words | 23 and 24 (final word included) | 16,384 | 16,384 |
Exhaustive count on one official test vector of each length.
The pairs that include the final word land exactly on the formula, because for each of the 2,048 values of the other missing word the final word has exactly 128 (or 8) valid choices. The others scatter within 0.7 percent of it. The figures show something the headline comparison hides: moving from 12 to 24 words does not make a one-word or two-word gap harder to repair. It leaves 16 times fewer candidates. A 24-word phrase with three words forgotten at known positions still leaves 33,554,432 candidates, and a 12-word phrase with two forgotten leaves 262,144.
When You Do Not Know Where the Gap Is
A different situation arises when you have a list of the words that survived, in the right order, and do not know where the missing ones belong. Each missing word can then sit in any slot. With k missing words in a phrase of N words, there are C(N, k) ways to choose which slots they occupy, and each choice carries the 2^(11k) raw combinations.
| Missing words (k) | Slot choices, 12 / 24 words | Valid, 12-word phrase | Valid, 24-word phrase | 12-word count divided by 24-word count |
|---|---|---|---|---|
| 1 | 12 / 24 | about 1,536 | about 192 | 8.00 |
| 2 | 66 / 276 | about 17,301,504 | about 4,521,984 | 3.83 |
| 3 | 220 / 2,024 | about 118,111,600,640 | about 67,914,170,368 | 1.74 |
| 4 | 495 / 10,626 | about 544,258,255,749,120 | about 730,213,159,796,736 | 0.75 |
Valid count = C(N, k) × 2^(11k) / 2^CS, with the known words in order and correct. Sequences that coincide because an inserted word equals its neighbour are not removed, which changes the one-word counts by well under 0.1 percent.
The last column reverses at four missing words. For one to three missing words the 24-word phrase leaves fewer candidates, since the 16-fold checksum advantage outweighs the extra slots. At four missing words the number of ways to place the gaps in a 24-word phrase (10,626) is 21.5 times the number for a 12-word phrase (495), which overtakes the factor of 16, and the 24-word phrase has more candidates. The ratio keeps falling: 0.298 at five, 0.110 at six. The claim that a 24-word phrase leaves fewer candidates therefore holds for one to three missing words and fails from four upward when the gaps' positions are unknown.
The one-word case was also counted exhaustively. Take an official vector whose words are all distinct, remove its fifth word, and insert every one of the 2,048 words at every slot: 24,576 sequences for 12 words and 49,152 for 24. Across four 12-word vectors the number of correct-checksum sequences came out at 1,565, 1,498, 1,461 and 1,601 (mean 1,531.25), against an expected 1,536. Across three 24-word vectors it came out at 211, 194 and 183 (mean 196.00), against an expected 192. Of the 24,576 raw sequences, 11 coincide with another sequence because the inserted word equals a neighbour; of the 49,152, 23 do.
If the problem is a lost order and not a lost word, the arithmetic is harsher, and here the longer phrase is the worse case by a wide margin. With all 12 words present and distinct but in unknown order there are 12! = 479,001,600 arrangements, of which about 29,937,600 pass the 4-bit checksum. With all 24 words present there are 24! = 620,448,401,733,239,439,360,000 arrangements (about 6.2 × 10^23), and about 2.4 × 10^21 pass the 8-bit checksum. Neither is a number anyone searches by hand.
If You Remember How the Word Starts
The wordlist is designed so that a short prefix narrows the choice quickly, and that interacts well with the checksum. Prefix statistics for the 2,048 words:
| Letters known | Distinct prefixes | Largest group | Expected words sharing your word's prefix | Expected valid final words left, 12-word phrase | 24-word phrase |
|---|---|---|---|---|---|
| 1 | 25 | 250 (words starting with s) | 122.17 | 8.52 | 1.41 |
| 2 | 200 | 48 | 18.45 | 2.08 | 1.06 |
| 3 | 1,096 | 13 | 2.94 | 1.12 | 1.01 |
| 4 | 2,048 | 1 | 1.00 | 1.00 | 1.00 |
Computed from the official English list. The last two columns apply to a missing final word and equal 1 + (expected group size − 1) × 127 / 2,047 for 12 words, or × 7 / 2,047 for 24 words, because the true word always passes and each other word in its group passes with the same small probability as any other word. Only 25 letters begin words: none starts with x.
For the first official vector the 128 valid final words split by first letter from 15 starting with s down to a single word each for j and q. Knowing only that the word starts with a leaves 8 of those 128; knowing it starts with ab leaves 1. That is a bound on how much memory of the word helps, not a promise: a remembered first letter that is wrong sends the search in the wrong direction. The fourth row restates the BIP's design goal that four letters suffice to identify a word.
Counting Candidates Is Cheaper Than Testing Them
A count of candidates says how many phrases are left. It does not say how long the search takes, because every survivor of the checksum still has to be turned into a seed. The BIP specifies that step: PBKDF2 with HMAC-SHA512, 2,048 iterations, the mnemonic sentence as the password and the string "mnemonic" plus the passphrase as the salt, producing a 512-bit seed. On one thread of a consumer desktop processor, in Node.js, the script measured about 854 of these derivations per second. The checksum test itself is far cheaper: about 465,000 per second for 12-word candidates and 400,000 per second for 24-word candidates, roughly 470 to 545 times the rate of seed derivation.
The table converts survivors into single-thread time for the seed derivation alone.
| Missing words, positions known | 12-word: survivors and time | 24-word: survivors and time |
|---|---|---|
| 1 | 128, 0.1 seconds | 8, under 0.1 seconds |
| 2 | 262,144, 5.1 minutes | 16,384, 19.2 seconds |
| 3 | 536,870,912, 7.3 days | 33,554,432, 10.9 hours |
| 4 | 1,099,511,627,776, 40.8 years | 68,719,476,736, 2.5 years |
| Missing words, positions unknown | 12-word: survivors and time | 24-word: survivors and time |
|---|---|---|
| 1 | 1,536, 1.8 seconds | 192, 0.2 seconds |
| 2 | 17,301,504, 5.6 hours | 4,521,984, 88.2 minutes |
| 3 | 118,111,600,640, 4.4 years | 67,914,170,368, 2.5 years |
| 4 | 544,258,255,749,120, 20,188 years | 730,213,159,796,736, 27,086 years |
One thread, seed derivation only. A real search also has to turn each seed into keys and addresses and compare them with the chain, and it has to generate and filter the raw combinations, which for three unknown-position gaps in a 24-word phrase is a further 17.4 trillion checksum tests. None of that is timed here, so every figure is a floor. Other software and hardware will run at different speeds; the measurement fixes an order of magnitude and does not predict the speed of any particular tool.
Two things follow from the table without further assumption. A single missing word is a job of seconds in either length, so the 12-versus-24 comparison is irrelevant at that size: both are trivially searchable by anyone who holds the other words. And the feasibility boundary arrives between three and four missing words with known positions and between two and three with unknown positions, which is where the cost on this machine moves from hours or days into years. Searching in parallel on many cores shrinks the time in proportion to the cores, and the arithmetic is silent on how many an attacker or a recovering owner has.
Every Word Handed Over Removes 11 Bits
Reading the same arithmetic in the other direction gives the cost of disclosing part of a phrase. Each word whose position and spelling someone knows takes 11 bits off the work they face. With k words unknown and positions known, the valid completions number 2^(11k − CS).
| Words unknown | 12-word phrase: valid completions | 24-word phrase: valid completions |
|---|---|---|
| 1 | 2^7 = 128 | 2^3 = 8 |
| 2 | 2^18 = 262,144 | 2^14 = 16,384 |
| 3 | 2^29 | 2^25 |
| 4 | 2^40 | 2^36 |
| 6 | 2^62 | 2^58 |
| 8 | 2^84 | 2^80 |
| 12 | 2^128 (nothing known) | 2^124 |
| 24 | not applicable | 2^256 (nothing known) |
Computed as 2^(11k − CS) with CS = 4 for 12 words and 8 for 24 words.
The last rows make a point about the two lengths. A 24-word phrase of which 12 words are known still has 2^124 completions, almost as many as a 12-word phrase of which nothing is known (2^128). Half of a 24-word phrase protects about as well as the whole of a 12-word phrase, as far as the counting goes, and the same table shows that 11 of 12 words, or 22 of 24, is a different matter: 128 or 16,384 candidates, which take 0.1 seconds and 19.2 seconds of seed derivation at the measured speed. The arithmetic therefore gives no basis for treating "all but one word" or "all but two" as partial secrecy. Whoever holds that much of a phrase is seconds to minutes of computation away from the whole thing.
What a Passphrase Changes and What It Leaves Alone
BIP-39 allows an extra string to be mixed into the seed. In its words: "A user may decide to protect their mnemonic with a passphrase. If a passphrase is not present, an empty string "" is used instead." The salt for the PBKDF2 step is the text "mnemonic" followed by the passphrase, and that is the only place the passphrase enters. The checksum is computed from the words alone, so a passphrase does not change which final words are valid. A 12-word phrase with one missing word still leaves 128 candidates, whether or not a passphrase is set.
What the passphrase changes is what each candidate leads to. The same test-vector phrase, with three different passphrases, gives three unrelated seeds. Showing only the first 16 hexadecimal characters of each seed for the 12-word zero-entropy vector (test only):
| Passphrase | First 16 hex characters of the 64-byte seed |
|---|---|
| none (empty string) | 5eb00bbddcf06908 |
| TREZOR (the passphrase the official vectors use) | c55257c360c07c72 |
| trezor (lowercase) | f5057546039282b5 |
Computed with the PBKDF2 parameters from the BIP. The TREZOR seed matches the published vector. A different case yields an unrelated seed, and there is no error or warning anywhere in the process.
The BIP states the consequence plainly: "The described method also provides plausible deniability, because every passphrase generates a valid seed (and thus a deterministic wallet) but only the correct one will make the desired wallet available." Nothing in the process says that a passphrase is wrong. Every attempt produces a working, empty-looking wallet, and the checksum cannot reject a passphrase the way it rejects a word.
For a missing word the passphrase has two consequences, both pure multiplication. If the passphrase is known, nothing changes: 128 candidates, or 8. If it is unknown or misremembered, each candidate word has to be tried against every passphrase, and no checksum filters the passphrase half of the search. The bits that a passphrase adds depend on how it was chosen, and the arithmetic can state them only for random choices.
| Passphrase, chosen uniformly at random | Possibilities | Bits | Final word missing in a 12-word phrase: candidates × passphrases |
|---|---|---|---|
| 4 lowercase letters | 456,976 | 18.8 | 128 × 456,976 = about 5.8 × 10^7 (2^25.8) |
| 6 lowercase letters | 308,915,776 | 28.2 | about 4.0 × 10^10 (2^35.2) |
| 8 lowercase letters | about 2.1 × 10^11 | 37.6 | about 2.7 × 10^13 (2^44.6) |
| 8 letters and digits | about 2.2 × 10^14 | 47.6 | about 2.8 × 10^16 (2^54.6) |
| 4 words from the BIP-39 list | about 1.8 × 10^13 | 44.0 | not computed |
| 10 printable ASCII characters (95 symbols) | about 6.0 × 10^19 | 65.7 | not computed |
Computed values; a passphrase chosen by a person is almost never uniform, and the number of bits it carries in practice is lower than the table says by an amount the arithmetic cannot supply.
A forgotten passphrase combined with a forgotten word is therefore a different order of problem from a forgotten word alone. With 128 candidate words and a six-letter lowercase passphrase the search is already 2^35 seed derivations, which at the measured 854 per second is more than a year on one thread, and every extra character of the passphrase multiplies it by 26 or more.
Guessing a Whole Phrase: 2^128 Against 2^256
The other end of the scale is a guess at a complete phrase with nothing known. The number of valid 12-word phrases is 2^128, which is 340,282,366,920,938,463,463,374,607,431,768,211,456, or about 3.4 × 10^38. For 24 words it is 2^256, about 1.2 × 10^77. The second number is not twice the first. It is the square of it, 2^128 times larger.
The table uses hypothetical guess rates, each one an assumption and not a claim about any real attacker. At the measured 854 seed derivations per second per thread, a rate of 10^12 guesses per second would need about 1.2 billion threads of that speed.
| Guesses per second (hypothetical) | Years to try every 12-word phrase (2^128) | Years to try every 24-word phrase (2^256) |
|---|---|---|
| 10^12 | about 1.1 × 10^19 | about 3.7 × 10^57 |
| 10^15 | about 1.1 × 10^16 | about 3.7 × 10^54 |
| 10^18 | about 1.1 × 10^13 | about 3.7 × 10^51 |
Years = 2^128 or 2^256 divided by the rate and by 31,557,600 seconds per year. Covering the whole space is the worst case; a guess has a 1 in 2^128 chance per try against one specific phrase.
A single uniformly random valid 12-word guess matches one specific phrase with probability 1 in 2^128, about 2.9 × 10^-39. If a billion distinct funded 12-word wallets existed, each guess would hit one of them with probability about 2.9 × 10^-30. Both of those are tiny, and the table shows that neither 2^128 nor 2^256 is reachable at rates far beyond what the measured hardware does. On the arithmetic alone, a 12-word phrase that was generated at random is already outside exhaustive search, and the extra 128 bits of a 24-word phrase add margin that a search of these rates could not touch.
Whether that margin is useful depends on the stage after the phrase. The BIP-32 specification, which turns the seed into keys, says of the keys it produces: "The total number of possible extended keypairs is almost 2^512, but the produced keys are only 256 bits long, and offer about half of that in terms of security." NIST's key-management guidance puts a number on the same relationship. Table 2 of NIST SP 800-57 Part 1 Revision 5 (May 2020), "Comparable security strengths of symmetric block cipher and asymmetric-key algorithms", lists elliptic-curve keys of size f = 256 to 383 at a security strength of 128 bits, and f = 384 to 511 at 192. The note to the table adds: "The security-strength estimates will be significantly affected when quantum computing becomes a practical consideration." Bitcoin's BIP-32 specifies the secp256k1 curve. Going by key size, the 256 bits of entropy in a 24-word phrase therefore exceed the roughly 128 bits of strength that a 256-bit elliptic-curve key is credited with. Read together, the two sources imply that a 12-word phrase made of 128 random bits matches the strength of the key it generates, and that the extra entropy of 24 words does not raise the strength of that key above the curve's own. This reading goes by key size only; the NIST table does not mention the secp256k1 curve. The quantum caveat has its own article on this site, the post-quantum security analysis.
All of this applies only to phrases generated from random bits. The BIP's motivation section says: "This guide is meant to be a way to transport computer-generated randomness with a human-readable transcription. It's not a way to process user-created sentences (also known as brainwallets) into a wallet seed." A phrase of words chosen by a person does not carry 128 bits, whatever its length.
Where These Numbers Stop Applying
Every count above assumes five things, and when one fails the counts say nothing.
The phrase is a BIP-39 phrase on the English list. Electrum's own documentation says it does not use BIP-39 for its native seeds: "For these reasons, Electrum does not generate BIP39 seeds." Its seed phrases carry a version number checked with an HMAC and have no BIP-39 checksum, so the 128 and 8 figures do not apply to them. The BIP names SLIP-39 as an intended successor, which is a separate scheme, and it states that using non-English wordlists is "strongly discouraged". A 12-word phrase of unknown format has to be identified before any of this arithmetic is relevant.
The other words are right, spelled as the list spells them, and in order. A misremembered word turns a 128-candidate problem into a different one, and the checksum cannot say that it has happened; it will only report that no candidate works, or worse, that some candidates work and lead to empty wallets.
The checksum was computed by the wallet that made the phrase. A phrase from software that skipped the checksum, or one corrupted by a typing error that happened to be written into a backup, will fail the test, and the mathematics of the search shifts to enumerating sequences that the checksum would reject.
The derivation path and passphrase are known. The seed is not the address. A candidate that passes the checksum still has to be derived into keys by whatever path the original wallet used, and the BIP-39 text says nothing about that choice. A wallet that restores to an empty-looking balance may have the right phrase and the wrong path or passphrase.
The candidate needs a way to be confirmed. Out of 128 valid completions, exactly one is yours, and the arithmetic offers no way to know which. Confirmation needs a fact about the original wallet, typically an address or a transaction. Without one, there is no search to run.
Offers to Recover a Phrase for You
A forgotten word invites offers of help. The arithmetic says three things about them, and two official sources describe the fee pattern.
First, anyone given 11 of 12 words, with positions, holds the whole phrase to within 128 candidates. Testing 128 candidates against the chain takes a fraction of a second of computation. The same is true of 22 of 24 words, which leaves 16,384. Handing over all but a word or two is, in effect, handing over the wallet, and nothing in the BIP-39 construction offers a halfway state.
Second, the mechanism by which a person gives up control is the phrase itself. The BIP defines the seed as the PBKDF2 output of the mnemonic sentence and the passphrase, and says: "This seed can be later used to generate deterministic wallets using BIP-0032 or similar methods." Whoever has the sentence, and the passphrase if one is set, can derive the same keys. A website, form, chat window or support agent that asks for the phrase, or for all but a word of it, is asking for the keys. The checksum test needs no network, so a request to send words somewhere to be checked is a request for something the arithmetic does not require.
Third, for one missing word the search is 128 candidates, well under a second of computation at the measured speed. For several missing words with unknown positions, the counts in this article are the number of candidates that any tool has to work through.
Two government sources describe the commercial pattern around recovery offers. The Federal Trade Commission's guidance on refund and recovery scams says: "Did someone contact you and ask for an upfront fee? That's a scammer." and "Never pay upfront for a refund or help with a refund." The FBI's Internet Crime Complaint Center warned on July 20, 2026 (alert I-072026-PSA): "IC3 will never ask for payment to recover lost funds, nor will IC3 refer someone to a company requesting payment for recovering funds." Both documents concern unsolicited offers made to people who have already lost money in a fraud; neither addresses a forgotten seed word, and applying them to one is an inference, not a quotation. What they establish is the upfront-fee pattern, and the arithmetic above establishes the other half, which is that the thing such offers ask for is the secret that controls the funds.
The one rule this article states outright follows from those numbers: a real phrase, or any part of one, does not go into a website, a message or a form. The tool and the checks in this article were run only on public test vectors. For the stages of the recovery-offer script and the free channels for reporting, see the guide to crypto recovery services and the second scam, and for reporting a loss, where to report a crypto scam. For backing up a phrase so that no word goes missing in the first place, the seed phrase backup and recovery checklist covers the practical side, and the cold wallet comparison covers how devices store and display recovery words. If a wallet has already been emptied, start with what to do after a wallet is drained.
Frequently Asked Questions
I forgot one word of my 12-word seed phrase. How many possibilities are there?
If you know which position is missing and the other eleven words are correct and in order, there are 2,048 words that could fill it and about 128 that pass the BIP-39 checksum. If the missing word is the last one, the count is exactly 128. If it is any other position, it averages 128 and varied from 104 to 158 across the official test vectors. Which of the candidates is yours has to be settled by a known address or balance.
Is a 24-word phrase easier or harder to repair than a 12-word one?
For one to three missing words with known positions, a 24-word phrase leaves 16 times fewer candidates, because its checksum is 8 bits and not 4. With unknown positions, the 24-word phrase leaves fewer candidates for one to three missing words and more from four upward, since the number of places the gaps can occupy grows faster than the checksum advantage. If the order of all words is lost, 24 words are vastly worse: about 2.4 × 10^21 arrangements pass the checksum against about 29,937,600 for 12 words.
Does a passphrase change how many words can be missing?
No. The checksum is computed from the words only, so a passphrase leaves the candidate count unchanged. It does change what each candidate produces: every passphrase gives a valid, different seed, so a wrong or forgotten passphrase looks like an empty wallet with no error, and the passphrase half of a search is not filtered by any checksum.
Is 12 words enough, or do I need 24?
The arithmetic gives one fact to weigh: guessing a randomly generated 12-word phrase takes about 2^128 tries, and the keys derived from either length are credited with about 128 bits of security by key size, according to BIP-32 and NIST SP 800-57. It does not decide the question. The choice also depends on device support, how the backup is stored and handled, and personal circumstances, none of which this arithmetic covers.
Can I check my own phrase with the script in this article?
The script was run only on public test vectors and the article does not publish it as a tool for real phrases. The six-step test above shows what any checksum checker computes. Entering a real phrase, or most of one, into any website, or into software whose handling of it cannot be verified, exposes the keys; this article states that rule because the counts above show that 11 of 12 words leaves only 128 candidates.
Do these counts apply to every wallet's recovery phrase?
No. They apply to BIP-39 phrases built from the English wordlist. Electrum documents that it does not generate BIP-39 seeds, and its native phrases use a version-number check instead of a BIP-39 checksum. SLIP-39 backups, non-English wordlists and other formats are separate schemes, and the counts here do not carry over to them.
Are recovery services that ask for my seed words legitimate?
The sources cited here do not address that case directly. They say that unsolicited upfront-fee offers to fraud victims are scams (FTC) and that the FBI's IC3 never asks for payment or refers anyone to a paid recovery company (IC3). The arithmetic shows that giving all but one or two words to anyone is nearly equivalent to giving the whole phrase, so the rule stated above applies: a real phrase, or any part of one, is not given to anyone who asks for it by message, website or form.
Arithmetic and background, not security, investment, tax or legal advice. Nothing here recommends any wallet, tool, service or phrase length. All phrases shown are public BIP-39 test vectors and must not be used to hold funds. Figures were computed from the BIP-39 text and wordlist on GitHub (bitcoin/bips) and the official test vectors, and checked on November 3, 2026.
Sources
Primary documents, market context, and methodology references behind this article.
Entropy and checksum table, 11-bit word indexes, PBKDF2 seed derivation with optional passphrase, shortcomings list, motivation text. Status Deployed. Checked November 3, 2026.
2,048 words, sorted, unique four-letter prefixes; every candidate count uses this list. Checked November 3, 2026.
The file linked from the BIP-39 Test vectors section; 24 English vectors, passphrase TREZOR. Test data only. Checked November 3, 2026.
secp256k1 curve; produced keys are 256 bits long and offer about half of that in security. Checked November 3, 2026.
May 2020. Table 2: ECC key size f = 256 to 383 at 128-bit security strength, and the quantum-computing note. Checked November 3, 2026.
States that Electrum does not generate BIP39 seeds and describes its version-number check. Checked November 3, 2026.