Skip to content
LocalOnly

Password Generator

Stable

Generate strong, random passwords with a live strength estimate.

Everything is processed locally in your browser

About Password Generator

Create strong, unpredictable passwords tuned to any site's requirements. Choose the length and which character sets to include - uppercase, lowercase, digits, and symbols - and optionally exclude look-alike characters. Every password is drawn from the browser's cryptographically secure random source and generated entirely on your device.

Features

  • Cryptographically secure randomness via crypto.getRandomValues
  • Adjustable length, from short PINs to long high-entropy secrets
  • Toggle uppercase, lowercase, digits, and symbols independently
  • Exclude ambiguous characters like 0, O, 1, l, and I for readability
  • Live entropy and strength estimate as you change the options
  • Bulk generation and one-click copy for provisioning multiple accounts

How to use Password Generator

  1. 1

    Set the length

    Pick a length that meets or exceeds the target site's requirement. Longer is stronger - 16 or more characters is a good baseline.

  2. 2

    Choose character sets

    Enable uppercase, lowercase, digits, and symbols. Optionally exclude look-alike characters if the password must be typed or read aloud.

  3. 3

    Generate and copy

    Generate one or many passwords and copy the one you want. The strength meter reflects the entropy of your current settings.

Examples

A 20-character password with all sets

Uppercase, lowercase, digits, and symbols enabled - output shown as an illustrative example.

Input

Length: 20 · Sets: A-Z a-z 0-9 symbols

Output

qR7$mK9!vX2@pL4#nB6&

How secure password generation works

Length matters far more than character variety

Entropy is length multiplied by the bits per character, and length is the term that scales. A 20-character lowercase-only password has about 94 bits of entropy. A 10-character password using all four character classes has about 65. The longer, simpler one is roughly half a billion times stronger, which is not a close call.

This is why the guidance changed. NIST SP 800-63B, revised in 2017 and reaffirmed since, explicitly recommends against composition rules - the requirements to include an uppercase letter, a digit and a symbol. They add little entropy and they push people towards predictable patterns: capitalise the first letter, append a `1`, finish with a `!`. Attackers model those patterns, so the rules make passwords more guessable rather than less.

The same guidance also advises against mandatory periodic rotation, for the same behavioural reason. Forced 90-day changes produce `Summer2024!` becoming `Autumn2024!`, which is worse than a strong password kept until there is evidence of compromise.

Where the randomness has to come from

A generated password is only as unpredictable as its random source. `Math.random()` is a pseudorandom generator seeded from limited state and designed for speed, not secrecy - its output can be predicted from previous values. A password generator built on it produces passwords an attacker with knowledge of the algorithm can reconstruct.

Browsers expose `crypto.getRandomValues()`, which draws from the operating system's cryptographically secure entropy pool. That is the only acceptable source for anything intended to be secret, and it is what this tool uses.

There is a subtler bug worth knowing about even in generators that use a secure source. Reducing a random number into an alphabet with the modulo operator introduces bias unless the alphabet size divides evenly into the range, because the lower values become slightly more likely. The correct approach is rejection sampling - discard values in the biased tail and draw again. The bias is small but it is a real reduction in entropy.

Passphrases, and the case for a password manager

For a password you have to type or remember, a passphrase of random words is easier to handle at equal strength. Six words drawn randomly from a 7,776-word list - the Diceware approach - gives about 77 bits of entropy, comparable to a 13-character random string but far easier to type accurately and to recall.

The critical word is random. Choosing memorable words yourself collapses the entropy, because human word choice is heavily skewed and phrases from songs, films or books are in every cracking dictionary. The words must come from a generator, not from your head.

For everything you do not need to memorise, a password manager is the better answer. It allows a genuinely unique 20-plus character random password per site, which is the single most valuable property - it means one breach cannot cascade. Reuse, not weakness, is what turns a breach at one service into compromised accounts everywhere else, and credential-stuffing attacks exist precisely to exploit it.

Reference

Entropy by length and character set

Entropy in bits. Above roughly 80 bits, offline brute force stops being the weakest link.

Character setBits per char12 chars16 chars20 chars
Digits only3.3405366
Lowercase4.7567594
Upper + lower5.76891114
Alphanumeric5.957195119
All printable ASCII6.5579105131
Diceware words12.9 per word6 words = 778 words = 10310 words = 129

Which tool should you use?

These tasks overlap. Here is how to pick the right one for what you are actually doing.

You need a password for an account stored in a manager
20 or more characters, alphanumeric plus symbols. You never type it, so length costs nothing.
You need something you will type regularly
A passphrase of six or more randomly chosen words. Easier to type accurately at equivalent strength.
You need an API key or a token
A 32-character alphanumeric string, or the Nano ID Generator. Avoid symbols that need escaping in config files and shell commands.
You need a unique identifier rather than a secret
The UUID or Nano ID generators. Identifiers appear in logs and URLs; secrets must not.
You need to store a password you have been given
Hash it with Argon2id or bcrypt server-side. Never store it in plaintext or under a general-purpose hash.

Use cases

  • Creating unique credentials for a new account or service
  • Rotating a compromised or reused password
  • Generating API keys, database passwords, and service secrets
  • Producing WiFi passphrases that avoid confusing characters
  • Provisioning many accounts at once with bulk generation

Troubleshooting common errors

A site rejects the generated password

Why: Composition rules or a maximum-length limit - some systems still cap at 16 characters or forbid certain symbols.

Fix: Generate within the site's constraints, choosing the longest length it allows. A low maximum length is a genuine warning sign about how the site stores passwords.

The password breaks a shell command or a config file

Why: Characters such as `$`, backtick, `!` or quotes are interpreted by the shell or the parser.

Fix: Use an alphanumeric set for anything going into a config file or a command line. Save the symbols for passwords typed into a login form.

Characters are hard to distinguish when read aloud

Why: Confusable pairs - 0 and O, 1 and l and I.

Fix: Exclude ambiguous characters and add a few more characters to compensate for the smaller set.

Your organisation requires 90-day rotation

Why: A policy that predates current guidance.

Fix: NIST SP 800-63B recommends against scheduled rotation, because it drives predictable incremental changes. Rotate on evidence of compromise instead - the published guidance is useful ammunition for changing the policy.

Limitations

What this tool deliberately does not do, so you know when to reach for something else.

  • Generated passwords are not stored anywhere - if you navigate away without copying, the value is gone.
  • A password's strength cannot protect an account whose service stores it badly.
  • Composition requirements imposed by a site may force a lower-entropy password than you would otherwise choose.
  • Passphrase strength depends on the word list being large and the selection being genuinely random.
  • No password defends against phishing or a compromised endpoint - that needs multi-factor authentication.

Frequently asked questions

Learn more

Command Palette

Search for a tool or command