What is a bit of password entropy?

A bit of password entropy is one yes-or-no question that, on average, splits the space of possible passwords in half. A password with 30 bits of entropy is one of roughly two-to-the-thirty (about 1 billion) equally likely passwords. More bits means more guesses an attacker must try before finding yours, which is why bits are the honest, math-based measure of password strength.

How many bits of entropy does a strong password need?

For most accounts, 50 to 60 bits is a sensible minimum against online attacks. For anything sensitive, or for passwords stored in offline hashes that attackers can crack at blazing speed, aim for 70 to 80 bits or more. A random 16-character password from a good generator typically lands around 75 to 105 bits, depending on the character set used.

Does password length or complexity matter more for entropy?

Length matters more than complexity, because every character you add multiplies the number of possibilities, and each extra character adds roughly 4 to 7 bits depending on the character set. Complexity (adding symbols and uppercase letters) adds roughly the same amount of bits as adding one or two characters, so a longer passphrase full of random lowercase words is usually stronger than a short password stuffed with symbols.

How can I calculate my password's entropy?

For a truly random password, multiply the size of the character set by itself once per character: entropy (in bits) = length x log2(character set size). For example, a 12-character lowercase password is 12 x 4.7 = 56 bits. For passphrases, entropy = log2(word list size) x number of words. Six words from a 7,776-word list (Diceware) gives about 77 bits.

Is password entropy the same as password hashing?

No, they are different layers. Entropy measures how hard a password is to guess. Hashing describes how a website stores it after you set it. A high-entropy password still leaks if the site stores passwords in plaintext or weak, fast hashes, and strong hashing cannot rescue a very weak password. You need strong randomness when the password is made, plus strong hashing and good storage when it is kept.

← Back to Blog

Password Security

Password Entropy Explained: What a Bit Really Measures

Q: Does a 64-bit password mean 64 characters?

No. A 64-bit password means the generation process has roughly 2^64 (about 18.4 quintillion) possible outcomes. With a 94-character alphabet that's only about 10 random characters. Counting characters instead of possibilities is one of the most common password-entropy misconceptions.

August 27, 2026·13 min read·BetterPass Security Team

Illustration of dice and password characters representing a password's entropy measured in bits

Everyone has seen those password-strength meters that glow green, yellow, or red, and most people have watched a password generator bragging that it made something with "128 bits of entropy." But what does that number actually mean?

Ask ten people and you'll get ten fuzzy answers: "It's a measure of complexity," "It's how random it is," "It's the strength score." Those are true in spirit but annoyingly vague. If you want to think clearly about password security—and stop trusting gut feelings about whether your password is "good enough"—you need to understand the one idea underneath all of it: entropy, measured in bits.

This article is a plain-English tour of what a bit really measures, why it's the only honest number on a password meter, and how to use it to build passwords that genuinely survive the cracking rigs used in 2026.

What Is a Bit, Really?

The word "bit" is short for binary digit, and technically it's just a 0 or a 1. A computer stores a bit as one of those two values. But when security people talk about password entropy, they're using "bit" to mean something richer than that. They're using it as a unit of uncertainty—an information-theory idea borrowed from Claude Shannon's landmark 1948 paper.

Here's the intuition. Imagine I'm hiding a coin under one hand and I ask you to guess which one. You have two equally likely options. Knowing the answer tells you 1 bit of information: it was left, or it was right. If I flip a coin twice and ask you to guess the sequence, there are 4 options, and you need 2 bits to describe the outcome (00, 01, 10, 11). Three coins, 8 options, 3 bits. Every bit doubles the number of possibilities.

So the definition we actually use is this:

A password's entropy in bits is the number of yes-or-no questions it takes, on average, to guess the password when you know nothing about it except how it was generated.

A password with N bits of entropy is one of roughly 2^N equally likely passwords. An attacker who has to try them one by one will need, on average, 2^(N-1) guesses before landing on yours—about half the total, since luck is involved.

That's why bits matter so much: they translate directly to work an attacker has to do. Every extra bit doubles the difficulty. Going from 20 to 23 bits makes a password 8 times harder to crack. That's the real reason security experts obsess over this one number.

