Password Entropy Calculator
Estimate password strength in bits of entropy under chosen length and character-set assumptions — useful when judging brute-force resistance (assuming random character selection).
Results
Enter data and click Calculate.
What password entropy means
Password entropy is the number of bits describing how much "uncertainty" (randomness) a password carries against a guess-and-check attack. Higher entropy means more possible combinations to search through — it is the standard strength measure used in cryptography and security guidance (e.g. NIST SP 800-63B).
Formula: bits and keyspace
The calculator computes entropy as H = L × log₂(N), where L is the password length and N is the number of possible characters in the set. The full keyspace is N^L — too large a number to display directly, so we show its base-10 logarithm instead (log₁₀(N^L) = L × log₁₀ N).
Character set sizes
| Set | Character count (N) | Bits per character (log₂N) |
|---|---|---|
| Lowercase a-z | 26 | ~4.70 |
| Lowercase + uppercase | 52 | ~5.70 |
| Alphanumeric (a-zA-Z0-9) | 62 | ~5.95 |
| Full ASCII (with special characters) | 95 | ~6.57 |
Entropy vs brute-force time
- Each extra bit of entropy doubles the number of combinations to search — entropy grows far faster than the raw password length.
- Real-world crack time depends heavily on how the password is stored: a fast hash (MD5, unsalted SHA-1) can be checked billions of times per second on a GPU, while a slow hash (bcrypt, scrypt, Argon2) is thousands of times slower to attack.
- Entropy is an upper bound on offline attack difficulty; an online attack (via a login form) is usually far slower thanks to rate limiting and account lockouts.
Human-chosen passwords are weaker than random
This formula assumes each character is chosen uniformly at random. In practice, people pick dictionary words, common substitutions (a→@, o→0), and patterns (a year, a name plus digits) — the real entropy of such a password is much lower than this calculator’s output. That is why a passphrase built from several random words can be practically stronger than a short "random-looking" password.
Examples
- 8 characters, lowercase only (26) → about 37.6 bits — crackable offline in a reasonable time.
- 12 characters, full ASCII (95) → about 78.8 bits — strong with proper password hashing.
- 16 characters, alphanumeric (62) → about 95.3 bits — very strong, comfortable safety margin.
FAQ — password entropy
- How many bits of entropy is "enough"?
- For online accounts with reasonable rate limiting, 60–70 bits is usually enough against online guessing. Offline attacks (stolen hashes) need higher values plus slow hashing. Entropy is only one piece: reuse, leaks, and MFA often matter more than a few extra bits.
- Does this calculator check if my password was leaked?
- No — it only computes theoretical entropy from length and character set. Checking breach databases (e.g. HaveIBeenPwned) is a separate, important control.
- Is a longer password always better than a more complex one?
- Usually yes — adding characters to the length increases entropy more than widening the character set at the same length.
- How do I set a custom character set?
- Choose "Custom character count" and enter your alphabet size, e.g. 16 for hex, 10 for digits only.
- How is this different from the hash collision calculator?
- This one measures password strength (how many guesses are needed to find it). The collision calculator measures the probability that two different inputs produce the same hash — a different problem.
- Is a multi-word passphrase better than random characters?
- It can be practically stronger and easier to remember — 4-6 truly random dictionary words give solid entropy, as long as the words are genuinely random (not a meaningful sentence).
- Why does a human-chosen password get an entropy that seems too high?
- Because the formula assumes full randomness. Real human-chosen passwords have much lower effective entropy — attackers check dictionaries and common patterns first.
- How does entropy relate to password hashing (bcrypt/Argon2)?
- Entropy tells you the worst-case number of guesses needed. A slow hash with an appropriate cost factor multiplies the time per guess, so together they give the real time needed to crack it.