Password Strength Checker

See exactly why a password scores the way it does — named rules, live entropy and an offline crack-time estimate, all on this device.

0 bytes uploaded

Strength—Effective entropy—Offline crack estimate—

Password

Measurements

CompactExpanded

Nothing to score yet — type or paste a password above.

Assumes an offline attack on a stolen database at 10^12 (a trillion) guesses per second against a fast hash — a login form is far slower, a purpose-built rig can be faster.

The band reads the effective-bits figure, not the line above it: Fair begins at 36 bits, where this scenario still resolves in under a second, and the estimate passes a day at about 58 bits and a year at about 66. Read both.

Length: —
Distinct characters: —
Guessing alphabet: —
Character sets in use: none yet

Raw entropy: —
Pattern penalty: —
Effective entropy: —

Character sets, one cell per character

One cell per character, coloured by set. Hidden while the password is masked.

13 named rules · 128 well-known words · 18 keyboard paths

—How this score is calculated

Why it scores this way

Findings appear here as you type.

What would help

Suggestions appear here once there is a password to read.

A shared link carries only the display options — masking, detail level and which sample is loaded. There is no state key that could hold a password.

Press ? for the five shortcuts on this page

This page scores a password and shows the rules behind the score. It does not check breach lists, and it does not generate or store passwords.

Never stored — a password is a credential. This page keeps nothing between visits.

This page loads no third-party code — no ads, no trackers, no analytics. Verify in your Network tab.

Do it offline:$ echo -n 'P@ssw0rd1!' | cracklib-check

How to use it

Type or paste into the password field. Scoring runs as you type, on this device; the field is masked by default and ⌘/Ctrl + Shift + M unmasks it. Prefer a password you are about to change, or one of the three samples.
Read the band chip and the four readouts beside it — length, distinct characters, inferred alphabet size and effective bits — then the crack-time line, which states the guessing rate it assumes.
Work down the findings rail. Each finding gives a code, the rule's name, the bits it subtracted and the positions it covers; unmask the field and switch the readout to Expanded to watch the character strip mark them. Suggestions point at the most expensive span first.
Copy or download the report, or share the current view. The report is positions and numbers only — no password characters appear in it, in the link or in the file, so it is safe to paste into a ticket.

Type a password and read the whole judgement, not a colour. This page counts the code points, infers the guessing alphabet, prints the entropy arithmetic, then names every pattern it charged you for and the bits each one cost — repeated blocks, keyboard paths, dates, word-plus-digits and nine more. The password is never stored, never put in a link and never sent anywhere.

How it works

Counting comes first, in code points rather than UTF-16 units, so one astral character — an emoji, say — counts once and not twice. Nothing is normalised: two Unicode compositions that look identical are different passwords to most login systems, though some servers do normalise before comparing (RFC 8265). Each code point joins one of five sets, and the sizes of the sets present are the guessing alphabet: lowercase 26, uppercase 26, digits 10, ASCII symbols 33, and anything else — non-ASCII or control characters — a flat 100, labelled as the estimate it is. Hence 95 for the four ASCII sets together, 36 for lowercase plus digits.

Raw entropy is then length × log₂(alphabet size): ten characters over a 95-character alphabet is 65.7 bits. That assumes every position was chosen independently and uniformly — true of a generator, almost never of a person — so thirteen rules run next, each a named row the page and the tool print identically: Too short, Single character set, Only two character sets, Few distinct characters, Digits only, Repeated block, Alphabet or digit run, Keyboard path, Year, Date, Complexity-rule shape, Well-known password word, and Word plus digits. Repeats cover block periods 1 to 4, so aaaa and abababab both match. Runs go up and down, case-insensitively, without wrapping — za is not a run. Paths are checked against 18 QWERTY rows and diagonals in both directions: 268 key-and-direction starting points. Years are 1900–2099; dates take / - . or no separator. Words are matched against a hand-authored list of 128, retried after undoing 19 look-alike substitutions such as @ for a.

A matched span is not deleted, it is repriced: the penalty is the bits that span was credited minus log₂ of the candidates someone who knows the pattern would try, floored at zero — a four-digit year keeps log₂ 200 ≈ 7.6 bits. Spans are chosen greedily, largest penalty first and leftmost to break ties, and never overlap, so every character gets at most one explanation. Hence the first example: P@ssw0rd1! reports Word plus digits and not also Complexity-rule shape, because the bigger span owns those characters. Four rules — Too short, Single character set, Only two character sets and Digits only — are always 0-bit advisories, since the alphabet size already encodes which sets are present, and Few distinct characters charges only the leftovers no span explains. Effective bits are raw minus penalties, floored at zero; four thresholds — 28, 36, 60 and 80 bits — give the score 0 to 4. Those four are judgement, not a reading of the crack line: the band labels the bits, and the next paragraph's scenario still resolves 36 bits in under a second.