Bits Are About How a Password Was Made, Not What It Looks Like

This is the part that trips everybody up, so let's sit with it.

The exact string "Tr0ub4dor&3" and the exact string "correcthorsebatterystaple" each have a fixed number of characters, but entropy isn't a property of the characters themselves. It's a property of how the password was chosen—the process, not the product.

Think about it this way. I could hand you a six-character password like "d4Xb#2". You can't tell by looking whether it has 35 bits of entropy (six random characters from a big set) or 5 bits (it's just "passw1" with the first letter capitalized and a digit tacked on). The characters are identical either way. The difference is the randomness that went into choosing them.

This is why the old advice to just "use a mix of uppercase, lowercase, numbers, and symbols" is dangerously incomplete. It's entirely possible to satisfy every complexity rule and still pick a password with almost no entropy:

Password123! — satisfies every rule, but it's a pattern an attacker will try in the first minutes of a crack.
Abcdefg1@ — sequential letters with a digit and symbol appended.
!iloveYou23 — a common phrase with a swap.

An attacker doesn't need to brute-force character by character. They use word lists, leaked-password dictionaries, and mutation rules that churn through every obvious obfuscation. A "complex-looking" password built from a guessable pattern collapses under that. Its apparent structure is irrelevant—only the actual randomness matters, and the bits are how we measure that randomness.

One more way to feel the divide: the exact same string can have wildly different entropy depending on where it came from. Take x7Q!m2L#9P. If a random generator produced it, an attacker has essentially no information about why those characters were chosen—plenty of bits. If a person made it by starting with their dog's name and swapping letters for numbers, an attacker who knows that habit can model it and gut most of the uncertainty. The characters are identical; the entropy is not. Entropy belongs to the generator, not to the visible string.

Theoretical Entropy vs Effective Entropy

This split deserves its own spotlight, because it's the single most important idea for actually protecting yourself.

Theoretical entropy is the number the formulas give you if you assume every character was picked at random from a known set. It's an upper bound—the best case.

Effective entropy is what the attacker actually faces in the real world: the number of guesses a smart attacker, armed with dictionaries and mutation rules, realistically has to try.

Here's where the gap gets uncomfortable. Take a password that looks complex on paper:

Summer2024!

Count it against the rules—uppercase, lowercase, digits, symbol, ten characters—and a naive calculator might cheerfully estimate 60+ bits. But it's built from a common word, a predictable year, and the most overused "special character" at the end. A cracker's first few minutes of rules hit this pattern, putting its effective entropy far lower—often around 20 bits or less.

That's why security pros say complexity rules chased by humans create a false sense of security. The rules don't fight the actual attack; they just make people decorate guessable cores with predictable trinkets.

