How Strong Is Your Password? Entropy in Plain English

Every password strength checker speaks the same language: bits of entropy. It sounds like physics, but entropy is really just a way of counting how many guesses an attacker would need. A password with 50 bits of entropy has about 2 to the power 50 possible combinations - roughly 1.1 quadrillion. Double the bits and you do not double the work; you square it. This guide explains where the bits come from, shows the numbers for real generated passwords, and explains why the boring advice - make it longer - beats every clever trick. If you want to check a password of your own as you read, our Password Strength Estimator gives an instant estimate, locally in your browser.

The only formula you need

The pool is the set of characters each position is drawn from: 26 for lowercase letters only, more when you add capitals, digits and symbols. Log2 just converts the pool size into bits - a pool of 64 is exactly 6 bits per character, because 2 to the power 6 is 64. Every character you add multiplies the number of possible passwords by the pool size, which is why length is so powerful: with a pool of 73, each extra character makes the password 73 times harder to brute-force.

A concrete reference point: our Password Generator draws from a pool of 73 characters. That is a slightly unusual number, and it is deliberate - the generator leaves out look-alike characters (0 and O, 1 and l) so a password can be read aloud or typed from a screen without mistakes. Its pools are 23 lowercase, 24 uppercase, 8 digits and 18 symbols, so each character carries log2(73), about 6.19 bits. That gives:

• 8 characters - about 50 bits of entropy
• 12 characters - about 74 bits of entropy
• 16 characters - about 99 bits of entropy
• 20 characters - about 124 bits of entropy
• For comparison: an 8-character password using lowercase letters only (pool of 26, about 4.7 bits each) has only about 38 bits - the bigger pool is worth roughly 4,000 times more combinations at the same length.

What those bits mean in practice

Take the worst realistic case: an attacker has stolen a password database with fast, weak hashing and can test 10 billion guesses per second on specialised hardware. Against a truly random 50-bit password they must try about 1.1 quadrillion combinations - a day or so of non-stop guessing, less on average. That is uncomfortably close, which is why 50 bits should be treated as a floor, not a target. At 74 bits the same attacker faces about 60,000 years of work. At 99 bits the answer runs to more than a hundred times the age of the universe. The jump from "a day" to "forever" is only a handful of extra characters.

Two honest caveats. First, these figures assume your password was chosen truly randomly, character by character - human-chosen passwords are far weaker than their length suggests, which the next section covers. Second, entropy only defends against guessing. It does nothing for a password that was reused and leaked in someone else's breach, or typed into a phishing page. Strength is necessary; it is not sufficient.

Why length beats complexity tricks

Most human password strategies add far less entropy than people think. Swapping a for @ and o for 0 is the first thing cracking software tries - those patterns are in every rule set. Appending the current year, a ! at the end, or a favourite team name adds almost nothing, because attackers try those shapes first. What actually works is raw length with randomness in it: a 16-character random string from the generator has about 99 bits no matter how it looks, while a 'clever' 9-character construction a human invented may test in the 20s. Strength estimators know this, which is why ours estimates from length and pool size and then penalises repeats, sequences and common words - paste a password into the Password Strength Estimator and a pattern-heavy one scores far below what its length promises.

Passphrases: the other way to buy length

If you must memorise a password rather than store it, a passphrase is the practical route. Five words chosen truly at random from a large word list (the classic Diceware list has 7,776 words, worth about 12.9 bits each) give you roughly 65 bits - comfortably past the floor - in something a human can actually remember and type, like a string of unrelated everyday words. The catch is the word "random": words you pick yourself drift toward predictable phrases, song lyrics and quotes, all of which are in cracking dictionaries. Roll dice or use a generator to choose the words, and the maths holds.

What to actually do

• Generate, do not invent. Use the Password Generator at 16 characters or more for important accounts - that is about 99 bits, beyond any realistic brute-force attack.
• Make every account unique. Entropy cannot save a password that leaks from one site and gets replayed on another.
• Store them in a password manager so length and uniqueness cost you nothing to maintain.
• Keep one strong memorised passphrase for the manager itself, built from randomly chosen words as described above.
• Turn on two-factor authentication where it exists; it covers the cases - phishing and leaks - that entropy does not.

That is the whole subject, honestly: strength is counting, counting rewards length, and length is free when a machine does the remembering. Generate long, keep them unique, and the bits take care of themselves.