Secure Password Generator

Free secure password generator. Create cryptographically strong random passwords with custom length and character options.

Advertisement

Generate a secure password you can actually type from memory

This password generator builds passphrases — several real words joined by a separator, with an optional number and special character — rather than a wall of random symbols. A new passphrase appears the moment the page loads and regenerates automatically every time you change an option, so there is no form to submit. Click the passphrase itself, or the Copy button, to put it on your clipboard.

The words are drawn at random from a wordlist stored on our server; your browser asks for a word count and a list of dictionary categories, and nothing else. The assembled passphrase is built entirely in your browser. It is never sent back, never written to a database, and never logged. Reload the page and the passphrase you were looking at is gone for good, so copy it into your password manager before you navigate away.

How to generate a password with this tool

  • Take the default. Out of the box the tool produces four words from the base dictionary, joined with hyphens, first word capitalised, a number from 0–999 on the end, and an exclamation mark. That configuration scores roughly 76 bits of entropy and is rated Strong. For most accounts you can stop there and click Copy.
  • Need more strength? Drag the Number of Words slider from 4 to 5. That one change pushes the same configuration past 91 bits and moves the rating to Very Strong. Each additional word from the base dictionary adds a little over 15 bits.
  • Hit a site that rejects the output? Change the separator or drop the special character rather than shortening the passphrase. Length is where nearly all the strength lives; the punctuation is a rounding error by comparison.
  • Generate a different one. Press Generate New. The options stay put and only the words and the random number change, which is useful when a passphrase happens to land on a word combination you would rather not type into a shared screen.

Because generation re–fires on every option change, you can watch the entropy figure and the crack–time estimates move as you adjust the settings. That live feedback is the point of the right–hand panel: it turns “is this good enough?” into a number you can compare against a policy.

Every option, and what it actually changes

Word dictionaries. The base dictionary holds 35,579 words and is selected by default. Alongside it are three professional lists — Computer (655 words), Legal (649) and Medical (610) — and ten themed lists: Sports, Superhero, Star Trek, Star Wars, Fantasy, Food, Animals, Mythology, Dinosaurs and Pirates. Each checkbox shows its live word count, and the running total of the selected lists appears underneath. You can tick any combination; the pools are merged before words are drawn. If you untick everything, the tool falls back to the base dictionary rather than failing.

A word of warning about the themed lists: they are small. Selecting only a themed list shrinks the pool from tens of thousands of words to a few hundred, and the entropy figure drops sharply to match. They are best used as an addition to the base dictionary — to make a passphrase more memorable for a particular team — not as a replacement for it.

Number of words (3–10). The single most important control. Entropy from the words alone is log2(pool size) × word count, so with the 35,579–word base list each word contributes about 15.12 bits.

Word separator. Hyphen, space, period, underscore, none, or a custom string of up to three characters. Hyphen is the default and the safest choice for compatibility. Space works in most modern password fields but still trips up older systems and some command–line tooling. “None” runs the words together, which makes the result shorter and harder to read back over the phone.

Capitalisation. Five modes: lowercase, UPPERCASE, Title Case, RaNdOm, and First word (the default, which capitalises only the first word). The entropy each contributes is honest about how little it buys: First word adds exactly 1 bit, Title Case adds 1 bit per word, and RaNdOm adds 1 bit per letter — the only capitalisation mode that meaningfully moves the number, at the cost of being effectively untypeable from memory. lowercase and UPPERCASE add nothing at all, because there is only one way to apply them.

Add number. Place a random number at the end (default), at the start, between the words, or at a random position, or leave it off. The range selector offers 0–99, 0–999 (default) or 0–9999, worth about 6.6, 10 and 13.3 bits respectively. Note that the number is inserted using the same separator as the words, so with the hyphen default it appears as its own hyphen–delimited chunk.

Add special character. A single character from ! @ # $ % ^ & *, placed at the end (default), at the start, or at a random position inside the string. You choose which character, so an attacker who has watched you generate passwords learns which one you always pick — the entropy model generously credits 5 bits here on the assumption the attacker has to guess among 32 common symbols. Do not lean on it.

Worked examples: what each setting is worth

All figures below use the base dictionary at 35,579 words and the tool's own entropy formula. The strength bands are fixed: under 25 bits is Weak, 25 to 40 is Fair, 40 to 60 is Good, 60 to 80 is Strong, and 80 and above is Very Strong.

ConfigurationEntropyRating
3 words, lowercase, no number, no symbol45.4 bitsGood
4 words, lowercase, no number, no symbol60.5 bitsStrong
4 words, first capitalised, number 0–999, one symbol (the default)76.4 bitsStrong
5 words, first capitalised, number 0–999, one symbol91.6 bitsVery Strong
6 words, lowercase, no number, no symbol90.7 bitsVery Strong
10 words, lowercase, no number, no symbol151.2 bitsVery Strong

