🔑 Password Generator
Password Generator
Strong passwords are long and random — two things humans are bad at producing. This generator builds them with your browser's cryptographic random source, entirely on your device; nothing is transmitted or stored anywhere.
Use at least 16 characters with all character types for important accounts, and keep them in a password manager. One unique password per site beats one clever password reused everywhere.
What this password generator does — and what it never does
This page creates a strong, random password for you, right here in your browser. You choose how long it should be and which kinds of characters it may use, click Calculate, and the generator builds a password from genuinely random choices. Nothing you generate is sent to a server, stored in a database, logged for later, or shown to anyone else. The page states this plainly, and it is worth repeating in full: "Generated locally in your browser with cryptographic randomness. Nothing leaves your device."
That local-only design is not a minor detail. It is the most important security property of the tool. A password that travels across the internet before you even use it has already had an unnecessary exposure. A password born on your own device, in your own browser tab, and copied straight into the account or password manager where it belongs, has had the shortest possible journey. Close the tab and the generator forgets everything — by design, it never knew anything worth remembering in the first place.
This guide explains how the generator works, what the "bits of entropy" figure under your password actually means, why length does more for you than clever complexity tricks, and how to use the passwords you make here well — because generating a strong password is only half the job. Storing it safely and using a different one for every account is the other half.
How the generator builds your password
When you click Calculate, the generator works through four clear steps, all inside your browser.
First, it reads your settings. The Length field sets how many characters the final password will contain, and the four checkboxes set which character sets are allowed: uppercase letters A–Z, lowercase letters a–z, digits 0–9, and symbols. The full symbol set used by this page is exactly these 27 characters: !@#$%^&*()-_=+[]{};:,.<>?/~. With all four boxes ticked, the working pool is 26 uppercase + 26 lowercase + 10 digits + 27 symbols = 89 possible characters for every position in the password.
Second, it draws random numbers using cryptographic randomness. Modern browsers expose a built-in function called crypto.getRandomValues, which is designed for exactly this kind of security work — it produces numbers that an attacker cannot predict from previous outputs. The generator uses that function as its primary source of randomness. Only if a very old or unusual browser does not provide it does the page fall back to Math.random, the ordinary JavaScript random function. Math.random is fine for games and animations, but it is not designed to resist prediction, which is why it is only the fallback here and never the first choice.
Third, it guarantees coverage. A purely random draw from a mixed pool could, by bad luck, produce a password with no digit in it even though you asked for digits. To prevent that disappointment, the generator makes sure the finished password contains at least one character from every set you selected. If you tick all four boxes, your password is guaranteed to contain at least one uppercase letter, at least one lowercase letter, at least one digit, and at least one symbol.
Fourth, it shuffles. The guaranteed characters are placed into the password and then the whole string is rearranged with a Fisher–Yates shuffle, the standard, unbiased method for shuffling a list so that every ordering is equally likely. Shuffling matters more than it might seem: without it, the guaranteed digit might always land in position one, and a password with a predictable structure is weaker than its characters suggest. After the shuffle, no position is special.
The result appears in the hero row as Your password, in code formatting, with a Copy button beside it so you can move it without retyping — retyping a random password is an excellent way to mistype it, lock yourself out, and learn to hate strong passwords. Below it, the page echoes the Length you chose and shows an Estimated strength figure in bits of entropy, which the next section explains properly.
What "bits of entropy" honestly means
Entropy, in password terms, is a measure of unpredictability — how much work an attacker must do, on average, to guess your password by trying possibilities one after another. It is measured in bits, and the rule to hold on to is simple: each additional bit of entropy doubles the guessing work.
A password with 40 bits of entropy presents about a trillion possibilities. Add one bit and it is 41 bits — twice as many possibilities. Add ten bits and the work is roughly a thousand times greater. Add twenty bits and it is roughly a million times greater. That doubling is why entropy grows so deceptively fast, and why modest-sounding increases in length produce enormous real-world differences in safety.
This page calculates estimated strength with a clean, standard formula:
bits = length × log2(pool size), rounded to the nearest whole number,
where the pool size is the total number of characters your selected sets provide. The formula assumes every character is chosen independently and uniformly at random from the pool — which, thanks to the cryptographic randomness and the shuffle described above, is a fair description of what this generator does. It is the right formula for randomly generated passwords. It is not the right formula for passwords humans invent, because humans are dreadfully non-random: we pick names, dates, keyboard walks, and the same substitutions everyone else picks. A human password that "looks complex" usually carries far less real entropy than its length and character mix suggest, which is precisely why generating passwords with a tool like this one beats inventing them.
Here are the verified reference points for this generator — the same figures the widget itself displays. This table is deliberately built only from these confirmed points; use the formula above to work out any other combination you are curious about.
| Your settings | Pool size | Length | Estimated strength |
|---|---|---|---|
| All four sets on | 89 | 16 chars | 104 bits of entropy |
| Digits only | 10 | 12 chars | 40 bits of entropy |
| Lowercase + digits | 36 | 20 chars | 103 bits of entropy |
| All four sets on | 89 | 8 chars | 52 bits of entropy |
| Lowercase only | 26 | 24 chars | 113 bits of entropy |
Read that table slowly, because it overturns two common intuitions. First, the shortest entry — 8 characters with every set switched on — is not the strongest by a wide margin; it is actually the second-weakest row here, despite using the biggest pool. Second, the longest entry — 24 characters of nothing but lowercase letters, the smallest alphabet — ends up the strongest row in the table. That is not a trick. It is the formula doing exactly what it says: length multiplies, pool size only feeds a logarithm. Each extra character adds the full log2(pool) again, while widening the pool raises that per-character value only slowly.
To make the doubling concrete: the gap between the 40-bit digits-only example and the 104-bit default is 64 bits. Sixty-four doublings is not "about one and a half times harder." It is harder by a factor of roughly eighteen quintillion. Numbers that large stop meaning anything intuitive, which is exactly the point — past a certain threshold, guessing stops being a practical attack at all, and attackers move on to softer targets: reused passwords, phishing pages, and password reset flows. Your job is simply to be past that threshold everywhere, with a unique password on every account.
Why length beats complexity tricks
For years, password advice obsessed over complexity: force an uppercase here, a digit there, a symbol for luck, and ban the result from being changed for ninety days. The predictable outcome was human behaviour working around the rules — one capital at the start, one digit at the end, a exclamation mark if the system demanded a symbol, and the same base word recycled across every site with the number bumped up at each forced change. Attackers know those patterns intimately and try them early.
Length suffers from none of that. Length is the one property that adds entropy steadily, honestly, and without asking the user to be clever. Compare the verified rows again: holding the pool at the full 89 characters, going from 8 characters (52 bits) to 16 characters (104 bits) exactly doubled the entropy — eight extra characters, each contributing the same per-character share, produced a password that is harder to guess by a factor of about 2 to the power of 52. No substitution trick, no l33t spelling, no appended symbol achieves anything remotely like that. Leetspeak in particular adds almost nothing: attackers' dictionaries have contained "p@ssw0rd"-style substitutions for decades, so the transformed password is tried almost as early as the original word.
This is also why the modern recommendation for human-memorised secrets is the passphrase — several ordinary words strung together — while for everything stored in a manager, the recommendation is exactly what this page produces: a fully random string, as long as the site allows. If a site accepts 16 characters, the default here is a sound choice. If it accepts 20, 24, or more, take them — length is nearly free when a manager remembers it for you, and every extra character buys the same solid chunk of entropy as the last.
There is one honest qualification. Pool size is not irrelevant — it is just the junior partner. A digits-only PIN-style password has a pool of just 10, so each character contributes little, and even the verified 12-digit example reaches only 40 bits — respectable against casual guessing, entered by hand, and protected by lockouts, but not a figure you would want guarding an email inbox against an offline attack where billions of guesses per second are possible. Use digits-only codes where the system design expects them (and rate-limits the guesses), and use mixed, longer passwords for real accounts.
Choosing your settings on this page
The defaults are chosen to be right for a typical new account: length 16, all four character sets on, 104 bits of entropy. For most people, most of the time, you can generate with the defaults and move on. The settings earn their keep at the edges:
- Raise the length for important accounts. Email, banking, and your password manager's master password deserve more than the default. Those accounts are the keys to resetting everything else, so push the length up — the entropy rises with every character.
- Untick symbols only when a site forbids them. Some older systems ban symbols or allow only a small list. If a site rejects your generated password, unticking Symbols (or matching its rules) and adding length instead keeps the strength where it belongs.
- Match the site's maximum, not its minimum. Minimum lengths are set for the weakest password the site will tolerate, not for the protection you want. If the form silently truncates at a certain length, generate at that length — a longer password that gets cut off without telling you can cause confusing login failures later.
- Do not lower the length for convenience if a manager is storing it. Convenience arguments apply to passwords you type daily by hand. A stored password costs you nothing at 24 characters that it does not cost at 12.
Two guards protect you from settings that cannot work. If the length falls outside the supported range, the page tells you: "Length must be between 4 and 128." And if you untick every character set — leaving the generator with no characters to choose from at all — it tells you: "Select at least one character type." Both messages appear instead of a password, which is the correct behaviour: a generator should refuse rather than quietly produce something weaker than what you asked for.
After you generate: the password manager conversation
A generator solves the invention problem. It deliberately does not solve the memory problem, because that problem is unsolvable by human brains at modern scale. Nobody can memorise fifty different 16-character random strings, and any scheme that claims to let you do so — one strong base with a tweak per site, a pattern you apply mentally — reintroduces predictability or reuse through the back door.
So the workflow this page is built for is: generate here, save immediately in a password manager, and let the manager fill it in from then on. A password manager is simply an encrypted vault, unlocked by one strong master password (or your device's fingerprint or face unlock), that remembers every other password for you. That single change delivers the three habits that prevent almost all account takeovers: every password is long, every password is random, and no password is ever reused on two sites.
Re-use deserves its own paragraph, because it is the failure mode behind most real-world account losses — not mathematical brute force. When any site you have ever used suffers a breach, its password list eventually circulates. Attackers then try those exact email-and-password pairs on banks, email providers, and shopping sites automatically, a technique called credential stuffing. A unique password per site makes a breach at your least important account a non-event for your important ones. The entropy of your bank password cannot save you if it is also your forum password and the forum leaks it in plain text.
Practical closing steps each time you generate: copy the password using the Copy button, paste it into the account's change-password form, save or update the entry in your manager before you navigate away, and only then submit. If the site offers two-factor authentication, turn it on — a strong password plus a second factor is dramatically safer than either alone. And never send a generated password to yourself by email, chat, or a notes app that syncs in plain text; the manager is the only copy that should exist outside the account itself.
Common mistakes
- Reusing a generated password on several sites. Generation fixes randomness, not reuse. Generate separately for every account — it costs one extra click.
- Shortening the password "because symbols make it strong." The verified table shows an 8-character all-sets password at 52 bits, while a 20-character lowercase-plus-digits one reaches 103 bits. Length first, pool second.
- Inventing the password yourself and typing it here mentally as comparison. Human-chosen passwords follow patterns that entropy formulas for random passwords do not describe. If a human picked it, the honest entropy is far lower than the formula suggests.
- Storing generated passwords in a plain text file or screenshot. That recreates a single point of failure. Use a password manager; failing that, a trusted device's locked notes are a compromise, not a solution — label it honestly as one.
- Generating on a shared or public computer and walking away. The generation is local, but so is the clipboard and the browser history of the tab you left open. Generate private credentials on your own device.
- Assuming a strong password makes phishing impossible. It does not. A fake login page will happily accept your 104-bit password and hand it to an attacker. Check the site address before pasting, and prefer manager autofill, which refuses to fill your bank password on a lookalike domain.
Key terms
- Entropy (bits) — the measure of guessing work a password presents; each extra bit doubles the number of possibilities an attacker must search.
- Pool size — the total number of distinct characters the generator may choose from, set by your ticked character sets (89 with all sets on this page).
- Cryptographic randomness — random numbers generated to be unpredictable even to an attacker who has seen earlier outputs; here, the browser's crypto.getRandomValues.
- Fisher–Yates shuffle — the standard algorithm for rearranging a list so every ordering is equally likely; used here so guaranteed characters do not sit in predictable positions.
- Password manager — an encrypted vault that stores a different strong password for every account, unlocked by one master secret and your device.
- Credential stuffing — automatically trying leaked username-and-password pairs from one site's breach against many other sites.
Related calculators
- Dice Roller — https://metacalculator.org/calculators/dice-roller.html
- Love Calculator — https://metacalculator.org/calculators/love-calculator.html
- Random Number Generator — https://metacalculator.org/calculators/random-number-generator.html
Frequently asked questions
Is the password I generate here sent to a server or stored anywhere?
No. The page generates your password locally in your browser with cryptographic randomness, and nothing leaves your device. There is no account, no history, and no saved list of generated passwords. Once you close the tab, the password exists only where you pasted it — which should be the account itself and your password manager.
What does "104 bits of entropy" mean for a 16-character password?
It means an attacker guessing at random faces about 2 to the power of 104 possibilities, because this page calculates bits as length × log2(pool size): 16 × log2(89), rounded, gives 104. Each bit doubles the guessing work, so 104 bits is far beyond practical brute-force guessing. That figure assumes random generation, which is what this page does.
Why does a longer password with fewer character types beat a shorter one with symbols?
Because length multiplies while pool size only feeds a logarithm. The verified figures on this page show 8 characters using all four sets (pool 89) at 52 bits, but 20 characters of lowercase plus digits (pool 36) at 103 bits. Twelve extra characters added far more entropy than the wider symbol pool did. Choose length first, then the widest pool the site allows.
How does the generator make sure my password includes a digit and a symbol if I ticked them?
It deliberately guarantees at least one character from each selected set, then shuffles the whole password with a Fisher–Yates shuffle so those guaranteed characters land in unpredictable positions. You will never get an all-letter result when Digits is ticked, and the guaranteed digit will not always sit in the same place.
What is the strongest setting I should use for an important account like email or banking?
Use the longest length the site accepts — more than the default 16 if it allows it — with all four character sets ticked, and save the result in a password manager with two-factor authentication turned on. Email deserves special care because password resets for your other accounts usually arrive there, making it the master key to everything else.
Why does the page refuse some of my settings?
Two guards protect you. If the length is below 4 or above 128, you will see "Length must be between 4 and 128." If every character type is unticked, you will see "Select at least one character type." — because there would be no characters to build a password from. Both messages appear instead of a weaker password, which is the right behaviour.
Can I just invent my own complex password instead of generating one?
You can, but it will almost certainly be weaker than it looks. Humans choose predictable patterns — a capital first letter, a digit and symbol at the end, familiar words and substitutions that attackers try early — so the random-password entropy formula does not apply to them. For accounts that matter, generate the password here and let a password manager remember it.







































