Password Strength Meter

What This Tool Does

This tool measures two complementary properties of a password and combines them into a single security score. The first is Shannon entropy, expressed in bits — a mathematical lower bound on guessing difficulty derived from the password's length and character set. The second is a pattern-aware guessability estimate inspired by Dropbox's zxcvbn library: it scans for dictionary words, keyboard sequences, common substitutions (l33t-speak), repeated characters, and matches against a top-100 leaked-password list. The combined score reflects both how large the theoretical keyspace is and how much smaller the practical search becomes once an attacker uses realistic prior knowledge.

The headline number is time to crack, but a single crack-time figure is misleading because attackers operate in very different cost regimes. This tool reports estimates against four reference scenarios: an online attack throttled to roughly 100 guesses per second (a typical web login with rate-limiting), an unthrottled online attack at 10,000 guesses per second (a poorly-defended API), an offline attack against a slow hash like bcrypt running at 100,000 guesses per second on consumer hardware, and an offline attack against a fast hash like MD5 or NTLM running at 100 billion guesses per second on a GPU cluster. Knowing which regime applies to a given account is what turns an abstract entropy number into a concrete threat assessment.

Every computation runs in JavaScript inside this browser tab. The password string is held only in the input element's value property and the local function scope that processes it; no fetch, XHR, WebSocket, or sendBeacon call carries it anywhere. When you close or reload the tab, the string is garbage-collected and gone. This privacy guarantee is the entire point of building the tool client-side rather than as an API.

How to Use It

The interface is one input field and a live analysis panel. There is no Submit button — analysis updates as you type, debounced to fire 100 milliseconds after the last keystroke so the entropy display does not flicker on every character.

Step 1: Type or Paste Your Password

The input starts in type="password" mode, masking each character behind a dot. The eye icon at the right of the input toggles between masked and visible — useful when you want to confirm what you have actually typed, especially on mobile keyboards that auto-correct or substitute characters silently. Clicking Try Example pre-fills the classic password Tr0ub4dor&3 (the one from XKCD 936) so you can see how the tool scores a leetspeak-heavy 11-character password.

Step 2: Read the Entropy and Score

The analysis panel updates immediately. The strength meter shows a 0–100 score and a label (Very Weak, Weak, Fair, Strong, or Very Strong) keyed to the score. Below the bar, four analysis cards report Shannon entropy in bits, the estimated crack time at 10 billion guesses per second (the GPU-offline regime), the size of the character set the password draws from, and the total combinations expressed as a power of two.

Step 3: Examine the Character Breakdown

The chip row beneath the input displays counts for each character category: total length, uppercase letters (A–Z), lowercase letters (a–z), digits (0–9), and symbols (everything else including punctuation, brackets, and whitespace). Categories with a count of zero are visually dimmed. This breakdown is what the entropy calculation feeds on — the character set size used in the entropy formula is the sum of category sizes that have at least one member present (26 for lowercase, 26 for uppercase, 10 for digits, 33 for symbols).

Step 4: Read the Suggestions

The suggestions list provides specific, actionable improvements. Red dots flag critical problems (common password, too short, dictionary match). Amber dots indicate weaknesses worth fixing (missing character class, sequential characters, repeated characters). Green dots confirm strengths (good length, full character class coverage, very strong overall). The goal is to make every red dot disappear and to accumulate green dots — at which point the strength label will read Strong or Very Strong.

Common Use Cases

Picking Your Own Password

The most direct use is to score a password you are about to set on a new account. Type your candidate, read the entropy, fix the red and amber suggestions, and stop when the meter reads Strong or Very Strong. For accounts that hold meaningful value — email, banking, password manager master password, work SSO — aim for at least 70 bits of entropy and a green-only suggestion list before committing.

Evaluating Company Password Policy

Security teams use entropy analysis to check whether a written password policy actually delivers the security it claims. A policy that mandates "minimum 8 characters, must include uppercase, lowercase, digit, and special character" produces effective entropy that is usually far below the 52.6 bits a fully-random 8-character ASCII password would carry, because mandated complexity drives users toward predictable patterns. Run a sample of likely user passwords through this tool — Summer2026!, Spring$24, P@ssword1 — and the policy's real-world weakness becomes visible.

Designing a Passphrase

