Password Generator
A 16-character password from an 82-character pool carries 101.7 bits of entropy, rated strong or better by every standard. A 12-character one has about 76.3 bits, and 128 bits is the point of being uncrackable. Length adds more security than symbols do.
| Entropy per password | |
| Strength | |
| Character pool size | |
| Guesses needed (average) |
Generated with your browser's cryptographic random number generator. Nothing is sent to a server, so these passwords exist only on this device.
Create strong, random passwords right here. Choose the length and which character types to include,
Key takeaways
- 16 characters from an 82-character pool = 101.7 bits of entropy
- 12 characters gives about 76.3 bits, still strong
- 80 bits is strong for most accounts; 128 bits is uncrackable
- Symbols add entropy, but length adds far more
- NIST advises against forcing a change every 90 days
On this page
- Length beats complexity: how password entropy works
- What each entropy level means in practice
- Worked example: 12 vs 16 vs 20 characters
- Why we use the Web Crypto API instead of Math.random
- What NIST SP 800-63B recommends
- Look-alike characters and when to exclude them
- Passphrases vs random strings: which should you pick?
Length beats complexity: how password entropy works
Every password has a measurable strength called entropy, and it is the number of bits the tool shows you. Entropy is calculated from two things: how long the password is, and how big the pool of characters it was drawn from. The formula is simple,
entropy (bits) = length × log2(pool size)
The pool is the count of distinct characters available. Lowercase only is 26, adding uppercase makes 52, adding digits makes 62, and adding symbols pushes it higher still. This generator's pool is 87 characters with every type on, or 82 if you also exclude the look-alike characters I, l, 1, O and 0.
Because length multiplies the logarithm, adding characters is far more powerful than adding complexity. Going from lowercase-only to all four character types roughly doubles the entropy of a 12-character password. But adding just four more characters to that same password multiplies it by more than sixteen, 24 times, because four extra bits double the space four times over. That is why the modern advice is blunt: make it longer first, fancy second. A 20-character lowercase passphrase is stronger than an 8-character mix of everything.
What each entropy level means in practice
Entropy only matters against a realistic attacker, and the benchmark to keep in mind is that modern offline cracking hardware can test on the order of billions to hundreds of billions of guesses per second against a fast, unsalted hash. Against a properly hashed password on a live login page, rate limiting makes the real number far lower. This generator labels strength with the usual thresholds:
| Entropy | Label | What it means |
|---|---|---|
| Under 40 bits | Weak | Crackable in minutes to hours with consumer hardware |
| 40-59 bits | Fair | Survives casual attacks, not a determined one |
| 60-79 bits | Strong | Safe for most accounts today |
| 80+ bits | Very strong | Out of reach of any realistic brute-force attack |
As a rule of thumb, 60 bits is the practical floor for anything that matters and 80 bits is where you stop worrying. The tool also shows the average number of guesses an attacker would need, that is 2 raised to the power of (entropy minus one), because on average they find the password halfway through the space.
Worked example: 12 vs 16 vs 20 characters
Let us hold the character pool fixed at 82 (all four types, look-alikes excluded) and change only the length. The widget's own formula gives these figures:
| Length | Entropy | Average guesses | Verdict |
|---|---|---|---|
| 8 characters | 50.9 bits | ~1.1 × 1015 | Fair, too short |
| 12 characters | 76.3 bits | ~4.6 × 1022 | Strong |
| 16 characters | 101.7 bits | ~2.1 × 1030 | Very strong |
| 20 characters | 127.2 bits | ~9.4 × 1037 | Very strong |
Read the jumps carefully. Going from 12 to 16 characters, four more keystrokes, multiplies the average work by about a hundred million. Going from 16 to 20 multiplies it again by about forty million. That is the whole argument for length in one table: each additional character is a fixed multiplicative gain, and four of them compound into an astronomical one. For a password you will store in a manager and never type by hand, 16 to 20 characters costs you nothing and buys an enormous margin.
Why we use the Web Crypto API instead of Math.random
JavaScript has two sources of randomness, and only one of them is safe for passwords.
Math.random() returns a floating-point number from a fast pseudo-random generator. It is fine for animation jitter or picking a random color, but it is seeded predictably and its output can be reconstructed. A password built from Math.random() is not truly random no matter how long it is.
This generator uses crypto.getRandomValues(), part of the Web Crypto API. It draws from the operating system's cryptographically secure random number generator, the same class of source the browser uses for TLS keys, and is designed to be unpredictable even to an attacker who knows everything about your machine. It is available in every current browser and requires no download or plugin.
There is a subtlety in how the numbers are converted. Taking a raw 32-bit value and applying % poolSize would bias the result toward the first characters in the pool, because 232 is not evenly divisible by most pool sizes. This generator rejects any value in the uneven tail and draws again, so every character has an identical chance of appearing.
What NIST SP 800-63B recommends
The US National Institute of Standards and Technology publishes the rules that most modern login systems follow. Its guidance, in NIST SP 800-63B, overturned a lot of old advice:
- Stop forcing periodic changes. No more “reset every 90 days”. Forced rotation pushes people toward predictable variations, so NIST recommends changing a password only when there is evidence of compromise.
- Do not require arbitrary complexity. Rules like “one uppercase, one digit, one symbol” are out. Length is what matters; NIST sets an 8-character minimum and explicitly recommends allowing passwords up to at least 64 characters.
- Check against known-breached lists. Systems should compare new passwords against lists of passwords exposed in past breaches and reject matches, rather than demanding a symbol nobody remembers.
- Allow the full character set. All printable ASCII, the space character and Unicode should be accepted, and the password should not be silently truncated.
- Use rate limiting and multi-factor. Throttling login attempts and offering two-factor authentication protect an account more than any complexity rule.
The takeaway for you as a user: pick a long, unique password per site, store it in a manager, and turn on two-factor authentication. The OWASP Authentication Cheat Sheet gives the matching practical rules for developers building the login side.
Look-alike characters and when to exclude them
Look-alike characters are the ones that are hard to tell apart in many fonts: capital I, lowercase l, the digit 1, capital O and the digit 0. Excluding them removes two characters from the uppercase set, one from lowercase and two from the digits, shrinking the pool from 87 to 82.
That reduction costs you little entropy, at 16 characters it is the difference between 103.1 and 101.7 bits, both comfortably “strong”. What you gain is a password you can read off a screen and retype correctly on the first try, which matters whenever a password is entered by hand: a device setup screen, a Wi-Fi login, a printed recovery code.
For a password that will live only inside a password manager and be pasted, exclusion is unnecessary and you might as well keep the full pool. For one you will read aloud, type from paper or copy between a phone and a TV, excluding the look-alikes is the better trade.
Passphrases vs random strings: which should you pick?
A passphrase is a string of several random words, like copper-otter-mango-violet. It is longer but easier to remember, and it can be just as strong as a short random string because entropy depends on the size of the pool you drew from, not on how the result looks.
Say you pick four words at random from a list of 7,776 common words, the size of the famous Diceware list. Each word contributes log2(7,776) ≈ 12.9 bits, so four words give about 51.7 bits and six words about 77.5 bits. To reach the 80-bit “strong” line you want six or seven words. By contrast, a 16-character random string from an 82-character pool already carries 101.7 bits.
So a random string of the same length is stronger, because its character pool is bigger than the word pool. The trade is memorability. Use a passphrase for the one password you have to remember by heart, your password manager's master password, and use long random strings for everything you let the manager store and fill for you.
Frequently asked questions
How long should a password be?
For anything important, 16 characters or more. Length matters far more than complexity, because every extra character multiplies the number of guesses an attacker has to make. A 12-character password mixing letters, numbers and symbols is decent, 16 is strong, and 20 or more is strong. For a master password or a password you will store in a manager, go as long as the site allows.
Is this password generator safe to use?
Yes. The generator runs entirely in your browser and uses the Web Crypto API, which pulls randomness from the operating system's cryptographic source rather than from a predictable seed. Nothing is sent over the network, so the password exists only on your device and only until you close the tab.
What does the entropy number mean?
Entropy measures how many guesses an attacker would need on average, expressed in bits. Each extra bit doubles the search space, so 40 bits is weak, 60 bits is moderate, 80 bits is strong for most accounts, and 128 bits is effectively uncrackable with today's hardware. The number is calculated from the password length and the size of the character pool you selected.
Should I include symbols and numbers?
Yes, when the site allows it, because they enlarge the character pool and therefore the entropy. Symbols also satisfy the complexity rules many sites enforce. The one exception is when a site rejects certain symbols, in that case, turn symbols off rather than risk a rejected password, and make the password longer instead.
What are ambiguous characters and why exclude them?
Ambiguous characters are ones that look alike in many fonts: capital I, lowercase l, the digit 1, capital O and the digit 0. Excluding them makes a password much easier to read and retype from a screen or a piece of paper. The cost is a slightly smaller character pool, which the generator accounts for in the entropy figure.
How often should I change my passwords?
Current guidance from NIST and most security experts is not to rotate passwords on a fixed schedule, because forced changes lead people to pick weak variations. Instead, use a unique long password for every account, store them in a password manager, turn on two-factor authentication, and change a password immediately if a service you use reports a breach.
How many bits of entropy is a 16-character password?
With this generator's default settings - all four character types with look-alike characters excluded, a pool of 82 - a 16-character password carries about 101.7 bits of entropy. That is far past the 80-bit mark considered out of reach of brute force. Turn off look-alike exclusion and the pool rises to 87, giving about 103.1 bits.
How many guesses would it take to crack a 12-character password?
From an 82-character pool, a 12-character password has about 76.3 bits of entropy, so an attacker would need an average of 2 to the power of 75 - roughly 4.6 times 10 to the 22nd - guesses. At a billion guesses per second that is about 1.5 million years. Add four more characters and the average work rises to around 2.1 times 10 to the 30, an increase of about a hundred million times.
Is a 12-character password still safe?
For most accounts, yes - 12 characters from a full character pool gives about 76 bits, comfortably in the 'strong' range. The reason to go to 16 is margin: it costs nothing when a password manager fills it in, and it protects you if a service is breached with weak hashing. For a master password or an email account, use 16 or more.
What is the character pool size and why does it matter?
The pool is the number of distinct characters the generator can choose from. This tool uses 26 uppercase letters, 26 lowercase, 10 digits and 25 symbols. With every type on the pool is 87; excluding the look-alike characters I, l, 1, O and 0 drops it to 82. A larger pool means more entropy per character, but length still matters far more.
Should I use a password manager?
Yes. A manager lets you use a long, unique password on every site without memorizing any of them, which is exactly what security guidance recommends. You only have to remember one strong master password - make it a long passphrase - and the manager generates and fills the rest.
Do I need to change my password every 90 days?
No. NIST SP 800-63B explicitly advises against forced periodic rotation, because it pushes people toward weak, predictable variations like 'Summer2026!'. Change a password when a service reports a breach or you have reason to think it is compromised - not on a calendar.
Can anyone see the passwords I generate here?
No. The passwords are created by JavaScript in your browser using the Web Crypto API, and nothing is sent over the network. There is no server call, no logging and no storage, so the only copy is the one on your screen until you close the tab. That is also why they are not saved for you - copy them into your password manager before you leave.
What is a passphrase and is it stronger than a random password?
A passphrase is several random words joined together, like 'copper-otter-mango-violet'. Four words from a 7,776-word list give about 51.7 bits; six words give about 77.5. That is strong, but a 16-character random string from an 82-character pool gives about 101.7 bits, so the random string is stronger at a similar length. Passphrases win on memorability, which makes them ideal for the one master password you keep in your head.
Spotted a wrong number or a broken result?
More Developer tools
Fee schedules, rates and rules change without notice. Always confirm important figures with the official source before you rely on them.