How to Estimate Entropy (and Why It's an Estimate)

Here's the honest truth you rarely read on password blogs: you can't compute "the" entropy of a password from the string alone. You can only estimate it, and the estimate depends on a model of how the password was generated. But for randomly generated passwords, the math is beautifully simple.

Random character passwords

When a password is made by picking each character independently at random from a known character set, entropy is:

entropy (bits) = length × log₂(character set size)

The log₂ just means "count in powers of two." Here are the common values:

Character set	Size	Bits per character
Digits (0–9)	10	3.3 bits
Lowercase only (a–z)	26	4.7 bits
Lowercase + digits	36	5.2 bits
Uppercase + lowercase	52	5.7 bits
Uppercase + lowercase + digits	62	6.0 bits
All 95 printable ASCII characters	95	6.6 bits

So a 12-character random lowercase password is about 56 bits, and a 16-character random ASCII password is about 105 bits. Notice how much the length does the heavy lifting there. Play with different lengths and character sets in BetterPass's Entropy Calculator to see how quickly random characters stack up into billions of possibilities.

Passphrases

For a passphrase built from random words, the model is different:

entropy (bits) = log₂(word list size) × number of words

The classic Diceware list has 7,776 words (6^5), so log₂(7776) is about 12.9 bits per word. Six random Diceware words:

6 × 12.9 = 77 bits

That's a genuinely strong passphrase, and it's usable because it's built from real words you can type and remember. The randomness is what makes it strong, not the weird characters. If you want one without the hassle, the Passphrase Generator builds random, Diceware-style passphrases locally in your browser.

Why "estimate"?

These formulas assume each choice is independent and truly random, drawn from a known set. The moment a human joins the decision-making, all bets are off. People are terrible random number generators. Given the choice, we pick "correcthorse" over "zx7!mQp" because it's memorable—and the predictability we add is exactly what an attacker's word lists are built to exploit.

So the formula gives a fair number for machine-generated passwords, and it's a generous upper bound for anything a human picked. That gap is why every reputable password generator hands you a random string and lets the math speak for itself.

How Many Bits Should Your Password Have?

There's no single "right" number, because it depends on the threat. But two broad situations cover most of your daily life.

Online attacks: the casual guesser

When an attacker tries to log in normally against a website's login form, they're limited. Site-side rate limiting, lockouts, and CAPTCHAs cap an online attack at maybe a few hundred guesses per account. Against that, anything over 50 to 60 bits is effectively uncrackable online. Even a modest random password walks past this threat.

This is why a random 12-character password feels like such a win for the normal person: it's already far beyond what an online attacker can brute-force by hand.

Offline attacks: the database breach

The dangerous scenario is the one people underestimate: a website gets breached, the password database leaks, and the attacker now has the hashes and can crack them on a GPU rig with no rate limiting whatsoever.

Modern hardware is staggering. A single high-end graphics card can attempt billions of hash guesses per second for fast algorithms like MD5 or SHA-1. At, say, 10 billion guesses per second, a 40-bit password (about 1 trillion possibilities) survives only ~100 seconds. A 50-bit password lasts hours. Even at 60 to 70 bits, a determined attacker with a big botnet and many days can chew through candidate space.

The defense is twofold, and this matters more than any single number:

Let the site hash your password with a slow, memory-hard algorithm like bcrypt, scrypt, or Argon2id. These slow the attacker down by many orders of magnitude, turning billions of guesses per second into millions or less. That's why BetterPass and modern services use them.
Use a password manager so that even if the site's hashing is weak (many legacy sites still use fast, ancient schemes), your password is a fresh, high-entropy random one that the word lists and mutation rules never get near.

So the practical guidance for 2026:

Situation	Recommended entropy
Everyday online accounts	50–60 bits minimum
Sensitive accounts (email, banking, cloud)	70–80+ bits
Password manager master password	80+ bits
Offline-stored, possibly-weak-hash scenarios	80+ bits

Decode what "a 64-bit password" actually means while you're at it. A 64-bit password does not mean 64 characters. It means the generation process has roughly 2^64 possible outcomes—about 18.4 quintillion. With a 94-character alphabet, that's only about 10 random characters. So a random string can hit 64 bits in a short line, while a hand-made 64-character sentence might still have tiny effective entropy because its "randomness" collapsed. Count possibilities, not characters.

A rule of thumb that does the work for you: let a good generator make random passwords that are 16+ characters for anything you care about, and turn on two-factor authentication wherever it's available. 2FA is not entropy, but it's the one thing that makes an even leaked password nearly worthless by itself. And if an account has already been caught up in a breach, check your email with the Breach Checker and rotate the password immediately.

Entropy Is Not Random-Looking, and It's Not Hashing

Two more confusions tend to blur the picture, and clearing them up removes the last excuses for weak passwords.

"Random-looking" is not random

A string that appears chaotic isn't automatically secure. The only thing that matters is how it was produced. If an app generates a password using something like JavaScript's Math.random()—designed for casual use, not security—an attacker who knows that flow may be able to reproduce the value. Security tools instead use a cryptographically secure random number generator (in browsers, the Web Crypto API) whose output no one can predict. In other words: the visual noise of Q7xP2mL9zK4r is decoration. The source of that string is the security.

Entropy and hashing are different layers

Entropy measures how hard a password is to guess. Hashing describes how the site stores it after you set it. A high-entropy password still leaks if the application keeps passwords in plaintext or weak, fast hashes (MD5, SHA-1). And the strongest hashing in the world can't rescue a 15-bit "Summer2024!" once the database is in an attacker's hands. You need both: strong randomness when a password is made, and strong hashing plus your own vault when it's stored. They solve different problems, and they never cancel each other out.

Common Entropy Myths, Gently Destroyed

Once you understand bits, a lot of popular password folklore falls apart on its own. Let's knock down the biggest ones.

"Complexity rules are what make a password strong"

Partly true, but leaned on far too hard. Adding special characters raises bits per character from, say, 6.0 to 6.6—less than one extra bit. Adding one random character to a password does the same work. Yet complexity rules push people toward short, weird, unforgettable strings like P@ssw0rd! that are actually more guessable, because the "obvious obfuscation" is exactly what crackers automate first. Length beats complexity every time.

"My birth year and my dog's name made it a strong password"

No. Fluffy2012 may look random to you, but it's semantically predictable and nearly worthless in bits. A human-chosen "random-looking" string is the single most cracked thing there is, because attackers already have gigantic lists of pet names, years, and l33t-speak variations.

"A password with more entropy is impossible to remember"

This is a false trade-off once you embrace managers and passphrases. You don't need to remember 12 random characters—your password manager does that for you. And for the handful of things you do memorize (like the master password), a random passphrase gives you goosebumps-inducing entropy and memorability at once. You get both, not one or the other.

"Random-looking and a CSPRNG are the same thing"

Close, but no. A string that looks scrambled isn't automatically secure; only the source of that string is. Security software uses a cryptographically secure random number generator, not the casual randomness used for animations or shuffling. Always reach for a tool that uses a trustworthy, local random source (like the browser's Web Crypto API) when a generator claims to create passwords for you.