If you need a password you can actually memorize — for a password manager master, a disk-encryption key, or a recovery phrase — passphrase design is the right approach. Generate four to six words from a public Diceware list using physical dice or crypto.getRandomValues(), then paste the result here. The tool will not pick up the Diceware structure (it sees dictionary words and may underrate the entropy), but you can verify the underlying math: n random words from a 7,776-word list carry 12.92×n bits of entropy, so five words is 64.6 bits and six is 77.5 bits. Anything you can paste in and see flagged as Strong on character analysis alone is a bonus.

Testing Password Manager Output

Modern password managers default to producing 16 to 20 character passwords with all character classes enabled. Paste a few samples into this tool to confirm: entropy should land between 95 and 130 bits, the strength meter should read Very Strong, and the crack time should be quoted in geological timescales. If the manager's output ever scores below Strong, check whether the character-set checkboxes were toggled off — a "letters and numbers only" 12-character password is only 71 bits, materially weaker than the same-length all-class version.

Edge Cases and Common Mistakes

Entropy Theater: Length-Only Checks

A surprising number of password meters score purely on length, character class coverage, and presence/absence of a digit or symbol. These checks are easy to satisfy with extremely weak passwords. Aaaaaaaa1! passes "8+ chars, uppercase, lowercase, digit, symbol" yet collapses instantly under any pattern-aware attack. This tool's penalties for repeated characters and dictionary words exist specifically to defeat that gaming behavior — but no automated checker can catch every pattern. The ground truth is: random beats memorable, and length beats complexity, every time.

Why P@ssw0rd Is Weak Despite Meeting Every "Complex" Rule

Eight characters, uppercase, lowercase, digit, symbol — and yet P@ssw0rd appears in every credential-stuffing wordlist and is cracked in milliseconds on consumer GPUs. The reason is that GPU-based cracking tools like hashcat run rule engines on top of their wordlists. A rule like p@$$:s says "replace each 's' with '$'"; l33t rules systematically swap 'a' for '@', 'o' for '0', 'i' for '1'. Every common dictionary word gets multiplied by hundreds of transformation rules. Leet substitution is not security; it is a renaming convention that attackers' tools already understand.

Dictionary Attacks and Compromised-Password Lists

Beyond bare wordlists, modern attackers use compromised-password corpora — collections of every password ever exposed in a breach. The HaveIBeenPwned Pwned Passwords dataset holds over 850 million unique passwords by mid-2026, each searchable by SHA-1 prefix without exposing the full hash. 1Password and other managers integrate this dataset to warn when a generated or stored password matches a previously-leaked one. If your password appears in this corpus — even just once, in any breach across the internet — it is effectively zero-entropy against an attacker who has loaded the same list.

Credential Stuffing: Reused Passwords

The largest password-related attack category is credential stuffing: attackers take a username/password pair leaked from one site and try it on every other site. If you use the same password on a low-value forum and your bank, the forum's breach compromises the bank account. The defense is uniqueness: one password per site, generated and stored by a password manager. Strength analysis matters for the password manager's master password and a few critical accounts (email, work SSO, the manager itself); for everything else, what matters is that no two passwords are the same.

zxcvbn Limitations

zxcvbn was trained on English-language wordlists, English names, and ASCII keyboard layouts. Passwords using non-English dictionary words, foreign-language phrases, or non-ASCII characters may receive inflated strength scores because zxcvbn cannot recognize the pattern. Conversely, attackers regularly use multi-language wordlists, and any wordlist that exists publicly is in the attacker's toolkit. Use the tool's score as a floor estimate, not an upper bound — your actual security may be lower if your password matches a pattern this tool's dictionaries miss.

Biometrics and 2FA Matter More Than Complexity in 2026

The hard truth is that password complexity has diminishing returns past the point where online attacks become infeasible (around 50 bits of entropy with rate-limiting). Beyond that, the realistic threats are phishing, credential reuse, malware-based credential theft, and SIM-swap attacks against SMS-based 2FA. WebAuthn passkeys (FIDO2) and hardware security keys defeat phishing in a way no password length can. Authenticator-app TOTP defeats credential stuffing even when the password leaks. For high-value accounts in 2026, the marginal hour spent strengthening a password matters less than the hour spent enabling phishing-resistant 2FA.

