Password Generator
How to create a strong password — and what this generator does differently
A password is only as strong as the number of guesses it takes to find it. This generator makes passwords from a cryptographic random source, tells you exactly how big the guess space is in bits, and shows how long that space takes to search under three real attack scenarios — instead of one comforting adjective. Everything runs in your browser: the page never sends a password anywhere, has no account, and works offline once loaded.
What happens when you press Generate
- 1
Your browser's Web Crypto API (crypto.getRandomValues) produces the random numbers — the same source password managers use. Nothing is derived from the clock or a seed you could reproduce, and no request leaves the page.
- 2
Every character is drawn uniformly from the pool you chose, with rejection sampling so no character is more likely than another. A 20-character password with all four classes has 90 possible characters per position — about 130 bits.
- 3
At least one character from each class you turn on is guaranteed and then shuffled into a random position, so a password never fails a site's 'must contain a number' rule while costing almost no entropy.
- 4
The strength shown is computed from how the password was built, not from how it looks. That is why a 5-word passphrase and a 12-character random string can show the same bits with very different shapes.
Entropy: the only number that matters
Entropy is the size of the space an attacker has to search, expressed in bits: each extra bit doubles the number of guesses. It depends on the length and on how many possibilities each position had — not on whether the result 'looks random'. A 12-character password drawn from 90 characters has 90¹² ≈ 2⁷⁸ possibilities; a 5-word passphrase from a 7,776-word list has 7,776⁵ ≈ 2⁶⁵. The table below is computed live by the same engine as the generator above.
| Password | Bits | Online (100/s) | Leaked, slow hash (100k/s) | Leaked, fast hash (100 bn/s) |
|---|---|---|---|---|
| 8 lowercase letters | 38 | 66 years | 24 days | 2 seconds |
| 8 chars, all types | 52 | 1 million years | 1 thousand years | 12 hours |
| 12 chars, all types | 78 | older than the universe | older than the universe | 89 thousand years |
| 16 chars, all types | 104 | older than the universe | older than the universe | older than the universe |
| 20 chars, all types | 130 | older than the universe | older than the universe | older than the universe |
| 4-word passphrase | 52 | 1 million years | 1 thousand years | 10 hours |
| 6-word passphrase | 78 | older than the universe | older than the universe | 70 thousand years |
| 6-digit PIN | 20 | 3 hours | 10 seconds | instantly |
Times are the worst case for the attacker (the whole space); on average a password is found half-way through. 'Online' is a login form with rate limiting. 'Leaked' means the site's database was stolen and the attacker guesses against the stored hashes on their own hardware — the speed then depends entirely on how the site hashed passwords, which you cannot see, so assume the fast case.
Three attackers, three answers
100/ s
Online guessing
Online guessing. The attacker types guesses into the real login form. Rate limits, lockouts and CAPTCHAs cap this at perhaps a hundred guesses a second, often far fewer — an 8-character random password already takes centuries here. This is the scenario a PIN is designed for, and the only one it survives.
100,000/ s
Leaked, slow hash
Offline, slow hashing. The site's database leaked, but passwords were stored with a deliberately slow algorithm (bcrypt, scrypt, Argon2). A GPU manages tens of thousands of guesses a second per hash. Sixty bits — a 10-character random password or a 5-word passphrase — takes decades.
100,000,000,000/ s
Leaked, fast hash
Offline, fast hashing. The database leaked and passwords were stored with MD5, SHA-1 or NTLM, or without any hashing. A single GPU rig tries a hundred billion guesses a second. This is where '8 characters with a symbol' dies in hours and where 80 bits and up is the floor worth aiming for — because you never know which kind of site you are on.
Random, passphrase or PIN — which to use
Random characters
The most entropy per character. Use for anything a password manager will type for you: websites, apps, Wi-Fi networks, API keys. At 16 characters with all classes you are past 100 bits; at 20 there is no scenario in which it is the weak point.
Passphrase
Words chosen at random from a 7,776-word list, each worth 12.9 bits. Use for the passwords you actually have to remember or type: the master password of your password manager, a laptop login, disk encryption. Five words (65 bits) are the sensible minimum; six words (78 bits) are comfortable even against fast offline attacks — and 'correct-horse-battery-staple' is far easier to type on a phone than 'x7#Kq$2v'.
PIN
Digits only, so the entropy is tiny — six digits is under 20 bits. A PIN is safe only where the thing it protects wipes or locks after a few wrong tries: a phone, a bank card, a hardware key. Never reuse a PIN as a website password.
Seven rules that hold up
- 01
Length beats complexity. Every extra character multiplies the guess space by the pool size; a symbol requirement adds a handful of bits once. Sixteen random characters or six random words, and the debate is over.
- 02
One password per site. When one site leaks — and one will — a reused password is tried on every other service within hours (credential stuffing). Uniqueness is what a manager buys you.
- 03
Random, not clever. Substituting @ for a and adding 1! is the first thing cracking tools try. A password you designed carries the patterns of a human; a generated one carries none.
- 04
Do not rotate for the sake of it. Modern guidance (NIST SP 800-63B) says change a password when there is a reason — a breach, a shared device — not on a calendar. Forced rotation produces Summer2024!, Autumn2024!.
- 05
Turn on two-factor authentication, and prefer passkeys where offered. A strong password protects against guessing; a second factor protects against the password being stolen outright by phishing or malware.
- 06
Check where you type it. A perfect password entered into a look-alike login page is a stolen password. The address bar matters more than the symbol count.
- 07
Never send a password through a service to 'check' it. This page checks yours locally and you can verify that with the network tab of your browser; any checker that uploads the password has already leaked it.
Passwords that look strong and are not
A word with a capital and a year: Michael1987 — about 20 bits, a dictionary word plus a date, cracked instantly offline.
Leetspeak: P@$$w0rd! — every cracking tool applies those substitutions automatically; it is 'password' with a costume.
Keyboard walks: qwerty, 1qaz2wsx, asdfghjkl — in every wordlist, in every order.
A pattern plus the site name: Hunter2-amazon, Hunter2-netflix — once one leaks the scheme is obvious.
Two words and a number: bluecar42 — about 35 bits, minutes on a GPU.
Reusing a strong password. 25 random characters used on three sites are exactly as safe as the weakest of those three sites.
When a site rejects the password
'Special characters not allowed' or only some allowed — use More options → Symbols to leave out, or turn symbols off and add four characters of length instead; you lose nothing.
'Must start with a letter' — turn on Start with a letter.
'Maximum 16 characters' — set the length to the maximum the site accepts and keep all four classes; if you must go short, keep symbols on.
'Must contain a number' with a passphrase — tick Add a number to a word (or a symbol); one character satisfies the rule and adds a few bits.
A code you will read aloud or type from paper — turn on Avoid look-alikes so 0/O and 1/l/I never cause a wrong guess.
A generator is half the job
A random password you cannot remember is only useful if something remembers it for you. A password manager stores one unique password per site, fills it on the real domain (and refuses on a fake one), and needs only one strong master passphrase from you — which is exactly what the Passphrase tab is for.
Every mainstream manager — the ones built into browsers and phones included — keeps the vault encrypted with a key derived from your master passphrase, so a leak of the vault is another offline attack against that one phrase. Six random words put it at 78 bits.
Where a site offers a passkey, take it: a passkey is a cryptographic key pair that cannot be phished, reused or guessed, and it removes the password from the equation entirely. Until then, unique random passwords plus a second factor is the standard.
What this generator does that most do not
Most password generators are a lead magnet for a password manager. This one is a tool, and it is judged on the tool.
| Feature | CalculatorAI | Typical generator |
|---|---|---|
| Random, passphrase and PIN modes | Yes | Random and memorable |
| Strength as entropy in bits | Yes, from how it was built | Colour bar |
| Crack time under three attack scenarios | Online, slow hash, fast hash | One estimate or none |
| Check a password you already have | Yes, locally, with pattern warnings | Rarely |
| Exclude specific symbols, avoid look-alikes, start with a letter | Yes | Sometimes |
| Generate a list and export it | 5–50, copy or .txt | One at a time |
| Account, sign-up prompts, tracking of what you generate | None | Sign-up CTA |
| Works offline after the page loads | Yes | Usually |
Frequently asked questions
Is this password generator safe to use?
Yes. Passwords are produced by your browser's built-in cryptographic random number generator (Web Crypto) and never leave the page — there is no request that could carry them, no account and no storage of results. You can confirm that in your browser's network tab. Only your option settings (length, character types) are remembered locally so the generator opens the way you left it.
How long should a password be in 2026?
Sixteen random characters with letters, numbers and symbols (about 105 bits), or a six-word passphrase (about 78 bits), for anything that matters. Twenty random characters costs nothing extra when a password manager types it. Eight characters, whatever the mix, is no longer safe against an offline attack on a leaked database.
Is a passphrase weaker than a random password?
Per character, yes; per password, not necessarily. Each random word from the 7,776-word EFF list adds 12.9 bits, so five words are 65 bits and six are 78 — comparable to 12 random characters. The passphrase is far easier to remember and type, which is why it is the right choice for the few passwords you must know by heart, such as your password manager's master password.
What do the crack-time estimates mean?
How long it would take to try every possibility at a given speed. Three speeds are shown because the honest answer depends on the attack: guessing through a login form is slow (rate limited), guessing against a leaked database of slow hashes is fast, and guessing against fast or absent hashes is very fast. Plan for the last case, because you cannot see how a site stores passwords.
Why show entropy in bits instead of a score?
A score hides the arithmetic. Bits are the arithmetic: each bit doubles the attacker's work, 40 bits is a coffee break on a GPU, 80 bits is decades, 128 bits is beyond any foreseeable hardware. Knowing the number lets you compare a passphrase with a random string honestly.
Should I write passwords down?
In a password manager, yes — that is the point of one. On paper, only for a master passphrase or recovery codes kept somewhere physically safe. Never in a notes app that syncs unencrypted, an email to yourself, or a browser that does not lock its saved passwords behind the device login.
Does adding symbols make a password much stronger?
A little, once. Going from 62 to 90 possible characters adds about half a bit per character. Going from 12 to 16 characters adds about 26 bits. If a site limits symbols, add length instead and you are ahead.
Can I generate passwords in bulk?
Yes: choose 5, 10, 25 or 50 under the generator, then copy the list or download it as a .txt file. Every entry is generated independently with the current options. Useful for provisioning accounts or Wi-Fi guest codes.
Glossary
- Entropy
- The size of the guess space, in bits. 2ⁿ possibilities = n bits. Each extra bit doubles the attacker's work.
- Brute force
- Trying every possible combination in order. Its cost is set purely by entropy and the attacker's guess rate.
- Dictionary attack
- Trying words, names, previous leaks and their common variants first. This is why 'Michael1987' falls in seconds and why generated passwords resist it.
- Credential stuffing
- Taking email/password pairs from one leak and trying them on other sites automatically. Defeated only by unique passwords.
- Hashing
- How sites are supposed to store passwords: as the output of a one-way function. Slow hashes (bcrypt, Argon2) make guessing expensive; fast hashes (MD5, SHA-1) do not.
- Salt
- Random data added to each password before hashing, so identical passwords hash differently and precomputed tables are useless.
- Passkey
- A public-key credential stored on your device and unlocked with its biometrics or PIN. Cannot be phished or reused; replaces the password on sites that support it.
- Two-factor authentication
- A second proof beyond the password — an authenticator code, a hardware key or a passkey — so a stolen password alone is not enough.
Related tools
Made on this page with your browser's cryptographic random generator (Web Crypto). Nothing is sent, stored or logged.