Entropy is a measure of surprise
When security people talk about a password’s entropy, they mean its unpredictability, measured in bits. One bit of entropy represents one yes/no guess — a coin flip. A password with n bits of entropy is as hard to guess as picking the right answer out of 2ⁿ equally likely possibilities. Eight bits means 256 possibilities; forty bits means about a trillion. Because the scale is exponential, each additional bit doubles the difficulty. That single fact explains almost everything about password strength, and it’s what the Password Strength Meter puts front and centre.
The formula
Entropy for a password drawn uniformly from a character set is wonderfully simple:
entropy (bits) = length × log2(pool size)
The pool size is how many different characters you could have used at each position. Lowercase letters give 26. Add uppercase and it’s 52. Add digits, 62. Add common symbols, around 95. The length is how many characters you actually used. Multiply length by the base-2 logarithm of the pool and you have the entropy.
A worked example makes it concrete. A ten-character all-digit PIN-like password has a pool of 10, so its entropy is 10 × log2(10) ≈ 33 bits. A twelve-character password using all four classes has 12 × log2(95) ≈ 79 bits. The second isn’t twice as strong — it’s roughly 2⁴⁶ times stronger. The Password Strength Meter computes this for you and also shows the keyspace as a power of ten so you can see just how astronomically the numbers grow.
Why length beats complexity
People instinctively reach for symbols and number substitutions (“p@ssw0rd”) to feel secure. But look at the formula: swapping a letter for a symbol only widens the pool slightly, while adding a character multiplies the keyspace by the whole pool again. Length is exponential; complexity is incremental.
This is the mathematical case for passphrases — several random words. They reach high entropy through length while staying memorable. The Password Strength Meter makes the comparison vivid: type a short cryptic password and a longer passphrase and watch the bits and crack time. The passphrase almost always wins. If you’d rather generate something maximally random, the Password Generator produces high-entropy strings directly, and the rule-based Password Strength Checker gives a quick checklist verdict.
Crack time is about the attacker, not just the password
Entropy tells you the size of the haystack. Crack time tells you how fast someone can search it — and that depends entirely on the attacker. This is why the meter shows five scenarios rather than one number:
A throttled online attack against a live login is slow — perhaps a hundred guesses a second before rate limits and lockouts kick in. An unthrottled online attack against a poorly built service might manage a million. An offline attack against stolen password hashes is far worse: if the site stored passwords with a slow hash like bcrypt, an attacker might do ten thousand guesses a second; if it used a fast hash, a single GPU does tens of billions, and a dedicated array reaches trillions.
The lesson is sobering and useful: a password that is perfectly safe against an online attack can fall in hours once a database is breached and the hashes are offline. That’s why the same string shows wildly different times across the meter’s scenarios, and why high entropy matters most — it’s the only thing that keeps you safe in the worst case. The mechanics of these attacks are detailed in our brute-force attack explainer.
Reading an entropy meter sensibly
An entropy meter is a model, and like all models it makes assumptions. It assumes your characters are chosen randomly; a password that technically has 60 bits “by the formula” but is actually a dictionary word with predictable substitutions has far less real entropy, because an attacker won’t search blindly — they’ll try likely patterns first. Treat the meter’s number as an upper bound on strength for a truly random password, and lean on good habits to make sure your password really is unpredictable. For those habits, see how to create a strong password.
A worked comparison
It helps to see the numbers on real examples. Take P@ssw0rd1 — nine characters, all four classes, so a pool of about 95 and roughly 59 bits of entropy “by the formula”. That sounds respectable until you remember the meter’s caveat about randomness: this is a dictionary word with predictable substitutions, so a real attacker’s effective search is far smaller than 59 bits suggests. Now take a four-word passphrase like river-cabinet-orbit-thistle — 27 characters from a pool of about 28 (lowercase plus the dash), giving roughly 130 bits, and because the words are random there’s no predictable pattern to shortcut. The Password Strength Meter will show the passphrase saturating the 0–100 score while the cryptic password lands mid-range.
The lesson the meter teaches, again and again, is that length plus genuine randomness beats clever-looking complexity. Two short passwords with the same character classes can have wildly different real-world strength depending on whether they’re memorable patterns or true randomness. When you want maximum entropy without thinking about it, generate the password with the Password Generator and paste it back here to confirm the bits, then store it in a manager so length is never a memorisation burden. For the everyday rule-of-thumb version of this advice, the Password Strength Checker gives a quick checklist verdict.
The takeaway
Entropy — length times the log of the character pool — is the cleanest single measure of how hard a password is to guess, and every extra bit doubles the work for an attacker. Crack time then depends on how fast that attacker can guess, which is why it ranges from instant to millions of years across threat models. Use the Password Strength Meter to see the actual bits, the keyspace, and the full crack-time spread, favour length over cleverness, and make sure your characters are genuinely random so the math reflects reality.