A password generator with cryptographic-grade randomness.
Generate random passwords or Diceware-style passphrases using the Web Crypto API — the same primitive your browser uses for TLS. Bulk-generate up to 50 at a time. Nothing is uploaded; nothing is logged.
20Drops Il1O0 — useful when the password will be read aloud or printed.
Every password is generated in this browser tab using `crypto.getRandomValues` — the same CSPRNG the engine uses for TLS handshakes. The page makes no network calls. We never see anything you generate, and nothing is logged.
Cryptographic randomness, with the trade-offs explained.
A generator that uses the Web Crypto API correctly (no `Math.random`, no modulo bias), supports both random strings and passphrases, and shows you the entropy so you can pick a length that actually matters.
All randomness comes from `crypto.getRandomValues`, the CSPRNG built into the browser. `Math.random` is fine for animations and shuffling cards; it is not fine for secrets — predictable from a few outputs and not designed to be cryptographically secure.
Naïve `byte % alphabet.length` over-represents low values when the alphabet size does not evenly divide 256. We use rejection sampling — discard bytes outside the largest evenly divisible range, draw again — so every character has exactly 1/N probability.
Random for compact, high-entropy strings (DB roots, API tokens). Passphrase for human-readable, type-able secrets that still hit 60+ bits at 5 words. Pick the one that matches the threat model and the typing context.
Each password shows its entropy in bits — `log2(alphabet)·length` for random, `log2(wordlist)·words` for passphrases. 60+ bits resists offline cracking by current hardware; 80+ is comfortable.
Generate 1, 10, 25, or 50 at a time. Useful for seeding multiple service accounts or onboarding a team — copy the full list with one click.
Drops `I`, `l`, `1`, `O`, `0` — the characters that look identical in many fonts. Use when a password will be read aloud, printed on a sticker, or transcribed from a screenshot.
Passphrase mode draws from ~250 short, common English words. Long enough that 5 words gives ~40 bits of entropy; short enough that the result is type-able. Bundled inline — no third-party fetch.
Use anonymously, on as many passwords as you want. No account, no history, no telemetry. Inspect the network tab — there is nothing outbound to inspect.
Wherever a fresh secret is the right answer.
A 24+ character random string with the full symbol set hits ~150 bits of entropy — well past brute-force territory. Use random mode; reach for the password manager and forget you ever saw it.
Most server-side secrets live in env vars and never get typed. Random mode at 32–48 chars gives ample entropy with minimal pain — copy once, stash in your secrets manager.
Backups need a passphrase that survives without a password manager — usually written down, sometimes recited. Use passphrase mode at 6–7 words for ~75 bits of entropy that you can actually remember.
Passphrase mode with hyphen separators reads cleanly off a card on the reception desk. 5 words covers most cafe / office threats; capitalize each word for a slight entropy bump.
When you need to exercise a signup flow with a real-looking password — random mode at 16 chars, no symbols (simpler validation rules), copy and paste.
Set bulk count to 25 and generate one fresh password per onboarded engineer. Each is delivered through your team password manager; users rotate on first login.
Random passwords, the plain answers.
`Math.random` is a non-cryptographic pseudo-random number generator. Its internal state is not seeded with high-quality entropy and does not resist prediction — given a handful of outputs, an attacker can derive the seed and predict every future output. The browser intentionally exposes a separate API (`crypto.getRandomValues`) for security-sensitive randomness, backed by the same CSPRNG the OS uses for TLS keys.
Entropy in bits is the log-base-2 of the number of equally likely possibilities — so 60 bits means the password is one of 2^60 ≈ 10^18 possibilities. Modern offline cracking hardware does ~10^11 guesses/second against bcrypt or argon2; a 60-bit password takes ~10^7 seconds (~4 months) to exhaust. 80+ bits puts you comfortably out of reach.
Same entropy, different ergonomics. A 5-word passphrase from a 250-word list gives ~40 bits — equivalent to a 7-character mixed-case alphanumeric. But humans actually remember and type passphrases. For secrets that have to live in a head (laptop login, full-disk encryption recovery), passphrases reach high entropy without being unusable.
~250 short, common English words curated for memorability and absence of confusable spellings (no homophones, no profanity). Inspired by the EFF short word list. The whole list is bundled inside this page; no external fetch.
No. Generation runs entirely in this browser tab. The page makes no network calls related to the passwords you generate — nothing is logged or transmitted. Open DevTools → Network and watch while you generate; you will see nothing outbound.
`crypto.getRandomValues` is a Web standard implemented by every major browser, sourced from the OS-level CSPRNG (`/dev/urandom` on Unix, `BCryptGenRandom` on Windows). It is the same primitive the engine uses internally to derive TLS session keys. If you do not trust it, you cannot trust HTTPS.
Need a place to store the secrets these protect?
Sign up for the free tier and you get $100 in credits, plus VMs, managed databases, object storage, and zero-config autoscaling across four regions.