Secure Random Password Generator

Create passwords that are genuinely random — not derived from a pattern you can guess. Choose length and character classes, generate several at once, and copy the list. Everything happens locally.

What makes a password strong

Strength is about entropy — how many equally likely possibilities an attacker must try. Each character drawn from the largest set this tool offers (88 characters: letters, digits and 26 symbols) adds about 6.5 bits; a 16-character random password therefore has roughly 103 bits, far beyond what any offline attack can brute-force. Length beats complexity: correct horse battery staple (four random words) is stronger than P@ssw0rd!, which follows a pattern cracking tools try first.

Humans are bad at randomness. Substituting 3 for e or appending 2026! adds almost nothing because attackers model exactly those habits. Let a cryptographic generator pick every character.

How this generator works

Characters are selected with crypto.getRandomValues(), the same cryptographically secure source browsers use for TLS, and each character is picked by taking a 32-bit random number modulo the size of the character set. With at most 88 characters the resulting modulo bias is far too small to matter in practice. You control which classes to include — uppercase, lowercase, numbers, symbols — plus the length (4–128) and how many passwords to generate (1–50). Characters are drawn independently, so a result is not guaranteed to contain every class you ticked. There is no option to exclude look-alike characters, so remove 0 O 1 l I by hand when a password must be read aloud or typed from paper.

Using passwords well

Use a unique password for every account and store them in a password manager — the generator is most useful for filling one in. Enable two-factor authentication where available. For Wi-Fi keys, shared service accounts or anything typed on a TV remote, favour length over symbols. For database and API credentials, 32+ characters is cheap insurance.

How to use it

  1. Set the password length (12–20 for personal accounts, 32+ for service credentials).
  2. Tick the character classes you need (Symbols is off by default); some legacy systems forbid certain symbols, so adjust accordingly.
  3. Click Generate, then press Copy. Generate again for a different value — nothing is stored.

Strength at a glance

Approximate entropy for common choices (88 = letters, digits and the 26 symbols):

8 chars, letters+digits (62)      ~48 bits  — weak, crackable offline
12 chars, all classes (88)        ~78 bits  — good for most accounts
16 chars, all classes (88)        ~103 bits — strong
4 random words (7776-word list)   ~52 bits  — memorable, add a 5th word for ~65
32 chars, all classes (88)        ~207 bits — API keys, DB passwords

Online services usually rate-limit guesses, so even 48 bits is fine against web login forms; the danger is leaked password hashes attacked offline, which is where 80+ bits matters.

Common use cases

What the options do

Set Length (4 to 128) and Count (1 to 50), then tick Uppercase, Lowercase, Numbers and Symbols. Symbols are off by default and use 26 characters: !@#$%^&*()-_=+[]{}|;:,.<>?. If nothing is ticked, the tool asks you to select a set.

Characters are drawn at random from the combined set, so a result is not guaranteed to contain one of every class you ticked; a short password with all four ticked can still lack a digit. If a site insists on one of each, generate another or use a longer length. A 16-character password from letters and digits (62 symbols) has about 95 bits of entropy, and adding the symbol set (88 characters) raises it to about 103 bits. There is no option to exclude look-alike characters, so remove 0 O 1 l I yourself when a password must be read aloud.

Frequently asked questions

Are the generated passwords sent to or stored by SmartDevTools?

No. They are created in your browser with a cryptographic random generator, shown once and never transmitted or logged.

Is Math.random() used?

No. Math.random() is not cryptographically secure. This tool uses crypto.getRandomValues().

How long should my password be?

At least 12 characters with mixed classes for ordinary accounts; 16 is a comfortable default; 32 or more for machine-to-machine credentials you never type.

Should I include symbols?

They add entropy per character, but a longer password without symbols is just as strong and easier to type. Choose based on the system's rules and how you will enter it.

Does it guarantee at least one symbol or digit?

No. Each character is chosen independently from the ticked sets, so any single class can be missing from a short password. Increase the length or regenerate if a site requires one of each.

Related tools

Explore all developer tools →