Password Strength Checker
Real entropy math and pattern detection — not a fake color bar.
Also known as: Password strength meter, Password security tester, Password entropy checker
How it works
- 1Type or paste a password into the box — it's masked by default, click the eye icon to reveal it.
- 2Read your live strength score, entropy in bits, and exactly what issues were found.
- 3Check the crack-time table to see how long it would realistically take to guess.
- 4Optionally click "Check for breaches" to see if it's appeared in a known leak — nothing but a partial hash is sent.
Why use Password Strength Checker
Real entropy math, not checkbox scoring
Calculates actual bits of entropy from character pool size and length, instead of just checking "has a number, has a symbol."
Detects real-world shortcuts
Flags common passwords, sequential runs, keyboard walks, repeated characters, and leetspeak substitutions — the patterns crackers check first.
Multi-scenario crack-time estimates
Shows realistic crack times across three attack scenarios, from throttled online guessing to fast offline hardware.
Optional breach check via k-anonymity
Checks Have I Been Pwned's breach database without ever sending your actual password — only a 5-character hash prefix.
Specific, actionable feedback
Names the exact problems found instead of leaving you with a bare "weak" or "strong" label.
Fully local by default
Every check except the explicitly opt-in breach check runs entirely on your device.
Who uses Password Strength Checker
Checking a new password before using it
Verify a password you just came up with is actually strong before setting it on a real account.
Auditing an old password
Check whether a password you've used for years is still holding up by modern standards.
Choosing between two candidates
Compare the real entropy of two password ideas side by side instead of guessing which is stronger.
Verifying a passphrase's real strength
Confirm a memorable, word-based passphrase is actually strong enough for a sensitive account.
Checking breach exposure before reusing a password
Run the optional breach check before deciding whether it's safe to reuse an old password anywhere.
Teaching password hygiene
Show concretely why "Password1!" is weak and a random passphrase is strong, with real numbers.
About Password Strength Checker
Type "Password1!" into most of the strength meters bundled into signup forms, and you'll likely see "Strong." It has an uppercase letter, a number, and a symbol — every box a simple regex check looks for. It's also one of the first guesses a real attacker's cracking tool would try, because it's a well-known pattern, not because it's mathematically strong. This is the core flaw with checkbox-style strength meters: they measure the presence of character types, not how unpredictable the password actually is.
This tool measures unpredictability directly. It starts with entropy — the number of bits of randomness in the password, calculated from the size of the character pool actually used (lowercase, uppercase, numbers, symbols) and the password's length. Then it actively looks for the shortcuts that let real cracking tools skip most of that theoretical search space: exact matches against a list of the most commonly used passwords in the world, sequential runs like "abcd" or "4321", keyboard walks like "qwerty" or "asdf", three-or-more repeated characters, and common leetspeak substitutions like "p@ssw0rd" checked against the same common-password list after normalizing the substitutions back to letters. Each pattern found reduces the effective entropy score and shows up as a specific, named issue — not just a lower number.
The crack-time table translates that entropy into something concrete: how long would it actually take to guess this password under three realistic attack scenarios — an online login throttled to about 100 guesses a second, an offline attack against a properly slow password hash like bcrypt at roughly 10,000 guesses a second, and an offline attack against a fast, poorly-chosen hash running on GPU hardware at roughly 10 billion guesses a second. The gap between those three numbers, often many orders of magnitude, is exactly why how a service stores your password matters as much as how you choose it — but it's also not something you control, which is why choosing a genuinely high-entropy password in the first place is the one lever you always have.
One feature goes further than entropy math alone can: an optional check against Have I Been Pwned's database of passwords exposed in real data breaches, using the k-anonymity method. Your password is hashed in your browser using SHA-1, and only the first five characters of that hash are sent to the API — never your actual password, and never the rest of the hash. This is the same technique privacy-conscious password managers use, and it's the only feature on this entire site that touches the network; it's off unless you explicitly click the button, and everything else stays fully local.
Password Strength Checker vs. other options
How Open Tools Library compares to desktop software and other online tools.
| Feature | Open Tools Library | Desktop software | Other online tools |
|---|---|---|---|
| Price | Free, unlimited | Often built into password managers | Often free |
| Scoring method | Real entropy + pattern detection | Varies | Often checkbox/regex-based |
| Common password detection | Yes, 150+ checked | Varies | Rare |
| Crack-time estimates | 3 realistic scenarios | Rare | Rare, if shown at all |
| Breach check | Optional, k-anonymity | Sometimes | Rare, or requires full password upload |
| Data privacy | Local by default | Stays local | Often sent to a server for scoring |
Pro tips
- Length matters more than complexity — a longer, simpler password often beats a shorter one stuffed with symbols.
- Avoid keyboard patterns like "qwerty" or "asdf1234" even if they look random at a glance — they're checked first by real cracking tools.
- Common substitutions like @ for a or 0 for o don't fool a real password cracker's dictionary — it checks for them too.
- If the breach check finds a match, stop using that password anywhere, not just on the account you're checking.
- Crack-time estimates assume an attacker already has your password's hash — using a unique password everywhere is what actually limits your exposure.
- A high entropy score with a flagged issue (like a common password match) is still weak — read the issues list, not just the number.
Technical specs
- Analysis method
- Entropy calculation + pattern detection
- Common password list
- 150+ known common passwords checked
- Pattern detection
- Sequential runs, repeats, keyboard walks, leetspeak
- Crack-time scenarios
- 3 (online throttled, offline slow hash, offline fast hash)
- Breach check
- Optional, k-anonymity via Have I Been Pwned
- Processing location
- 100% local (breach check is the sole opt-in exception)
Privacy & security
Typing a real password into a random website to "check" it is exactly the kind of thing security advice warns against — so it matters that this one never leaves your device unless you explicitly ask it to.
Every character you type is analyzed locally in your browser — nothing is sent anywhere by default.
The optional breach check sends only a 5-character hash prefix, never your actual password or the full hash.
Nothing you type is stored, logged, or cached — refresh the page and it's gone.
Works the same for a throwaway test password as it does for the one guarding your email.
Frequently asked questions
Is my password uploaded anywhere while I check it?
No, not by default. The strength analysis runs entirely in your browser. The only exception is the optional breach check, which you must explicitly click to run, and which only ever sends a 5-character hash prefix — never your actual password.
How is the strength score actually calculated?
From real entropy math (character pool size and length), reduced by penalties for detected weaknesses like common passwords, sequential characters, keyboard patterns, and repeated characters.
What counts as a "common password" for this check?
A curated list of over 150 of the most frequently used passwords in real-world breach data, like "123456", "password", and "qwerty" — checked both directly and after normalizing common leetspeak substitutions.
What are the crack-time scenarios based on?
Three realistic attacker capabilities: an online login throttled to about 100 guesses/second, an offline attack against a slow hash like bcrypt at about 10,000 guesses/second, and an offline attack against a fast hash on GPU hardware at about 10 billion guesses/second.
Is the breach check actually safe? Does it send my real password?
It never sends your real password. It hashes the password in your browser with SHA-1, then sends only the first 5 characters of that hash to Have I Been Pwned's API — a technique called k-anonymity, the same method privacy-conscious password managers use.
Can two very different passwords get the same score?
Yes — the score is a rounded bucket (Very weak to Excellent) based on entropy bits, so passwords with similar effective randomness can land in the same bucket even if they look different.
Does this tool remember or store anything I type?
No. Nothing is saved anywhere — refresh the page and everything you typed is gone.
Troubleshooting
My password shows as weak but has uppercase, lowercase, numbers, and symbols
Character variety alone doesn't guarantee strength — if the password also matches a common password, a keyboard pattern, or a sequence, those issues drag the score down regardless of character mix. Check the "What we found" list for the specific reason.
The breach check shows an error
This means the request to the breach-check service failed, usually due to a network issue — your password itself was never at risk, since only a hash prefix is ever sent. Try again in a moment.
Why does length matter so much more than I expected?
Entropy grows multiplicatively with length — each additional character multiplies the total number of possible passwords, while adding one more character type only slightly increases the pool size per character.
A passphrase and a password show different-looking entropy math
That's intentional — a passphrase's real strength comes from random word selection, not character-by-character patterns, so it's calculated differently to avoid understating it.
Related searches
Landed here looking for something worded a little differently? Password Strength Checker covers all of these too:
Ready to use Password Strength Checker?
Free, private, and ready right now — no signup required.
Scroll to Password Strength Checker