Free secure password generator. Create cryptographically strong random passwords with custom length and character options.
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.
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.
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.
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.
| Configuration | Entropy | Rating |
|---|---|---|
| 3 words, lowercase, no number, no symbol | 45.4 bits | Good |
| 4 words, lowercase, no number, no symbol | 60.5 bits | Strong |
| 4 words, first capitalised, number 0–999, one symbol (the default) | 76.4 bits | Strong |
| 5 words, first capitalised, number 0–999, one symbol | 91.6 bits | Very Strong |
| 6 words, lowercase, no number, no symbol | 90.7 bits | Very Strong |
| 10 words, lowercase, no number, no symbol | 151.2 bits | Very 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.
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.
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.
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.
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.
Entropy measures the unpredictability of a password. It depends on the character set size and password length:
Entropy formula: E = L × log₂(C)
| Character Set | Set Size (C) | Bits per Char | 12-char Entropy | 16-char Entropy |
|---|---|---|---|---|
| Lowercase only | 26 | 4.7 | 56.4 bits | 75.2 bits |
| Lower + upper | 52 | 5.7 | 68.4 bits | 91.2 bits |
| Lower + upper + digits | 62 | 5.95 | 71.4 bits | 95.3 bits |
| All printable ASCII | 95 | 6.57 | 78.8 bits | 105.1 bits |
Recommended minimums:
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.
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).
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.
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.
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.
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.
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.
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.
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.