Password Strength Checker with Local Estimates
Inspect password patterns and the tool's strength estimate in your browser. Treat any entropy or crack-time output as a model, not a guarantee.
Password Strength Meter workspace
—
Enter a password to analyze it.
Real Shannon Entropy
Charset size × length, then penalized for keyboard runs, repeated chars, sequential runs, leet substitutions, and year suffixes — the same heuristics used by professional security audits.
Breach-Corpus Lookup
Instant blacklist check against the ~120 most common passwords from rockyou and HIBP aggregate. If your password is there, no length or charset can save it.
Four Attack Speeds
See crack-time estimates at: online throttled (100/h), online unthrottled (10/s), offline slow hash (10K/s bcrypt), and offline fast hash (10B/s SHA-1 GPU).
Strictly Offline
No HIBP request or analytics event contains the password. Pattern matching, entropy estimates, and the bundled breach-corpus check run in your browser.
Password Strength Meter: Entropy, Patterns, and Crack-Time
Inspect password patterns and the tool's strength estimate in your browser. Treat any entropy or crack-time output as a model, not a guarantee. Strength estimates depend on assumptions about how a password was chosen and how an attacker guesses. Pattern checks and a bundled common-password list cannot establish that a password has never appeared in a breach. Do not treat a strong label as proof of account security.
How to use the password strength meter
- Type or paste a password into the input above — analysis updates as you type, with nothing sent anywhere.
- Read the 0–4 score and its label (Risky, Weak, Fair, Strong, Excellent).
- Check the entropy in bits — aim for 60+ for everyday accounts, 100+ for high-value ones.
- Review the detected issues list: each flagged pattern (keyboard run, repeat, leet word, short length) is a concrete fix.
- Scan the four crack-time rows; the offline fast-hash figure is the worst case if a database leaks.
- If the score is 3 or below, generate a replacement with the Password Generator and recheck it here.
What is password entropy and how does scoring work?
Password entropy is the Shannon entropy of the password, measured in bits: E = L × log₂(R), where L is length and R is charset size. This tool detects four classes — lowercase (+26), uppercase (+26), digits (+10), symbols (+33) — so a mixed all-class password draws from R = 95. Each extra character adds log₂(R) bits; each bit doubles the guesses an attacker needs.
Raw entropy alone overrates human-chosen passwords, so the meter follows the zxcvbn approach — estimate strength the way a cracker would — and subtracts bits for patterns: keyboard runs −10, leet-matched word −12, sequential or repeated runs −6 each, trailing 4-digit year −4, and −3 per character under 8. The penalized total maps to a score: under 28 bits = 0, 28–35 = 1, 36–59 = 2, 60–99 = 3, 100+ = 4. An exact breach match caps the score at 0 regardless of length.
"Verifiers SHALL compare the prospective secrets against a list that contains values known to be commonly-used, expected, or compromised."— NIST SP 800-63B, Digital Identity Guidelines, which sets an 8-character minimum and recommends supporting up to 64.
Worked examples: password → score
correct horse · 13 chars, lowercase + space
R = 26 letters + symbol class for the space, so ~13 × log₂(59) ≈ 76 bits → score 3. Length carries it even with no digits or capitals.
Tr0ub4dor · 9 chars, all classes but a dictionary base
Raw entropy looks fine (~59 bits), but un-leeting hits a word and the meter flags it → typically score 1–2. Complexity theatre, not real strength.
Edge case · leet detector is exact, not fuzzy
The penalty fires only when the fully un-leeted string equals a blacklist entry. P@ssw0rd scores 0 because its lowercase form p@ssw0rd is literally in the list — the blacklist branch catches it before entropy is weighed. But the un-leet map only covers @ 4 3 ! 1 0 $ 5 7; substitutions like 8→b or 2→z are not reversed, so Pa$$w8rd can slip past the dictionary check.
Entropy and crack-time reference
Offline crack times below assume the meter's fast-hash speed (10¹⁰ guesses/second, SHA-1 on a single high-end GPU). Times scale linearly with attacker hardware.
| Password Profile | Entropy (bits) | Score | Offline GPU Crack Time |
|---|---|---|---|
| password | 0 (in corpus) | 0 | instant |
| Summer2024! | ~28 | 1 | under 1 second (rule attack) |
| 8 random lowercase | ~37 | 2 | ~14 seconds |
| 12 random mixed case + digits | ~71 | 3 | ~80 years |
| 16 random all-class | ~104 | 4 | far beyond a human lifetime |
Why an exact blacklist beats a clever pattern check
This meter ships exactly ~120 passwords for its instant O(1) blacklist — a deliberate, honest limit, not a full corpus. The full RockYou2024 compilation holds nearly 10 billion passwords — far too large to ship to a browser, and querying it would need a network call this tool refuses to make. So a 16-character random string and a 16-character keyboard walk both look long, but the walk loses 10 entropy bits and the random one keeps all of them.
The real gotcha: an exact breach match wins instantly. p@ssw0rd caps at score 0 not because of the symbol or the digit, but because the literal string sits in the blacklist. Length and charset cannot rescue a password that an attacker already has on a list — which is why NIST tells verifiers to screen against breach corpora before trusting any complexity rule.
Related security & developer tools
Create random score-4 passwords
Hash GeneratorSHA-256 digests, bcrypt prep
HMAC GeneratorKeyed message authentication codes
UUID GeneratorUnguessable tokens & API secrets
Random Number GeneratorCryptographically random integers
Number Base ConverterHex, binary & decimal for hashes
QR Code GeneratorShare TOTP and Wi-Fi secrets
HTTP Status Codes401 vs 403 auth reference
Cron Expression BuilderSchedule rotation reminders
All ToolsBrowse the full toolk hub
Guide: Strong PasswordsWhy length beats complexity
Guide: Hashing vs EncryptionHow passwords get stored safely
Last updated: September 15, 2026 · Runs 100% in your browser — no uploads, tool input is not sent to Toolk.
Frequently asked questions
How does the scoring actually work under the hood?
It starts with Shannon entropy — length × log&₂(charset size), with charset detected from four classes (lowercase +26, uppercase +26, digits +10, symbols +33) — then subtracts bits for detected patterns: keyboard runs −10, leet-matched common passwords −12, sequential or repeated runs −6 each, a trailing year −4, and −3 per character under 8. The adjusted total maps to zxcvbn-style buckets: under 28 bits scores 0, then 28–35 = 1, 36–59 = 2, 60–99 = 3, and 100+ = 4.
Is it safe to type a real, in-use password into this meter?
Yes, by construction: every check — entropy math, pattern detection, the ~120-entry breach lookup, all four crack-time rows — executes locally in your browser with zero HTTP requests, so there is no HIBP call to leak it. Toolk's page analytics never receive what you type here.
Why did my long password still cap at score 0?
An exact match in the built-in common-password corpus ends the analysis immediately: if the password (or its lowercase form, such as p@ssw0rd) sits on the rockyou-style blacklist, no length or symbol count can rescue it, because attackers try listed passwords first regardless of how complex they look.
What can the meter catch that a plain entropy counter would miss?
Human-shaped weaknesses: qwerty-style keyboard walks, abc and 123 sequences, aaa repeats, year suffixes like Summer2024, and leet disguises that un-leet back onto the blacklist. If the report flags any of those, rebuild the password with Toolk's password generator (/tools/password-generator) and re-score the replacement here.