Password Generator — Strength You Can Check, Not Just Trust
Generate passwords whose strength is a measured number, not a vibe. Random passwords with unbiased CSPRNG sampling, memorable passphrases from the full 7,776-word EFF list, and a pronounceable mode for passwords you have to say out loud — every mode shows its exact entropy in bits and crack-time estimates with the guess rates printed beside them. Everything runs in your browser; nothing you generate is ever transmitted or stored.
Editable — the pool size and entropy update live as you type.
Randomness comes from crypto.getRandomValues — your operating system's secure random source. Math.random is never used.
Characters are picked by rejection sampling, so every character is exactly equally likely — no modulo bias.
Nothing you generate is sent anywhere. Verify it: open DevTools → Network, then generate — no request carries a password.
Clipboard hygiene: a copied password stays on your clipboard until something replaces it. Clear it once you have pasted.
Nothing yet — press Generate and the batch is kept here for this session, in case you navigate away before pasting.
How to Use
- 1Pick a mode: Random for passwords a manager will store, Passphrase for one you must memorise, Pronounceable for one you must say aloud or type on a TV.
- 2Set the length (or word count) and character types, and watch the exact entropy in bits update as you change the settings.
- 3Press Generate, then check the crack-time table — judge your password against the scenario that matches the account.
- 4Copy the password straight into the site or your password manager. Never reuse it for another account.
- 5Clear your clipboard when you have pasted, and turn on two-factor authentication for the account.
Key Features
- ✓
Unbiased randomness — rejection sampling, not modulo
Many generators quietly skew their output: they draw a random 32-bit number and take it modulo the pool size, which over-represents the first characters of the pool whenever 2^32 doesn't divide evenly by it. This generator rejects any draw that falls in the incomplete final block, so every character in the pool has exactly the same probability — the property the entropy figure on the page assumes. The randomness itself comes only from crypto.getRandomValues, your operating system's CSPRNG. Math.random, a predictable pseudo-random generator, is never touched.
- ✓
Exact entropy, even with guarantees switched on
Tick 'require every selected type' and most tools keep quoting the naive length × log2(pool) figure — but guaranteeing a digit, a symbol, an upper and a lower shrinks the space of possible passwords, so the honest number is smaller. This tool counts the constrained space exactly, by inclusion–exclusion over the character classes, and prints that figure. The same rigour applies to 'no duplicate characters', which is priced with falling factorials (permutations), and to passphrases, priced from the real size of the wordlist. Every number on the page is a count, not an estimate dressed as one.
- ✓
A real passphrase mode — the full EFF list, stated size
Passphrase generators are only as strong as their wordlist, and some popular ones draw from a few hundred hidden words, which silently caps your entropy no matter how many words you stack. This one bundles the Electronic Frontier Foundation's large wordlist verbatim and unmodified: 7,776 words, each contributing 12.92 bits. Four words give 51.7 bits, six give 77.5 — the EFF's own recommendation for a master password. Separators, capitalisation and optional digit/symbol extras are all priced into the displayed figure, bit for bit.
- ✓
Crack times with the assumptions printed next to them
A single 'time to crack' number is meaningless without the guess rate behind it — the same password falls in hours to an offline GPU rig and outlives the universe against a throttled login form. So the estimate table shows four scenarios side by side: online throttled (100 guesses/hour), online unthrottled (10/second), offline against a slow hash like bcrypt (10 thousand/second) and offline against a fast hash like MD5 (100 billion/second). Each figure is the average case — half the space — and is labelled an estimate, because that is what it is.
- ✓
Bulk generation where every row carries its strength
Generate up to 100 passwords in one click for team onboarding, test fixtures or a password-manager import. Every row shows the entropy of the settings that produced it — a batch of 6-digit PINs is honestly labelled as weak as a batch of 32-character secrets is labelled excellent — and the whole set copies as one block or downloads as a .txt file. Presets cover the recurring jobs: everyday accounts, maximum security, Wi-Fi passkeys, URL-safe API secrets, easy-to-type passwords with look-alikes removed, and PINs.
- ✓
Nothing leaves the browser — and history is your choice
Generation happens entirely in this tab. No password is transmitted, logged or stored on any server — a claim you don't have to take on faith: open your browser's DevTools Network panel, generate, and watch nothing leave. The session history exists only to rescue a password you generated before navigating away; it lives in tab memory and dies with the tab. Keeping it on the device is an explicit opt-in toggle with its warning printed beside it, off by default, wipable in one click. There is no account, no vault and no premium tier.
Frequently Asked Questions
How are the passwords generated?
Is any generated password sent to, or stored on, a server?
How long should my password be?
Random password or passphrase — which should I use?
What does the entropy figure in bits actually mean?
How accurate are the crack-time estimates?
What does 'exclude ambiguous characters' do, and when do I need it?
Can I use these passwords for work or commercially?
What actually makes a password strong: entropy, not complexity theatre
A password's strength is the size of the space an attacker has to search, measured in bits of entropy. Every bit doubles the work. A password drawn uniformly at random from a pool of P characters at length L has L × log₂(P) bits — which is why length beats cleverness: adding one character to a password from the full 88-character pool adds about 6.5 bits, while swapping a letter for a symbol inside the same length adds a fraction of that. Current NIST guidance (SP 800-63B) lands in the same place: it dropped mandatory complexity rules and periodic rotation in favour of length — at least 15 characters for a password used on its own — because forced complexity made people predictable, not safe. The defaults here follow that evidence: 20 characters, all four character types, one of each guaranteed. That is 129.2 bits by the naive formula and a slightly lower, exactly counted figure once the guarantee is priced in — and the tool shows you the honest one.
How these passwords are generated — and how to verify it yourself
Three properties separate a generator you can rely on from one you merely hope about. First, the randomness source: this tool uses crypto.getRandomValues, the Web Crypto API backed by your operating system's entropy pool — the same source browsers use for TLS. It never uses Math.random, whose output can be predicted from a handful of observed values. Second, the sampling: random values are mapped to characters by rejection sampling. Draws are taken from a 32-bit space; any draw at or above the largest multiple of the pool size is discarded and redrawn, so no character is ever favoured. Third, the guarantee step: when "require every selected type" is on, one character is drawn from each class first, the rest are filled from the full pool, and the whole string is Fisher–Yates shuffled with the same CSPRNG so the guaranteed characters sit in uniformly random positions. None of this needs trusting: the generation code path contains no network call at all, and the Network panel in your browser's DevTools will confirm that generating a password produces no request carrying it — the page works fully offline once loaded, and installs to your home screen as a standalone app for exactly that use.
Passphrases: when the password has to live in your head
A random 20-character password belongs in a password manager. The one password you cannot store anywhere — the manager's own master password, or a disk-encryption passphrase — has to be memorised, and that is what the passphrase mode is for. It follows the Diceware method: words drawn uniformly at random from the EFF's large wordlist. The arithmetic is transparent: the list has 7,776 words, so each word adds log₂(7,776) ≈ 12.92 bits; five words give 64.6 bits, six give 77.5, seven give 90.4. Because the words are common and concrete, a six-word phrase is genuinely memorisable in a way that 20 random characters are not, while remaining far beyond brute force. Two cautions the tool is honest about: capitalising words adds no entropy (it is a display choice, priced at zero), and a passphrase's strength collapses if you pick the words yourself — human-chosen "random" phrases cluster on famous quotations and song lyrics. Let the dice fall where they may. For the accounts that support it, a passphrase plus the 2FA authenticator is stronger than either factor alone.
Reading the crack-time table without fooling yourself
The estimates on this page assume the attacker knows exactly how the password was generated — pool, length, mode — and simply grinds through the space, succeeding after half of it on average. That is the correct conservative assumption for a generated password, and it is why the figures are honest where a consumer "strength checker" fed a human password is guessing. What the table cannot know is which scenario you are actually in, and the spread is enormous: the difference between the throttled-online row and the fast-hash-offline row is thirteen orders of magnitude. The lesson cuts in a direction most people don't expect — once a password passes roughly 70–80 bits, the website's hashing algorithm matters more than your password does. A 128-bit password in a database hashed with raw MD5 is a bigger risk than a 77-bit passphrase behind Argon2. Practically: generate long, make every account's password unique so one breach can't cascade, and treat any service that caps your password at 12 characters or emails it back to you in plaintext as a service to give the least valuable identity you have. Developers generating credentials for systems rather than people can pair this tool with the UUID generator for identifiers and the JWT decoder when debugging the tokens those credentials protect.
What this tool deliberately does not do
Three popular features were left out on purpose, and the reasons are part of the security model. There is no server API: the moment a password is generated anywhere other than your own device, it has crossed a network and existed in someone else's memory and logs — the entire point of a generator is that exactly one copy of the secret exists until you save it. There is no built-in vault: a web page is the wrong place to warehouse the keys to your life; use a dedicated password manager with audited encryption, sync and recovery, and let this tool do the one job it can do perfectly. And there is no zxcvbn-style score for passwords you type in: estimators that guess how a human picked a password are the right tool for auditing human choices, but for machine-generated passwords the exact combinatorial count is available, so an estimate would be a downgrade disguised as a feature. The Base64 encoder is the right companion when a generated secret needs encoding for transport — remembering, of course, that encoding is not encryption.
A short, complete password routine
Generate a unique password for every account — reuse is the single habit that turns one site's breach into your whole digital life. Store them in a password manager protected by a six-word passphrase from this page. Turn on two-factor authentication everywhere it is offered, preferring an authenticator app or passkey over SMS. When a breach notice arrives, that account's password — and only that one, because it is unique — gets regenerated here at 20+ characters. Keep a copy of nothing in your email, your notes app or a spreadsheet. That routine, followed consistently, removes you from the reach of credential stuffing, password spraying and offline cracking alike — which is to say, from essentially every password attack that actually happens.
Related Tools You Might Like
Handy utilities in Developer Tools
2FA Authenticator
Generate TOTP 2FA codes online free — multi-account board, SHA-1/256/512, 6/8 digits, otpauth import, bulk import, QR export, code checker. 100% client-side, secrets never leave your browser.
UUID Generator
Generate random, high-entropy UUIDs (v4 and v7) online for free. Generate single or bulk unique identifiers instantly. Cryptographically secure and private.
JWT Decoder & Verifier
Free JWT decoder and verifier: decode header, payload and claims, check expiry with a live countdown, and verify HS256/RS256/ES256 signatures in your browser. Tokens never leave your device.