"Every password needs 100+ bits"

Nope. That's overkill for routine online accounts where rate limiting already protects you. Save the brute-force-grade entropy (80+ bits) for things like your password manager and high-value accounts that could end up in a leaked, poorly-hashed database.

How to Actually Get High Entropy in Real Life

Understanding the math is 20% of the battle. The other 80% is putting it to work. Here's the concrete playbook.

Start with a password manager. This is non-negotiable if you want a unique, high-entropy password everywhere without losing your mind. One strong master password to unlock, and it generates and stores a fresh random password for every single account. It also fills them on the correct site, which quietly defends against phishing too. Once it's in place, verify your existing credentials hold up with the Strength Checker so you can spot the weak links you thought were fine.

Generate, don't compose. Let a tool that uses a cryptographically secure random number generator build your passwords. Randomly generated strings are the only place the entropy formula is honest. BetterPass's Password Generator is built on your browser's Web Crypto API and runs locally—letting you configure length and character sets and producing genuinely random output.

Prefer passphrases for things you must remember. For the small set of passwords you'll actually type from memory, pick 5–6 random words and let the word-list math (about 13 bits per word) do the work. Six words equal roughly 77 bits of entropy that you can actually recite. Avoid real-world-producible phrases and don't pick the words yourself—let a diceware-style generator choose them randomly.

Turn on two-factor authentication. It's not entropy, and it won't replace a strong password, but it's the single highest-leverage habit you can add, and it neutralizes leaked passwords in a way no entropy score can.

The Bottom Line

A bit of password entropy is a unit of hide-and-seek difficulty—the number of yes-or-no questions an attacker must, on average, answer before landing on your password. Every bit doubles the work. And the number is rooted in how your password was generated (randomness), not how it looks (complexity).

Here's the version worth remembering for the rest of your life:

More bits = exponentially harder to crack.
Length adds more practical bits than fiddling with symbols.
Randomly generated beats "complex-looking" every single time.
A manager + random passwords + a passphrase master + 2FA covers the real-world threats better than obsessing over a single score.

Next time a password meter flashes a bit count at you, you'll know exactly what it's claiming: the number of times an attacker has to split the possibility space in half before they find you. Choose your passwords the way the math wants you to—randomly, through a generator, saved in a manager—and let the bits fall where they may.

Ready to put this into practice? Create random credentials with the Password Generator, build a memorable master phrase with the Passphrase Generator, and see how many bits your current passwords are hiding with the Entropy Calculator.