Entropy in Passwords: What the Number Actually Means
Learn what password entropy is, how it is calculated, why higher entropy makes passwords harder to crack, and what the numbers actually mean in real-world security.
Password strength calculators often display a number called entropy. You might see messages such as “40 bits of entropy,” “80 bits of entropy,” or “128 bits of entropy.” For many people, these numbers are confusing. Is 80 good? Is 128 overkill? How does entropy relate to password length? And why do security professionals care about it so much?
Understanding password entropy helps explain why some passwords can be cracked almost instantly while others would take longer than the age of the universe.
What Is Password Entropy?
Password entropy is a measurement of unpredictability. In simple terms, entropy estimates how difficult it would be for an attacker to guess a password. It’s the same underlying idea used to describe how large a key space is in AES-128 versus AES-256: more bits means more possible combinations to search through.
Higher entropy means more possible password combinations, less predictability, and greater resistance to guessing attacks. Lower entropy means fewer possible combinations, more predictability, and easier password cracking.
Entropy is typically measured in bits. Each additional bit doubles the number of possible password combinations.
Why Is It Called Entropy?
The term comes from information theory, where entropy measures uncertainty. A completely predictable outcome has low entropy. A completely random outcome has high entropy. Passwords follow the same principle.
Consider password123, qwerty, and letmein. These passwords are highly predictable, attackers know people use them frequently, so their practical entropy is extremely low.
Now compare them with vK8#rP2!mZ4@tQ9. This password is far less predictable. An attacker has many more possible combinations to consider, so its entropy is much higher.
How Password Entropy Is Calculated
The basic entropy formula is:
Entropy = log₂(possible combinations)
Most password entropy calculations use:
Entropy = Length × log₂(Character Set Size)
The calculation estimates how many possible passwords could exist given the length and available character choices, condensing that space down into a single comparable number in much the same way a checksum condenses an entire file down into a single value.
Example: Four-Digit PIN
A four-digit PIN can contain any value from 0000 through 9999, creating 10,000 possible combinations. Entropy becomes log₂(10,000), approximately 13.3 bits. A four-digit PIN has about 13 bits of entropy.
Example: Eight Lowercase Characters
Suppose a password contains only lowercase letters. The available character set is 26, and the password length is 8, giving 26⁸ possible combinations, approximately 208 billion. Entropy is 8 × log₂(26), approximately 37.6 bits.
Example: Sixteen Random Characters
Suppose a password uses uppercase letters, lowercase letters, numbers, and symbols. That gives a total character set of 94. At a password length of 16, entropy is 16 × log₂(94), approximately 105 bits. This is dramatically stronger than the previous example.
It’s worth noting that this only holds if the characters are genuinely randomly chosen from that full set, the same requirement that makes an encoding scheme like Base64 or hex predictable in its own way: both are just systematic ways of representing an underlying value using a fixed alphabet, and neither adds randomness on its own.
Why Every Extra Bit Matters
Entropy grows exponentially. Each additional bit doubles the search space.
| Entropy | Possible Combinations |
|---|---|
| 20 bits | 1 million |
| 30 bits | 1 billion |
| 40 bits | 1 trillion |
| 50 bits | 1 quadrillion |
| 60 bits | 1 quintillion |
| 80 bits | 1.2 septillion |
| 128 bits | 340 undecillion |
This is why small increases in entropy can have enormous security impacts.
The Problem With Entropy Calculators
Many entropy calculators assume passwords are completely random. Humans are not random.
Consider Summer2026!. A calculator may assign a relatively high entropy score because the password contains uppercase letters, lowercase letters, numbers, and symbols. However, humans frequently create passwords using predictable patterns, and attackers know this. Real-world cracking tools prioritize dictionary words, seasons, years, common substitutions, and keyboard patterns. As a result, actual security may be much lower than the calculated entropy suggests.
The Difference Between Theoretical and Real Entropy
This distinction is important.
Theoretical entropy assumes every character was chosen randomly. For a password like xR7#Lm2@Q9$KpW5!, theoretical entropy is usually accurate.
Human-generated passwords, like Summer2026!, are different. The calculation may suggest strong entropy, but actual predictability is much higher, which reduces real-world security.
Why Password Length Matters So Much
Many people focus on complexity requirements, but security professionals increasingly focus on length instead, a shift reflected directly in NIST’s digital identity guidelines, which now emphasize length over forced complexity rules.
Compare P@ssw0rd! with correct horse battery staple. The second password contains more characters and far more possible combinations despite being easier to remember. Length often contributes more entropy than adding special characters, which is one reason passphrases have become increasingly popular.
Password Entropy and Passphrases
Passphrases work differently from random character strings. Consider a list of 7,776 words. Choosing four random words creates 7,776⁴ possible combinations. Entropy is 4 × log₂(7776), approximately 51.7 bits. Using five random words gives roughly 64.6 bits, and six random words gives roughly 77.5 bits.
This provides substantial security while remaining easier to remember.
What Entropy Is Considered Secure?
There is no universal threshold, but common guidelines are:
| Entropy | Security Level |
|---|---|
| Under 30 bits | Weak |
| 30–50 bits | Moderate |
| 50–70 bits | Strong |
| 70–100 bits | Very Strong |
| 100+ bits | Extremely Strong |
Modern password managers often generate passwords with well over 100 bits of entropy.
Online Attacks vs Offline Attacks
Entropy matters differently depending on the attack type.
Online attacks happen when the attacker submits login attempts directly. Systems usually enforce rate limits, account lockouts, and CAPTCHA challenges, so even moderate entropy may provide sufficient protection.
Offline attacks happen when an attacker obtains password hashes and attempts cracking locally. No rate limits exist, and attackers can perform billions of guesses per second using specialised hardware. High entropy becomes far more important here, and most password entropy discussions focus on resisting offline attacks specifically.
Does More Entropy Always Mean Better Security?
Generally yes, but only up to a point. A password with 180 bits of entropy is stronger than one with 120 bits, but both are already beyond practical brute-force capabilities. At some point, additional entropy provides little practical benefit, in much the same way that stacking certificate chains three or four levels deep doesn’t meaningfully add trust once one solid link back to a root already exists.
Other security measures become more important at that point, including multi-factor authentication, password managers, account monitoring, breach detection, and access controls.
Why Password Managers Change Everything
Humans struggle to create and remember truly random passwords. Password managers remove this limitation. Instead of remembering something like vK8#rP2!mZ4@tQ9 for dozens of websites, users only need to remember one master password. The manager can generate high-entropy passwords automatically, which dramatically improves security across all accounts, a practice both OWASP’s Authentication Cheat Sheet and most modern security guidance recommend over expecting users to invent strong passwords manually.
Common Misconceptions About Entropy
Special characters automatically make passwords strong. Not necessarily. Length and unpredictability matter more than symbols alone.
Complex passwords are always better. A longer random passphrase may provide greater security than a short complex password.
Entropy measures real security perfectly. Entropy estimates possible combinations. Human behaviour often reduces actual security.
Entropy is only about length. Length helps significantly, but randomness is equally important. Predictable long passwords can still be weak.
Frequently Asked Questions
What is a good password entropy score? As a rough guide, under 30 bits is weak, 30 to 50 bits is moderate, 50 to 70 bits is strong, and anything above 70 to 100 bits is very strong to extremely strong. Most password managers generate passwords well above 100 bits by default.
Does adding a symbol always increase entropy more than adding a letter? Not necessarily. What matters is the total character set size and the length. A single extra character of any kind from a large set typically adds more entropy than swapping one character for a symbol within a fixed-length password.
Why do security experts now recommend passphrases over complex short passwords? Length tends to add more entropy than complexity does, and passphrases are dramatically easier for humans to remember accurately, which reduces the temptation to reuse or write down passwords. Four to six random words routinely lands between 50 and 80 bits of entropy.
Is a high-entropy password useless if I reuse it everywhere? Reuse undermines even a very high entropy password, since a breach at one site exposes the password everywhere else it’s used. Entropy protects against guessing attacks specifically, not against credential reuse after a leak.
Do password strength meters give accurate entropy scores? Often not for human-generated passwords. Most meters calculate theoretical entropy based on character variety and length, but they can’t fully account for predictable patterns like dictionary words, keyboard walks, or common substitutions, so real-world security is frequently lower than the displayed score suggests.
Conclusion
Password entropy measures how unpredictable a password is and how difficult it would be to guess through brute force. Higher entropy means more possible combinations and greater resistance to password cracking. Every additional bit doubles the number of possibilities an attacker must consider.
While entropy provides a useful way to compare password strength, it is only part of the picture. Human-generated passwords often contain predictable patterns that reduce real-world security, even when calculators assign high scores.
For most users, the best approach is simple: use a password manager, generate long random passwords, enable multi-factor authentication, and avoid relying on memorable patterns. Those practices provide far more protection than chasing a specific entropy number alone.
Written by the Workshelve team, who write practical explainers on data integrity, networking, and developer tooling.