Password Generator
Strong random passwords, generated locally.
Generated on your device, never transmittedGenerate a strong random password
Length vs. entropy
With the default settings (all four sets, look-alikes removed) the alphabet is 82 characters, so every character adds about 6.4 bits of entropy:
Below ~60 bits a leaked password can be cracked offline on rented hardware. From 80 bits up you are comfortable, and with a password manager extra length costs you nothing. No password generated here leaves your browser — it is never stored, sent, or logged.
About this password generator
Choose a length and which character sets to include — lowercase, uppercase, digits, symbols — and get a password drawn from your browser’s cryptographically secure random generator. That is crypto.getRandomValues, which the Web Cryptography specification requires implementations to seed from an operating-system entropy source such as /dev/urandom. An option removes the look-alike characters l, 1, I, O and 0, worth turning on for any password you will have to read off a screen, dictate over the phone, or type on a phone keyboard.
Generation is fully local. The password exists only on your screen until you copy it, nothing is transmitted, and you can load this page, disconnect from the network, and keep generating. The line under the field reports entropy in bits, computed as length × log2(pool size) — the same arithmetic a security reviewer would use, rather than a vague weak / medium / strong badge that gives you nothing to compare against.
Entropy measures the generator, not the string. A 20-character password from this page is worth about 129 bits because every character was drawn independently from a pool of 87; a 20-character password you invented yourself is worth far less, however jumbled it looks, because human choices cluster around real words, keyboard runs and predictable substitutions. The same arithmetic prices the look-alike option honestly: excluding l, 1, I, O and 0 shrinks the pool from 87 to 82 and costs about 0.09 bits per character — under 2 bits on a 20-character password, a rounding error against the readability you gain.
The current reference for password policy is NIST SP 800-63B-4, finalised on 31 July 2025, and it overturns a lot of received wisdom. Verifiers SHALL require a minimum of 15 characters when a password is the only factor (8 when it is one factor among several), SHOULD permit at least 64 characters and SHOULD accept Unicode, SHALL NOT impose composition rules such as “one uppercase and one symbol”, and SHALL NOT require subscribers to change passwords periodically — a forced change is mandated only when there is evidence the password has been compromised. Verifiers SHALL also allow password managers and autofill, and SHALL verify the whole password rather than truncating it. A site that still expires your password every 90 days and caps it at 12 characters is enforcing a policy NIST retired.
Two honest limits. This page cannot tell you whether a password has already appeared in a breach: NIST requires verifiers to compare candidates against a blocklist of known compromised passwords, and the usual implementation — Have I Been Pwned’s range API, where you send the first five characters of the SHA-1 hash and match the returned suffixes locally — still needs a network request, which this site deliberately never makes. For a string generated fresh here the check is moot; for a password you already use, run it through a manager that does the lookup. And a 20-character random string is not memorable, nor is it meant to be. Generate one strong master password or passphrase you can actually recall, then let a manager mint and store a unique password for every site.
Password entropy by length and character set
Entropy is not an opinion. If every character is drawn independently and uniformly from a pool of N possibilities, a password of length L carries L × log2(N) bits — literally the number of yes/no questions an attacker has to answer to find it. The pool depends only on which boxes you tick above.
| Character set | Pool size | Bits per character |
|---|---|---|
| Lowercase only (a–z) | 26 | 4.70 |
| Lowercase + digits | 36 | 5.17 |
| Upper + lowercase | 52 | 5.70 |
| Upper + lower + digits | 62 | 5.95 |
| All four sets on this page | 87 | 6.44 |
| All four, look-alikes excluded | 82 | 6.36 |
Multiply by length and the trade-off becomes obvious. A long lowercase-only password beats a short one that ticks every box — that is the whole of “length beats complexity” stated as arithmetic:
| Length | Lowercase only | All four sets |
|---|---|---|
| 8 characters | 38 bits | 52 bits |
| 12 characters | 56 bits | 77 bits |
| 16 characters | 75 bits | 103 bits |
| 20 characters | 94 bits | 129 bits |
| 24 characters | 113 bits | 155 bits |
| 32 characters | 150 bits | 206 bits |
Turning bits into time requires an assumption you should always state out loud, because a published “time to crack” figure is meaningless without it. Assume 10¹² (one trillion) guesses per second, a rate a well-resourced attacker can reach offline with GPUs against a fast, badly chosen hash such as unsalted SHA-1. Exhausting a 40-bit keyspace then takes about 1 second; 52 bits (8 characters, all four sets) about 75 minutes; 77 bits (12 characters) about 4.8 million years. On average a password is found after half the space has been searched, so halve those figures.
Those numbers apply only to an offline attack on a stolen password database. An online attack against a live login form is many orders of magnitude slower, because SP 800-63B-4 requires verifiers to rate-limit failed attempts; and an offline attack against a correctly salted, deliberately slow key-derivation function is far slower than 10¹²/s as well. The uncomfortable conclusion is that a hashing decision made by a site you do not control matters about as much as your password does — which is the real argument for never reusing one.
Passphrases obey exactly the same arithmetic, with words as the units. The EFF long wordlist holds 7,776 words (6⁵, so five dice rolls per word), which is log2(7776) ≈ 12.9 bits per word: six words ≈ 77 bits, seven words ≈ 90 bits. Any list of 7,776 distinct words gives the same figure in any language, provided the words are chosen at random and not by you. A six-word passphrase is therefore worth roughly the same as a 12-character random password from this page, and you can actually memorise it — which makes it the right shape for the two or three passwords you type by hand. For everything else, generate 20 characters above and paste the result straight into a password manager.
FAQ
Is it safe to generate passwords on a website?
On this one, yes: generation uses crypto.getRandomValues in your browser and nothing is transmitted. You can even load the page, go offline, and generate.
How long should a password be?
16+ characters with mixed sets for anything important. Length matters more than complexity — every extra character multiplies the cracking time.
Should I use a password manager?
Yes. Generate one strong master password here, then let a manager create and store unique passwords for every site.