Password Entropy Calculator
This password entropy calculator shows you the entropy in bits and a rough estimate of how long it would take to guess, calculated entirely in your browser as you type — nothing is sent anywhere, logged, or stored, so it's safe to test a real password if you want an honest answer.
length × log2(character pool size), the same formula behind
NIST SP 800-63B's approach
to password strength, and everything runs client-side in your browser — the password you type is
never transmitted. On top of that raw number, this tool also checks the password against a list of
commonly breached passwords and for sequential runs, repeated characters, and keyboard-row patterns
(like "qwerty" or "1234") — the same category of check NIST's screening recommendation is built on
(see our breach-screening guide) and the kind of
pattern-aware check tools like Bitwarden's zxcvbn-based tester perform. If a pattern is found, the
displayed entropy is capped down to reflect that a pattern-matching attacker would try it early, regardless
of the character-class math. This still isn't a full linguistic/leetspeak analysis — a password like
"P@ssw0rd" won't be caught by the substring check the way "password" is — so treat a clean result
here as a reasonable signal, not a guarantee. The crack-time estimate assumes 10 billion guesses per
second, a commonly cited rough figure for a fast offline attack against an unsalted or weakly-hashed
password list. Real attack speed varies enormously depending on how a service actually stores passwords
(properly salted and hashed passwords are dramatically slower to attack), so treat the crack-time number
as illustrative, not exact. The "Check for known breaches" button works differently from everything else on
this page: it's the one feature here that isn't fully offline. It hashes your password (SHA-1) in your
browser, then sends only the first 5 characters of that hash to the
Have I Been Pwned Pwned
Passwords API and checks the response locally — the full password and full hash never leave your
device, but that one check does require a network request, unlike the rest of this page.
What entropy actually measures
Entropy, in bits, is a measure of how many possible passwords exist given a character pool and length — not how "random-looking" a password is. A short password with symbols can have less entropy than a longer password using only lowercase letters, because length matters more than character variety once you're past a certain point. That's part of why NIST's current guidance emphasizes length over complex composition rules.
Frequently asked questions
Is it safe to type my real password into this calculator?
Yes — the calculation happens entirely in your browser using JavaScript running on this page. Nothing is sent to a server, logged, or stored. That said, if you're not comfortable typing a real password anywhere, testing a similar dummy password of the same length and character mix gives you the same entropy number.
How many bits of entropy is "safe"?
There's no single cutoff, but a common informal target for a strong password is 70+ bits. Below 40 bits, a determined attacker with real computing resources could feasibly guess it.
Why does the crack-time estimate seem too fast or too slow?
It's a rough illustration based on one commonly cited attack speed, not a guarantee about any specific account. A properly hashed and salted password (which is how reputable services store passwords) is far slower to attack than the raw number here suggests.
Why did my entropy score drop after I typed a real word or a sequence?
This tool checks for commonly breached passwords, sequential runs (like "abcd" or "4321"), repeated characters, and keyboard-row patterns (like "qwerty"), and caps the score down when it finds one — because a pattern-matching attacker tries those first, regardless of how the character math works out. A "pattern-adjusted" label next to the bit count means this kicked in.
How does the breach check work, and is it really safe?
It uses a technique called k-anonymity. Your password is hashed in your browser, and only the first 5 characters of that hash are sent to the breach-check service — enough to get back a list of possible matches, never enough to identify your actual password. The comparison against that list happens back in your browser. It's the same method NIST's own breach-screening recommendation is typically implemented against.