Password Generator & Strength Checker

Yes. Generating, analysing, bulk generation, passphrases, downloads and every option are free, with no account, no sign-up and no cap on how many passwords you create.

No. Passwords are generated and analysed by JavaScript running in your browser. Nothing is sent to a server, nothing is stored, nothing is logged, and there is no analytics call carrying what you typed. You can disconnect from the network after the page loads and the tool keeps working — which is the test worth applying to any password tool, because a generator that talks to a server is a generator that could be keeping what it made.

They come from crypto.getRandomValues, the platform's cryptographically secure random number generator, which draws from the operating system's entropy pool. Math.random is not used anywhere in this tool and must not be: it is a fast non-cryptographic generator whose future output can be predicted from a handful of observed values, so passwords built on it look random while being reproducible by an attacker.

Entropy measures how many guesses an attacker needs, expressed in bits. Each extra bit doubles the work. A password with 40 bits takes about a trillion guesses to exhaust and falls to a GPU in seconds; one with 80 bits takes about 10^24 and does not. Entropy comes from the process that chose the password, not from how complicated the result looks — which is why a password you invented to look random usually has far less than it appears to.

By finding the cheapest way to describe the password. The analyser looks for dictionary words, common passwords, keyboard walks, sequences, repeats, dates and personal patterns, then computes the least-cost route that covers the whole string — recognised stretches are charged at what that trick costs an attacker, and anything left over is charged at the full brute-force rate. That is why Password1! scores badly here and well on meters that simply multiply length by alphabet size.

Most strength meters compute length × log2(alphabet), which assumes every character was chosen at random. A password a human invented was not. That formula rates Password1! at about 65 bits — centuries of cracking — when a real attacker reaches it in under a second by trying a dictionary word with a capital, a digit and a symbol. This tool models the attacker rather than the keyboard, so it gives lower and more useful numbers.

By dividing the guesses needed by the rate an attacker can make them, at the median — an attacker expects to find a password half way through the search rather than at the end. Four scenarios are shown, from a rate-limited login form at 100 attempts an hour to a GPU rig at a trillion guesses a second against a stolen database. The headline figure is the GPU one, because that is the case a password actually has to survive.

Because it is the realistic threat. Online guessing against a live login is slow and usually stopped by rate limiting and lockouts — the service is doing the defending, not your password. The case where your password alone stands between an attacker and your account is when a company is breached and the password database is stolen. If it was hashed with MD5 or unsalted SHA-1, an attacker makes billions of guesses a second offline, and only entropy helps.

Sixteen characters or more for anything that matters, and longer for accounts that protect other accounts — your email and your password manager. Length beats complexity: adding one random character to a mixed-case alphanumeric password multiplies the search space by about 62, while adding a symbol to a short password multiplies it by a much smaller factor and makes it harder to type. The generator defaults to 20 for that reason.

A passphrase is several unrelated random words — forest-river-coffee-laptop. It is not automatically stronger; it is stronger per unit of memorability. Four words from this tool's 2,048-word list is 44 bits, about the same as a 7-character random password, but you can actually remember it. Six words is 66 bits and still memorable, where a 12-character random string is not. Use a passphrase for the handful you have to type from memory and random passwords, stored in a manager, for everything else.

Four is the minimum worth using and six is a good target. Each word from a 2,048-word list is exactly 11 bits, so four words is 44 bits, five is 55 and six is 66. Below four the phrase is short enough that a dedicated attacker who knows you used a passphrase can exhaust it. The security comes from the number of words and the size of the list — never from the list being secret, since every wordlist worth using is public and an attacker is assumed to have it.

No, and the tool says so where the option sits. Capitalisation here is applied to every word or to none, so there is nothing for an attacker to guess — it adds zero bits. It exists because some password policies demand an uppercase letter. Appending random digits or a random symbol does add entropy, because those are actually chosen at random: two digits is 6.6 bits and one symbol from eight is exactly 3.