The crack-time line is one scenario, stated plainly: an offline attack on a fast, unsalted hash at 10¹² guesses per second, reported as the average case. It excludes online rate limits, a slow KDF like bcrypt or Argon2, a guesser who knows your dog's name, and any breach corpus. Past roughly the age of the universe the reading stops counting and says so, which is why no figure here can render as Infinity. Thresholds, word list and the 100-per-character estimate are published judgement calls rather than a standard; the arithmetic around them is reproducible from the numbers above.

Examples

P@ssw0rd1!

band very-weak · score 0/4
length 10 · unique 9 · alphabet 95
entropy 65.7 raw − 45.8 penalty = 19.9 effective
crack instant at 10¹² guesses/s
F_WORD_PLUS_DIGITS · Word plus digits · −45.8 bits · characters 1–9

The canonical complexity-rule password: a capital, a symbol, a digit, ten characters, and 45.8 of its 65.7 bits gone. Undoing @→a and 0→o exposes a list word, the trailing 1 completes word-plus-digits, and that span covers characters 1 to 9.

Tr0ub4dor&3

band strong · score 3/4
length 11 · unique 10 · alphabet 95
entropy 72.3 raw − 2.1 penalty = 70.2 effective
crack about 20 years at 10¹² guesses/s
F_CARGO_CULT · Complexity-rule shape · −2.1 bits · character 11

The famous cartoon example. Its substitutions do not unwind to a word on this checker's list — troubadour is not among the 128 — so only the capital-first, digit-last shape is charged, cheaply. A checker carrying a large dictionary would score it far lower.

qwertyuiop1

band very-weak · score 0/4
length 11 · unique 11 · alphabet 36
entropy 56.9 raw − 43.6 penalty = 13.2 effective
crack instant at 10¹² guesses/s
F_TWO_CLASSES · Only two character sets · 0.0 bits (advisory)
F_KEYBOARD_RUN · Keyboard path · −43.6 bits · characters 1–10

Eleven distinct characters, not one repeat — exactly what a character-counting meter rewards. Ten of them walk the top keyboard row in order, so 268 starting points describe that walk instead of 36¹⁰ and 43.6 bits disappear.

correct horse battery staple

band very-strong · score 4/4
length 28 · unique 13 · alphabet 59
entropy 164.7 raw − 61.1 penalty = 103.6 effective
crack beyond the age of the universe at 10¹² guesses/s
F_TWO_CLASSES · Only two character sets · 0.0 bits (advisory)
F_LOW_UNIQUE · Few distinct characters · −61.1 bits

Length wins even after a large deduction: twenty-eight characters draw on only thirteen distinct ones, so the leftovers are repriced against 13 options each rather than 59. Note what the figure does not claim — this phrase is famous, and a guesser working from published phrases finds it immediately.

Tr0ub4dor&3xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Password is 513 characters — this checker handles up to 512 characters. Shorten it to continue.

Eleven characters plus 502 more is 513, one past the cap. The whole input is declined and the pane keeps its size — scoring the first 512 would report a different password's score. A key or a token that long belongs in a different tool anyway.

Every example on this page is executed against the same engine that powers the tool, on every build.

Gotchas worth knowing

Two meters disagree because they model different guessers

A meter is a claim about how an attacker searches, and there is no standard search. This one prices thirteen named patterns and a 128-entry word list; one carrying tens of thousands of dictionary and leaked entries prices differently, and a bank's may count character classes only. When readings differ, believe the lower one and read the reasons.

Whitespace is scored as typed, and forms often disagree

A leading or trailing space counts as a symbol and widens the alphabet, but many login forms trim it before comparing, silently changing the password — so the report warns instead of stripping it. Internal spaces are ordinary characters, and they are what make a passphrase register as two sets, not one.

Look-alike letters can beat the word list

Substitutions are undone before matching, but only the 19 documented ASCII ones. Replace a Latin P with the Cyrillic Р and the string matches no list entry, so the score rises although the password looks unchanged — a rising score is not proof of improvement. The portability warning that fires there matters more: a character you cannot retype on another keyboard is a lockout waiting to happen.

Overlapping patterns are charged once, deliberately

19851985 is a year and a repeated four-character block at once. Because spans never overlap, the repeat wins the whole string and the year is not charged again — stacking penalties on the same characters would make scores fall faster than an attacker's work does.

Control characters and non-ASCII: counted, then flagged

