ForgotWalletPassword.com

Tool · built on measured crack speeds, not guesses

What are your real recovery odds?

This calculator turns your password into two numbers that decide everything: how many possibilities exist, and how fast the best available hardware could check them. It uses measured crack speeds from the open-source btcrecover benchmark suite — not marketing figures.

By Robbert Bink · ~6 min read · Published 6 August 2026 · Last reviewed: 14 August 2026

Illustration of a balance scale weighing the odds of password recovery
Short answer

Two numbers decide your case: the size of the password space (character-set size raised to the password length) and the guesses-per-second rate your wallet format allows. An old wallet.dat is checked hundreds of times per second on a desktop CPU; a modern Ethereum scrypt keystore only around a hundred. Use the tool below to find where your password falls — and what that means.

10
Character types it would have contained

Entropy
Possible passwords
No hints — full brute force
With your clues

Fill in the fields above to get your verdict.

The password you type (or the shape you describe) is treated as a sample of the search space — the calculator estimates how long the space of similar passwords would take to check; it is not checking your actual password, which never leaves your browser. The clue reductions are deliberately conservative heuristics, not guarantees: “weak clues” narrows the space by a factor of 100, “good clues” by 10,000,000, “strong clues” by 100,000,000,000. Treat these clue reductions as rough examples, not predictions — real-world reduction depends on how specific, accurate and structured the clue is.

The measured speeds behind this calculator

Every rate in the dropdown comes from the official btcrecover performance benchmarks — the numbers the open-source recovery community actually measures, not advertises. “CPU” is a Ryzen 9 9950X (16 cores); “GPU” is an RTX 5090. Where a format is memory-hard (scrypt), GPUs gain little, which is why some rows show the CPU rate for both.

Wallet formatKey derivation (verified)Guesses/sec, CPUGuesses/sec, GPU
wallet.dat — low-round reference (~68k)iterated SHA-512 (EVP_BytesToKey)47211,950
wallet.dat — high-round reference (~267k)iterated SHA-512 (EVP_BytesToKey)1223,210
Ethereum keystore (scrypt)scrypt N=2¹⁸ (geth standard) · reference test N=2¹⁷96(no GPU result in the reference test)
BIP38 paper-wallet keyscrypt N=2¹⁴ r=8 p=87243 (GPU slower — CPU is the practical choice)
MetaMask vault — legacy 10kPBKDF2-SHA256 10k5,1605,590
Electrum 2.8+ passphrasePBKDF2-HMAC-SHA512 1k iterations; candidate verified by deriving keys (ECIES/BIE1)29,6704,300 (GPU slower — CPU is the practical choice)
BIP39 passphrasePBKDF2-HMAC-SHA512 2k iterations; candidate verified by deriving target addresses15,25019,950 (RTX 5090/OpenCL)
Blockchain.com — v0 exportPBKDF2-SHA1, 10 iterations627,580627,580 (CPU rate)
Blockchain.com — v2 exportPBKDF2-SHA1, 10,000 iterations2,7709,470 (RTX 5090/OpenCL; CPU 2,770)
Blockchain.com — v3 exportPBKDF2-SHA1, 5,000 iterations5,45020,030 (RTX 5090/OpenCL; CPU 5,450)
MultiBit Classic — .key backup3×MD51,810,0001,810,000 (CPU rate)
MultiBit Classic — .walletscrypt N=2¹⁴ r=8 p=1510510 (no GPU gain)
MultiBit HDscrypt N=2¹⁴ r=8 p=1510510 (no GPU gain)
Coinomi vaultscrypt N=2¹⁴ r=8 p=1503503 (no GPU gain)

wallet.dat rows use the measured btcrecover reference values (67,908 and 267,488 rounds on the reference wallets). All rows are published measurements from the btcrecover benchmark suite (Ryzen 9 9950X / RTX 5090, July 2026). The MetaMask row is the legacy 10,000-iteration vault — newer vaults store their own KDF parameters in the vault data (read the actual count; 600,000 and 900,000 are both documented), which can run up to roughly 90× slower per guess. These are point estimates — real hardware varies with driver, tool version and your file’s KDF parameters — so treat every result as an order of magnitude, not a promise. Hardware, method and dates are on the benchmarks & methodology page.

How the math works

  • Entropy = length × log₂(character-set size). Each bit doubles the work: a 10-character lowercase password is ~47 bits; a 16-character mixed password is ~100+ bits. The jump from “hard for a week” to “hard for the universe” happens around 80 bits.
  • Possible passwords = character-set^length. This is the search space — the number of guesses a blind attack would have to try.
  • Time = search space ÷ guesses per second. A low-round wallet.dat checked at 472 guesses/sec needs ~2×10²¹ seconds for a 12-character random password — compare that with the ~4.4×10¹⁷ seconds the universe has existed.
  • Clues shrink the space, not the speed. Remembering that the password began with your initials doesn’t make the GPU faster — it removes all passwords that don’t fit, which is worth orders of magnitude more. This is why memory reconstruction beats hardware.

What the calculator cannot tell you

  • Uncertainty. The output is one number from one benchmark run; the realistic range around it is usually “an order of magnitude either way”. Use it to separate minutes from months — not to bet on 4 hours vs 5.
  • Whether your memory is right. It models the password you give it — not the one you actually used. If you feed it a 16-character guess and your real password was 11, the verdict is wrong in the optimistic direction.
  • Hardware you don’t have. The rates assume hardware you can actually run offline. Cloud GPU rentals multiply the check rate — at a price.
  • Pattern-based shortcuts. Real attacks use wordlists, keyboard-layout masks and year lists that are far smaller than the full space. If your password is patterned (a name, a date, a habit), the estimate sits closer to the “with your clues” column than the brute-force one — read how offline tools actually work.
  • The difference between guessing and unlocking. A MetaMask password or a PIN gate may reset without any guessing — the calculator only models encryption that has to be broken offline.

If the math says impossible, that’s the real answer

A password with ~90+ bits of entropy cannot be brute-forced by anyone — not by a $500 online “service”, not by a lab with a server farm. You just ran the calculation most people skip. If your number lands in the impossible zone, that knowledge is your protection.

Next steps with your number

  • Fast to crack? Fix it now. If your verdict is minutes or hours, the priority is securing the wallet file and doing the 68-place search — your password is likely findable, and you want to be the one who finds it.
  • Reachable with clues? Invest in memory reconstruction, then run the numbers again with the better clue level.
  • Impossible? You now know the realistic range. Trust the math — anyone who claims otherwise is not doing real work.

Sources & references

  1. btcrecover — performance benchmarks
  2. BIP39 — mnemonic code for generating deterministic keys
  3. ethereum.org — Web3 Secret Storage (keystore specification)
  4. BIP38 — passphrase-protected private keys
Missing something, or spot an error? Tell us — every correction is checked and applied.
Was this guide helpful?

Keep going — it’s all free

Not sure what you lost or what’s possible?

Take the quick diagnosis for a first verdict — it stops early when the answer is already clear — then work the search checklist. Everything here is informative, runs offline, and is free to use.