Behind the Scenes

Shannon Entropy Formula

For a password of length L drawn uniformly at random from a character set of size C, the Shannon entropy in bits is:

H = L × log2(C) = log2(C^L)

For a 12-character password using all 95 printable ASCII characters: H = 12 × log2(95) = 12 × 6.57 = 78.8 bits. The keyspace is 2^78.8 ≈ 5×10^23 possible passwords. This calculation assumes uniform random selection — every character independently and equally likely. Any deviation from uniformity (human selection, dictionary words, keyboard patterns) reduces the effective entropy below the formula's prediction, often dramatically. The formula provides an upper bound on guessing difficulty, not a guarantee.

The zxcvbn Algorithm

zxcvbn was developed by Dan Wheeler at Dropbox in 2012 and remains the de facto standard for realistic password scoring. It works by attempting to decompose a password into a sequence of matches drawn from multiple pattern categories: dictionary matches (against frequency-ordered English words, surnames, female/male names, US cities, common passwords, leet-substituted variants); spatial matches (qwerty keyboard runs, asdf rows, numeric-keypad shapes); repeat matches (aaa, abab); sequence matches (abc, 123, jklm); and date matches (1985, 12/31, 2026-04). For each decomposition, zxcvbn estimates the number of guesses required to reach that match using realistic attacker priors — most-common dictionary words first, common substitution rules second, etc. The decomposition with the fewest total estimated guesses becomes the password's score. The output is a single number (guesses required) that converts to crack time at any guess rate.

NIST SP 800-63B-3 Requirements

NIST Special Publication 800-63B revision 3 (the current US federal guidance, last revised June 2017 with errata through 2026) gives strikingly different advice than the older complexity-rules orthodoxy. Key requirements for memorized secrets (passwords): minimum 8 characters with at least 64 character types allowed (the full printable ASCII range plus Unicode); no forced periodic expiration (rotation only on suspected compromise); no composition rules like "must contain uppercase" — these are explicitly discouraged; compare against a blocklist of known-compromised passwords from prior breaches; and offer the user a strength meter. The reasoning: forced complexity produces predictable patterns, forced rotation produces incremental passwords (Password1 → Password2), and the highest-leverage check is whether the password has already been leaked.

HaveIBeenPwned for Offline Checking

Troy Hunt's HaveIBeenPwned (HIBP) Pwned Passwords API provides a privacy-preserving way to check whether a password has appeared in any known breach. The client hashes the password with SHA-1, sends only the first 5 hex characters of the hash to the API, and receives back all hash suffixes from the database starting with those 5 characters (a k-anonymity response). The client then checks locally whether its full hash appears in the response. The API never sees the password or its full hash; the response leaks only that the client is checking some password whose SHA-1 begins with the 5-character prefix. This tool does not call HIBP — to preserve the absolute no-network-egress guarantee — but a top-100 common-password check is performed locally, and the Password Generator shows how to integrate HIBP for stricter checking when you accept the network call.

Comparison: This Tool vs. Other Strength Meters

Different password strength tools measure different things and have different threat models. The table below clarifies what each tool is actually checking, so you can pick the right one for the question you have.

How Much Entropy Is Enough? Threshold Reference

The "right" amount of entropy depends entirely on the attacker scenario. The table below gives concrete crack-time estimates across realistic guessing rates so you can match the entropy target to the threat.

Related Tools

The natural complement to a strength meter is a generator that produces strong passwords directly. The Password Generator uses crypto.getRandomValues() to produce cryptographically-random output with configurable length and character set — paste its results here to confirm they score as expected. For hashing a known password (to compare against a stored hash, or to compute a SHA-256 fingerprint), the Hash Generator covers SHA-1, SHA-256, SHA-512, and MD5 entirely in-browser via the Web Crypto API.

If you are working with API credentials rather than human passwords, the UUID Generator produces 122-bit random identifiers (UUIDv4) suitable for API keys, session tokens, and database primary keys. The JWT Decoder inspects JSON Web Tokens to verify their algorithm, claims, and expiration — useful when debugging authentication flows where you need to confirm that a token was issued correctly without paste-checking the embedded secret. For converting binary keys or password hashes to a printable form, the Base64 Encoder handles the standard encoding used in most credential storage formats.