Strong Password Generator
Create strong, random passwords — or a memorable passphrase — instantly. Choose a length from 8 to 128, pick which character sets to use, drop look-alike characters, and watch a live entropy readout tell you exactly how strong the result is. Everything runs in your browser using the cryptographic RNG (crypto.getRandomValues); nothing is ever uploaded.
20 chars × log₂(88 pool) ≈ 129 bits of entropy
Generated entirely in your browser from the operating system's cryptographically secure RNG (crypto.getRandomValues, with rejection sampling so there is no modulo bias). Nothing is transmitted, logged or stored on any server — no password here ever leaves this device.
What this tool is
- A free, in-browser strong password generator: random strings of 8–128 characters with your choice of uppercase, lowercase, digits and symbols, or a memorable multi-word passphrase.
- Toggle off look-alike characters (O 0 l 1 I |) for passwords you have to read or type by hand, and generate up to ten at once.
- A live entropy readout shows the real bits of randomness — computed correctly as length × log₂(pool size), or words × log₂(list size) for passphrases — plus a qualitative strength label.
- Randomness comes from the browser’s cryptographic RNG (crypto.getRandomValues) with rejection sampling, so there is no modulo bias and no predictability — not Math.random.
- Everything happens on your device. No password is ever sent to, logged by, or stored on any server; close the tab and it is gone.
What makes a password strong
The single most important property is that the password is chosen at random, and after that, that it is long. Complexity rules — “must have an uppercase letter, a digit and a symbol” — matter much less than people think, because they mostly push humans toward predictable patterns (Password1!) that an attacker’s wordlist already contains. A random password’s strength is measured by its entropy: the number of equally likely possibilities someone would have to search to be sure of finding it.
Length beats complexity — the math
Entropy for a random string is bits = length × log₂(pool size). Enlarging the character set only helps logarithmically — each character is worth log₂(26) ≈ 4.7 bits from lowercase alone, log₂(62) ≈ 5.95 bits with upper, lower and digits, and log₂(94) ≈ 6.55 bits once symbols are added — whereas every extra character adds that fixed amount again. So length scales entropy linearly and the character set only shifts the per-character rate:
- A 12-character password over a 94-character pool ≈
79 bits— strong. - A 16-character password over the same pool ≈
105 bits— very strong. - A 20-character password (this tool’s default) ≈
131 bits— far beyond brute-force reach.
As a rule of thumb: under 40 bits is weak, 60–80 bits is strong for everyday accounts, and 80 bits or more comfortably resists offline cracking of a properly hashed password. These bit counts only count if the password is actually random — a 12-character password you made up yourself has far less real entropy than 12 random characters, because human choices are guessable.
Why client-side and a real CSPRNG matter
A password you only trust if it is generated locally. This tool runs entirely in your browser and makes no network request, so the secret is never transmitted, logged or stored anywhere — there is nothing to intercept and no server-side copy to leak. The randomness comes from crypto.getRandomValues, the browser’s cryptographically secure RNG seeded by the operating system, and when mapping those random numbers onto the character set we use rejection sampling so every character is equally likely. Naïvely doing random % poolSize introduces modulo bias when the pool size does not divide evenly into the random range, making some characters slightly more likely and quietly reducing entropy; rejection sampling avoids that. We never use Math.random, which is fast but predictable and must never be used for anything secret.
Passphrases vs. random strings
A passphrase is several randomly chosen words joined together, like anchor-lilac-teapot-raven-vigil. Its entropy is words × log₂(list size). A word from the well-known EFF 7776-word list is worth about log₂(7776) ≈ 12.9 bits, so six words give roughly 77 bits. This tool ships a compact 289-word list so it can stay completely offline — that is about 8.2 bits per word, so you want more words (around eight to ten) for a very strong passphrase. The live readout shows exactly where you land. Use a passphrase for something you have to type or remember (a master password, a device login); use a long random string for secrets you only ever paste from a manager.
Use a password manager, and never reuse
The strongest password in the world does not help if you reuse it: one breached site then unlocks all the others (credential stuffing). The practical system is a unique random password for every site, stored in a password manager so you only have to remember one strong master passphrase, plus multi-factor authentication wherever it is offered. You do not need to memorise a 20-character string — let the manager hold it and generate a fresh one here per account.
What NIST 800-63B actually says
- Favour length. Allow a minimum of at least 8 characters and support long ones (at least 64), and accept all printable characters including spaces and Unicode.
- Drop composition rules. Do not force a specific mix of character types — it mostly produces predictable patterns.
- No forced rotation. Do not expire passwords on a schedule; change them only on evidence of compromise.
- Screen against breaches. Reject new passwords found in known-breached or common-password lists.
Security note: Because this generator is fully client-side, a password is only ever as safe as the device and browser you run it in — generate on a machine you trust, and move the result straight into a password manager rather than leaving it in your clipboard or a text file. The entropy figure is a measure of resistance to guessing, not a guarantee; pair a strong, unique password with multi-factor authentication.
Frequently asked questions
What makes a password strong?
Length matters far more than complexity. The strength of a random password is its entropy — the number of equally likely possibilities an attacker would have to search — and entropy grows linearly with length but only logarithmically as you enlarge the character set. Each extra character adds a fixed number of bits (about 6.6 bits per character for a 94-character pool of upper, lower, digits and symbols), so a long password from a smaller set usually beats a short password from a larger one. A 16-character random password over a 94-character pool has roughly 105 bits of entropy, which is far beyond what any realistic attacker can brute-force. Beyond randomness, a strong password is also unique (never reused on another site) and not based on a dictionary word, name or date that a targeted guess could reach quickly.
What is entropy, and how many bits do I need?
Entropy measures unpredictability in bits: n bits means 2^n equally likely passwords, so each added bit doubles the attacker’s work. For a random string, entropy equals length × log₂(pool size); for a passphrase it equals (number of words) × log₂(word-list size). As a rough guide, under 40 bits is weak, 60–80 bits is strong for most accounts, and 80 bits or more is very strong and comfortably resists offline cracking of a well-hashed password. This is why the default here is 20 characters: over the full symbol pool that is about 131 bits. Entropy only counts if the password is actually generated at random — a 12-character password you invented yourself has far less real entropy than 12 random characters, because your choices are predictable.
Is a passphrase better than a random string?
Neither is strictly better — they trade memorability for density. A passphrase of several random words (think “anchor-lilac-teapot-raven-vigil”) is much easier to remember and type, and with enough words it is just as hard to guess, but each word adds only log₂(list size) bits, so you need more of them. A word drawn from the well-known EFF 7776-word list carries about 12.9 bits, so six words give roughly 77 bits. This tool ships a compact 289-word list (about 8.2 bits per word) so it can stay fully offline, which means you want more words — around eight to ten — for a very strong passphrase; the live readout tells you exactly where you are. For secrets you never type (stored only in a password manager), a long random string is simplest; for a master password or a login you type often, a passphrase is friendlier.
Is this safe — are the passwords sent anywhere?
No. The generator is 100% client-side: it runs in your browser’s JavaScript and never makes a network request, so the passwords are never transmitted, logged or stored on any server. The randomness comes from crypto.getRandomValues, the browser’s cryptographically secure pseudo-random number generator seeded by the operating system — the same class of RNG used for cryptographic keys — and we use rejection sampling when mapping those random values onto the character set so every character is equally likely (no modulo bias). We deliberately do not use Math.random, which is fast but not cryptographically secure and must never be used for secrets.
What does NIST recommend for passwords?
NIST Special Publication 800-63B modernised password guidance and largely overturned the old rules. It recommends allowing long passwords (at least 8 characters minimum, and supporting at least 64), permitting all printable ASCII and Unicode characters including spaces, and NOT imposing composition rules such as “must contain an uppercase letter and a symbol” — those rules push people toward predictable patterns like “Password1!”. It also recommends against forced periodic rotation (change passwords only on evidence of compromise), and instead checking new passwords against lists of known-breached and common passwords. The practical takeaways: favour length, use a unique random password or passphrase per site, store them in a password manager, and turn on multi-factor authentication wherever you can.