Read the table twice and the lesson lands: four words plus a number plus a symbol (76.4 bits) is weaker than six bare words (90.7 bits). The decorations that password policies obsess over — the digit, the punctuation, the capital letter — are collectively worth about 16 bits, roughly one extra word. Adding a word is cheaper for you to remember and buys more.

Reading the strength panel and the crack–time estimates

The right–hand column shows entropy in bits, a strength label, and four attack estimates. Every time figure is an average case — half the keyspace — not a worst case, so a determined attacker could get lucky in half that time.

  • Online attack models 1,000 guesses per second against a live login endpoint. This is the scenario a rate limiter or an account lockout is supposed to prevent, and the number here should be enormous for any credential you care about.
  • Offline attack and Cloud GPU brute force both model 158 billion hashes per second, the tool's stated figure for an NVIDIA H100. Because both use the same rate, these two times are always identical — that is expected, not a bug. The cloud panel adds a dollar cost on top, computed at $2 per GPU hour.
  • Dictionary attack is the one that matters most, and the only estimate that models an attacker who knows you used this tool. Instead of guessing characters, it guesses word combinations: pool size raised to the word count, multiplied out by the separator choice, capitalisation mode, number range and symbol placement. If you are choosing between two configurations, compare their dictionary numbers, not their brute–force numbers.

The gap between the brute–force and dictionary figures is the price of using a known wordlist. It is a price worth paying, because the passphrase is one you will actually remember instead of writing on a sticky note — but the tool shows you the number rather than hiding it, and you should look at it.

Common mistakes and how to spot them

  • The entropy figure collapsed after you picked a theme. You unticked the base dictionary. Selecting only Pirates or only Star Wars leaves a pool of a couple of hundred words. Re–tick Base Dictionary and the number returns; the total selected word count under the checkboxes is the fastest way to confirm.
  • You are hunting for a character–length control. There isn't one. This tool is word–count driven, not character–count driven, so if a site demands exactly a certain number of characters you will need to trim the output by hand or use a character–based generator instead. Output length varies run to run, because the words themselves vary in length.
  • You reused the passphrase across two accounts. Entropy protects you against guessing, not against a breach at one provider being replayed at another. Generate a fresh one per account and store them in a password manager.
  • You typed the passphrase from the screen instead of copying it. Words from the professional dictionaries in particular are easy to mistype. Click the passphrase to copy; the “Copied!” confirmation appears for two seconds.
  • You changed an option and lost the passphrase you liked. Any option change triggers a fresh generation. Copy first, then experiment.
  • “Error generating passphrase” appears. The wordlist request failed — usually a dropped connection or a blocked request. Press Generate New to retry.

When to use a passphrase, and when to use something else

Passphrases are the right answer wherever a human has to type the secret: a laptop login, a disk encryption passphrase, an SSH key passphrase, a password manager's own master password, a Wi–Fi pre–shared key that guests will read off a card. In all of those cases memorability and transcription accuracy are real constraints, and a hyphenated word sequence beats a random symbol string on both while reaching comparable entropy through length.

They are the wrong answer where nothing human ever reads the value. API keys, service account credentials, database passwords and anything else that lives in a secrets manager should be long random character strings generated by that tooling — there is no memorability benefit to trade for, so take the higher entropy per character. Passphrases are also a poor fit for systems with a hard low character cap, or fields that reject spaces and punctuation without telling you which; there, a shorter random string is the pragmatic choice.

Whichever style you land on, the rules that actually reduce risk are unchanged: one unique credential per account, stored in a password manager, with multi–factor authentication turned on wherever the service supports it. A 91–bit passphrase protects nothing if the same one guards a dozen accounts and one of them is breached.

What Is a Secure Password Generator

A secure password generator creates random, high-entropy passwords using cryptographically secure random number generators (CSPRNGs). Unlike human-chosen passwords—which tend to follow predictable patterns, use dictionary words, and reuse across services—generated passwords maximize randomness, making them resistant to brute-force attacks, dictionary attacks, and credential stuffing.

Password security is measured in bits of entropy—the amount of randomness in the password. A 12-character password using uppercase, lowercase, digits, and symbols provides approximately 79 bits of entropy, meaning an attacker would need to try an average of 2^78 combinations. For context, modern GPU-based crackers can test billions of password hashes per second against weak hashing algorithms, making password length and randomness critical defenses.

How Password Entropy Works

Entropy measures the unpredictability of a password. It depends on the character set size and password length:

Entropy formula: E = L × log₂(C)

  • L = password length
  • C = character set size
Character SetSet Size (C)Bits per Char12-char Entropy16-char Entropy
Lowercase only264.756.4 bits75.2 bits
Lower + upper525.768.4 bits91.2 bits
Lower + upper + digits625.9571.4 bits95.3 bits
All printable ASCII956.5778.8 bits105.1 bits