They help, but less than people think, and less than length. Adding symbols takes the alphabet from 62 characters to 94, which is about 0.6 extra bits per character. Adding four more characters to a 62-character alphabet adds about 24 bits. If a policy demands a symbol, use the require option; if it does not, spend your effort on length. Symbols also make a password harder to type on a phone, which is a real cost.

“Similar characters” drops O, 0, I, l, 1 and | — the pairs people transcribe wrongly when reading a password off a screen or a printout. “Ambiguous symbols” drops the characters that need escaping somewhere they are likely to be pasted: quotes and backslashes break shell commands and CSV files, angle brackets break HTML, and a backtick starts a command substitution. Both shrink the pool and cost entropy, which the figure beside the password accounts for — compensate with a little more length.

That the generated password contains at least one character from each type you tick, so it satisfies a policy that demands them. It works by placing one character of each required type and then shuffling everything, so the required characters are not sitting in predictable positions. It costs a fraction of a bit of entropy, because a constraint is information an attacker can use — the tool computes the exact reduced figure rather than reporting the unconstrained one.

Because a password with no repeats cannot be longer than the number of distinct characters available. With every character type on that is 94; with the exclusions on it can drop below 60. When you ask for more than that, the tool generates the longest password those settings allow and says so. The option also slightly reduces entropy for the same reason “require at least one” does: knowing no character repeats is knowledge an attacker can use.

Yes — 10, 25, 50 or 100 at a time, each generated independently rather than permuted from a common seed. Every row shows its own strength rating and entropy, since an unlucky combination of settings can produce a weak one and finding that out after the file has been distributed is too late. Click any row to load it into the analyser, and export the whole set as TXT, CSV or JSON.

It is a real risk and the tool warns about it after each download. The file lands in your downloads folder in plain text, often gets synced to a cloud drive, and is usually still there months later. If you export a batch, move the passwords into a password manager and delete the file. Bulk export exists because provisioning accounts genuinely needs it, not because it is harmless.

Not against the full breach corpus, and it is important to be precise about that. It checks against a sample of the few hundred most common passwords, which catches the worst cases instantly. It cannot tell you a password is absent from every breach, because doing so would mean sending something derived from your password to a third-party service — and this tool sends nothing anywhere. To check a specific password against real breach data, use Have I Been Pwned's password service directly.

No. The history lives in the page's memory and nowhere else — no localStorage, no sessionStorage, no cookie, no server. Refreshing the page, closing the tab or navigating away erases it. It is capped at the 50 most recent so a long session does not accumulate a growing pile of live credentials in memory, and you can delete individual entries at any time.

Reusing one password across accounts is the worst by a distance — one breach anywhere becomes a breach everywhere, and attackers automate exactly that. After that: using personal information that is public anyway, using a dictionary word with predictable substitutions, adding a year or an exclamation mark to satisfy a policy, and choosing something short because it has to be typed often. The last one is solved by a password manager rather than by a shorter password.

No — that guidance was withdrawn. NIST's current recommendation, and the UK NCSC's, is to change a password when there is reason to believe it has been compromised and not on a schedule. Forced rotation makes people pick weaker passwords and increment them predictably: Spring2024! becomes Summer2024!. Use a long unique password per account, change it if the service is breached, and leave it alone otherwise.

Yes. A strong password protects against guessing and cracking; it does nothing against phishing, malware on your machine, or a breach at the service. Two-factor authentication is what covers those, because an attacker with your password still cannot get in. Prefer an authenticator app or a hardware key over SMS, which can be intercepted by SIM swapping.

Yes. It is the only practical way to have a genuinely unique long random password for every account, which is the single most valuable thing you can do. The common objection — putting everything in one place — is real but backwards: the alternative is reusing passwords, which is a much larger risk. Protect the manager with a long passphrase you can remember and two-factor authentication, and let it generate everything else.

Ctrl/Cmd+G generates, Ctrl/Cmd+Shift+C copies, Ctrl/Cmd+Shift+D downloads, Ctrl/Cmd+Shift+Delete clears everything including the history, and Ctrl/Cmd+F opens the search over the generated list and history. Ctrl/Cmd+Enter also generates, matching the other tools here. Escape closes the search.