Password Strength Checker

Hollywood shows a hacker guessing your dog's name at a login screen. Real password cracking looks nothing like that. The vast majority of cracked accounts fall to automated, industrial-scale attacks that never touch the login form at all — which is why the offline number in the table above is the one that should worry you.

The usual sequence starts with a data breach. A website gets compromised and its password database is stolen. Reputable sites don't store passwords in plain text — they store hashes, one-way mathematical fingerprints. But an attacker with the database can run guesses through the same hash function on their own hardware, completely offline, and compare the results. A single consumer GPU tests billions of guesses per second against fast hash functions like MD5 or SHA-1; a rig with eight of them reaches the tens of billions. That is where our 10-billion-guesses-per-second offline estimate comes from — it is an ordinary, achievable setup, not a nation-state supercomputer.

The attacker doesn't guess randomly, either. Cracking runs in escalating stages:

Two takeaways follow directly. First, a password that looks complex but is built from a word plus predictable decoration is nearly worthless against rule-based attacks — the checker above penalizes exactly those constructions. Second, no amount of strength protects a password that's already leaked and reused, which is why our password leak checker is the natural companion to this page.

Password strength is measured in bits of entropy. The idea is simple: how many yes/no questions would an attacker need to narrow down your exact password? Every added bit doubles the number of possibilities. A password with 40 bits of entropy has 2⁴⁰ — about a trillion — possible combinations; 41 bits has two trillion.

The basic formula is bits = log₂(charset size) × length. Each character drawn from a bigger pool carries more bits: lowercase-only gives about 4.7 bits per character, adding uppercase pushes it to 5.7, and the full keyboard (lowercase, uppercase, digits, symbols — 95 characters) yields about 6.6 bits per character. That's why length wins: one extra character adds a full 6.6 bits, while upgrading the character set of an existing password adds far less.

*Passphrase entropy assumes words picked randomly from a large wordlist (~12.9 bits per word from a 7,776-word diceware list × 4 words, plus separators) — not four words you thought of yourself, which are far more predictable.

The catch — and the reason this checker doesn't just multiply two numbers — is that the formula assumes every character is chosen randomly. Humans don't do random. "abc123abc123" is 12 characters, but an attacker's software models sequences and repetition, so its real search cost is a fraction of the naive math. Our estimator therefore applies penalties: characters inside sequential runs (abc, 987), repeats (aaa), and keyboard walks (qwerty, asdfgh) mostly don't count, and anything matching our embedded top-200 common-passwords list — or a trivial variant of one — is capped near zero, because those are literally the first guesses any cracking rig makes.

The table in the tool shows two very different attack speeds, and the gap between them is the point. The online estimate (10,000 guesses per second) models an attacker hammering a login form or API. In practice most services throttle far harder than this, lock accounts, or trigger CAPTCHAs — so even a mediocre password survives a while online. The offline estimate (10 billion guesses per second) models the serious scenario: your password's hash has been stolen in a breach and the attacker is grinding through guesses on their own GPUs with nothing slowing them down. Judge your password by the offline number.

Two honest caveats. Crack-time estimates assume the attacker knows nothing about you — if your password contains your pet's name or birth year, a targeted attacker's effective search space is tiny regardless of what any calculator says. And the numbers assume a fast hash; sites using slow, modern hashing (bcrypt, Argon2) cut attacker speed by factors of thousands. You can't know which a site uses, so plan for the worst case.

The single most effective upgrade is length made of genuinely random material. Two practical recipes work:

Random passwords from a generator. A 16–20 character string of random mixed characters lands deep in Excellent territory. You will never remember it — and you shouldn't try. Generate one with our password generator (which, like this tool, runs entirely in your browser) and store it in a password manager. This is the right answer for the 99% of logins you paste rather than type.

Random passphrases for things you must type. For the handful of secrets you enter by hand — your password manager's master password, your computer login, disk encryption — chain four or five words picked randomly from a large wordlist: plank-orbit-mango-drizzle. At roughly 13 bits per truly random word, five words clear 64 bits while remaining typeable and memorable. The critical word is "randomly": four words that occurred to you ("iloveparisinspring") follow language statistics that cracking software models very well.

Just as important as strength is uniqueness. Credential stuffing — replaying leaked email+password pairs across other sites — is arguably the top account-takeover method today, and it works because people reuse passwords. One password per account means one breach compromises one account instead of your entire digital life. Nobody manages 100+ unique strong passwords in their head; a password manager is the tool that makes the whole strategy workable, and every major one encrypts your vault with AES-256 encryption locked by your master passphrase.

Even an Excellent password can be phished, shoulder-surfed, or leaked in plain text by a careless website. Multi-factor authentication (MFA) is the safety net: an attacker who has your password still can't log in without a second proof — a code from your phone, a hardware key, or a biometric check. Microsoft and Google have both published figures showing MFA blocks the overwhelming majority of automated account-takeover attempts.

Not all second factors are equal, though. Authenticator apps (TOTP codes) are a big step up from SMS codes, which can be intercepted through SIM-swapping. Hardware security keys and passkeys are stronger still, because they cryptographically verify the site's identity and are effectively unphishable. The pragmatic priority list: enable MFA on your email account first (it's the reset key to everything else), then banking, then your password manager, preferring an authenticator app or passkey over SMS wherever the option exists.

MFA complements, not replaces, password strength: the password is still the only lock on breached databases cracked offline, where no second factor is asked for.

A password is only as safe as the path it travels. HTTPS protects the password itself in transit, but on an open network — airport Wi-Fi, hotel Wi-Fi, a café hotspot — the network operator and anyone else on it can still see which sites you visit, harvest metadata, and attempt downgrade or spoofing attacks against sloppy apps. A VPN closes that layer by wrapping all your traffic in its own encryption before it leaves your device; our privacy-focused VPN rankings cover the providers that do this properly, with NordVPN and ExpressVPN the most consistent performers in our tests. Several top VPN subscriptions now bundle a password manager and breach alerts, which pairs neatly with the habits on this page.

The full hygiene loop looks like this: generate unique random passwords (generator), verify anything you typed yourself here, check whether your existing passwords have already leaked (leak checker), turn on MFA, and encrypt the connection you log in over (best VPNs).