Recommended minimums:

  • General accounts: 12+ characters, 72+ bits of entropy
  • High-value accounts: 16+ characters, 90+ bits of entropy
  • Master passwords: 20+ characters, 100+ bits of entropy

Why randomness matters: The password "P@ssw0rd123!" has 95^12 possible combinations in theory, but because it follows predictable patterns (capital first letter, common substitutions, trailing numbers and symbol), it falls in minutes to rule-based attacks. A truly random password like "k7#mQ2!vLp9&" from the same character set would take centuries.

Common Use Cases

  • Account creation: Generate unique passwords for every online service instead of reusing passwords
  • Password manager seeding: Create master passwords and individual account passwords for storage in a password manager
  • Service accounts: Generate credentials for databases, APIs, and automated systems
  • Wi-Fi passwords: Create strong, random pre-shared keys for wireless networks
  • Encryption keys: Generate passphrases for disk encryption, PGP keys, and SSH key passphrases

Best Practices

  1. Use a password manager — No one can remember random 16-character passwords for dozens of services; use a manager like 1Password, Bitwarden, or KeePass
  2. Generate unique passwords per service — Password reuse means one breach compromises every account using that password
  3. Prefer length over complexity — A 20-character lowercase-only password (94 bits) is stronger than a 10-character mixed-case password (60 bits) and easier to type
  4. Use passphrases when memorization is needed — Random word combinations like "correct-horse-battery-staple" provide high entropy with better memorability
  5. Enable multi-factor authentication — Even the strongest password can be phished; MFA provides a critical second layer of defense

Frequently Asked Questions

How to generate a secure password?+

Use cryptographically secure random number generator (CSPRNG), not Math.random(). Include: 16+ characters, uppercase, lowercase, numbers, symbols. Avoid: dictionary words, personal info, patterns. Our tool uses Web Crypto API (window.crypto.getRandomValues) for true randomness. Generate unique password per account. Store in password manager. Verify strength using entropy calculator. Longer = better (20+ chars ideal).

What is a cryptographically secure generator?+

Cryptographically secure pseudo-random number generator (CSPRNG) produces unpredictable random values suitable for security. Uses entropy from OS (hardware noise, timing). Not guessable like Math.random(). Examples: Web Crypto API, /dev/urandom, CryptGenRandom. Essential for passwords, encryption keys, tokens. Standard random generators are predictable - never use for security. CSPRNG passes statistical randomness tests.

Should I use memorable or random passwords?+

Random passwords (CSPRNG-generated) are strongest - maximum entropy, no patterns. Memorable passwords (passphrases) are easier to remember but slightly weaker. Best approach: random passwords in password manager (most accounts) + memorable passphrase for master password. Example passphrase: "Tiger!Climb$Forest29". Avoid: common phrases, song lyrics, quotes. Use password manager to eliminate memorization need for most accounts.

Is it safe to use online password generators?+

Yes, if using client-side CSPRNG (no server transmission). Our tool generates passwords in your browser - never sent to server. Check: uses crypto.getRandomValues(), open-source code, HTTPS. Avoid: generators requiring server requests, closed-source tools, non-HTTPS sites. Most secure: offline generator or password manager. Clear clipboard after copying. Never save generated passwords in browser autofill without master password.

What length should my password be?+

Minimum 16 characters for strong security. Longer = exponentially stronger. Recommendations: 16 chars (good), 20 chars (better), 32 chars (excellent for high-value accounts). Master passwords: 20-30 chars (passphrases). Short passwords (<12 chars) are vulnerable to brute-force. Each added character increases cracking time exponentially. Modern systems support 64+ characters. Use maximum allowed length for critical accounts.

Should I include special characters?+

Yes, if allowed. Special characters (!@#$%^&*) increase entropy and character space. Some systems limit allowed symbols - check requirements. Avoid ambiguous characters (O/0, I/l/1) if typing manually. Balance: length matters more than character variety. 20 char lowercase > 10 char with all types. Best: 16+ chars with uppercase, lowercase, numbers, and symbols. Use password manager to handle complex passwords.

How to remember generated passwords?+

Do not try - use password manager instead. Password managers: store encrypted passwords (AES-256), auto-fill credentials, sync across devices, generate unique passwords. Recommended: Bitwarden, 1Password, LastPass, KeePass. Exception: master password - use memorable passphrase (20+ chars). Write master password on paper, store in safe. Enable MFA on password manager. Better to store securely than use weak memorable passwords.

Can generated passwords be cracked?+

Properly generated passwords (16+ chars, true random, CSPRNG) take centuries to crack with current technology. Weak points: password reuse, phishing, keyloggers, compromised password manager. Quantum computers (future) threaten current encryption - use 32+ chars for future-proofing. Defense: unique passwords per account, MFA, breach monitoring, regular security audits. No password is uncrackable - layer security with MFA.

This tool is provided for informational and educational purposes only. All processing happens in your browser — no data is sent to or stored on our servers. While we strive for accuracy, we make no warranties about the completeness or reliability of results.