A null byte or any other control character counts as an unclassified character worth an estimated 100 options, and is warned about, because many login forms strip or reject it. Accented letters, CJK and emoji are counted the same way, once each.

Zero-bit findings are explanations, not punishments

Too short, Single character set, Only two character sets and Digits only always show 0.0 bits: they explain a small alphabet that has already been applied, since a four-digit PIN is 13.3 raw bits precisely because the alphabet is 10.

This page scores; it does not look anything up

There is no breach lookup here, no vendored password corpus and no network request of any kind — a password can score 4 out of 4 and still sit in a public breach list. Pwned Password Check does that lookup; Password Generator and Passphrase Generator make replacements; the entropy arithmetic on its own belongs to Password Entropy Calculator.

Common errors

Password is 513 characters — this checker handles up to 512 characters. Shorten it to continue.: The cap counts code points, not bytes, and the message reports the count it actually saw. Refusal is total: no partial score, no truncation, and the input is left untouched. A key block or a token dump lands here regularly, and neither is a password.
1 character is a control character — many login forms strip or reject control characters, so this password may not be accepted everywhere.: Scoring continues, with the character counted as unclassified. The warning is about acceptance rather than strength: a null byte or a stray tab usually arrives from a paste out of a terminal, and the form on the other side may drop it, leaving a password you can no longer reproduce.
This password starts or ends with whitespace — it is scored exactly as typed, but many forms trim it, which would change the password.: Almost always an accident of copying. The space is scored, because guessing it is real work, but it is fragile to depend on: trim the string, re-read the score, and decide whether the password still stands up without it.

FAQ

Why does another site's meter give my password a different score?

Because a score is a model of an attacker, and the models differ. This page prices thirteen published rules against a 128-entry word list and prints the bits for each; other meters weigh a large dictionary, count character classes, or cap the reading at some length. None is measuring a physical quantity. Compare the reasons rather than the numbers.

Why does P@ssw0rd1! score so badly when it satisfies every complexity rule?

Because the rules it satisfies are the ones attackers assume. Undoing the look-alike substitutions leaves a list word, the trailing digit completes the commonest password shape there is, and the executed example above shows 45.8 of its 65.7 bits vanishing on that one span. Complexity requirements produce predictable strings, which is why NIST SP 800-63B now pushes length over composition.

Does this tool check whether my password has been in a breach?

No, and the distinction matters. Nothing is looked up, because nothing leaves this device — the score comes from the string alone. A password can reach the top band here and still appear in a public breach corpus, which makes its bits irrelevant. Pwned Password Check answers that question instead.

Is this zxcvbn?

No. zxcvbn is the well-known research estimator, and this page neither reproduces it nor claims its results: no third-party estimator ships here, no frequency lists are bundled, and matching runs against 128 hand-authored entries where zxcvbn uses tens of thousands. Expect kinder treatment of an obscure word, equal harshness on the obvious shapes.

Is my password sent anywhere, or stored?

Neither. The analysis is arithmetic over the string in this tab, the page makes no network request at all, and nothing derived from the password is written to storage — no history, no restore-on-return, only your mask and detail preferences. Shared links carry those preferences and never the password. Check it in your browser's network panel.

What counts as good enough?

Read the bits, not the colour — and note that the band and the crack line sit on a different scale. Sixty effective bits is where this page starts saying strong and 80 very strong, though that same scenario cracks 60 bits in about six days and anything under about 41 bits in under a second. Aim past 80 for anything you would mind losing, keep it unique to one site, and add a second factor. Treat each deduction as an instruction: rewrite that span.

Keyboard shortcuts

⌘/Ctrl + Enter: Score the field again immediately — reassurance on a tool that is already live as you type.
⌘/Ctrl + Shift + M: Mask or unmask the field. The state is announced to screen readers and is kept between visits.
⌘/Ctrl + Shift + S: Insert the next built-in sample, so you can compare shapes without typing a real password.
⌘/Ctrl + Shift + X: Clear the field. Undoable once, like every other destructive action here.
⌘/Ctrl + C: Copy the report while focus is in the tool and nothing is selected; a real selection copies just itself. The report contains no password characters.

Nothing you paste here leaves this tab. State only ever travels in links you explicitly create.

NIST SP 800-63B — memorized-secret verifiers (length over composition) · zxcvbn: Low-Budget Password Strength Estimation (USENIX Security 2016) — the estimator this page does not reproduce · RFC 8265 — PRECIS OpaqueString profile for passwords (obsoletes RFC 4013 SASLprep) · Bitwarden — password strength testing tool · Security.org — How secure is my password?

Last reviewed: 2026-08-11