Passphrase & Password Generator
Generate secure passwords and memorable passphrases. Live entropy meter shows exact bit strength. Diceware passphrase mode, bulk generate up to 100. All via crypto.getRandomValues — nothing leaves your tab.
How to use
- Password tab: set length (8–128), choose which character sets to include. The entropy bar and strength label update live as you move the slider. Click Generate — a new password is drawn from the selected charset using
crypto.getRandomValues(). - Passphrase tab: choose word count (3–10), separator, and whether to capitalize and append a digit. The 7-word default gives ~63 bits — stronger than most 12-character passwords and far easier to remember.
- Bulk tab: generate 5–100 passwords or passphrases in one click. Copy all puts every result on your clipboard, one per line, ready for a spreadsheet or password manager bulk import.
All generation uses crypto.getRandomValues() — the Web Crypto API backed by your OS's secure random pool. No server is involved at any point.
Frequently asked questions
What is a passphrase and why is it more secure?
A passphrase is a sequence of random words — for example lamp-river-bold-fence-dust-king-oval. A 7-word passphrase from a 554-word list has about 63 bits of entropy. That is far stronger than most 8–10 character passwords and much easier to type from memory. The security comes entirely from how many possible combinations exist, not from visual complexity.
What is password entropy?
Entropy measures how unpredictable a password is, expressed in bits. Character passwords: log₂(charsetlength). Passphrases: log₂(wordlistwordCount). A 16-character password from uppercase + lowercase + digits has log₂(62¹⁶) ≈ 95 bits — Very Strong. Higher entropy means exponentially more combinations an attacker must try before finding yours.
What is Diceware?
Diceware is a passphrase method invented by Arnold Reinhold in 1995: roll physical dice and look up each result in a numbered wordlist. This tool implements the electronic equivalent using crypto.getRandomValues(), which reads from your OS's cryptographic random source — the same entropy quality as physical dice, automatically verifiable.
How many bits of entropy is enough?
For most rate-limited online accounts: 60 bits is comfortable (a trillion-guess-per-second attack would need ~36,000 years). For master passwords, disk encryption, or credentials attackable offline: 80+ bits. The tool labels <40 bits as Weak, 40–59 as Fair, 60–79 as Strong, and 80+ as Very Strong, matching the informal industry consensus and NIST SP 800-63B guidance.
Are my passwords stored or transmitted?
No. All generation happens in your browser using JavaScript. No password, passphrase, or setting is transmitted to any server. You can verify this by opening DevTools → Network and generating — you will see zero outbound requests from the tool. The wordlist and all logic are embedded in this page's <script> block.
What character sets should I include?
Enable all four (A–Z, a–z, 0–9, symbols) for the largest charset (94 printable ASCII characters). A 12-character password from this set has ~78 bits of entropy. If a site bans symbols, use letters + digits (62 characters) and increase length to 14+ to maintain similar entropy. Avoid lowercase-only — the 26-character alphabet needs 17 characters to reach 80 bits.
Why crypto.getRandomValues instead of Math.random?
Math.random() uses a seeded pseudorandom algorithm; an attacker who observes enough outputs can predict future values depending on the JavaScript engine. crypto.getRandomValues() reads from your OS's cryptographic random pool (/dev/urandom on Linux, BCryptGenRandom on Windows). It is considered indistinguishable from true randomness and is the standard for security-critical code.
What separator should I use for passphrases?
Hyphens are the safest: accepted everywhere, easy to type. Spaces work everywhere except some legacy systems. The separator adds no entropy since it is constant. Enabling "Add digit" appends a random 0–9, adding ~3.3 bits of entropy and satisfying "must contain a number" rules on most sites.
How do I use a passphrase on sites requiring symbols and numbers?
Enable "Capitalize" (uppercases the first letter of each word) and "Add digit" (appends a random digit). Together these satisfy the vast majority of complexity rules while keeping the phrase readable. Alternatively, use the Password tab which lets you select any combination of character sets.
Can I generate passwords in bulk for a password manager import?
Yes. The Bulk tab generates 5–100 passwords or passphrases at once. "Copy all" puts the full list on your clipboard, one per line, ready to paste into a spreadsheet or password manager bulk-import screen. Each entry is independently generated with its own crypto.getRandomValues() call — no shared state between them.
Examples
Database admin credential
Use a 20-character password with all four character sets — ~130 bits of entropy, appropriate for a root or admin credential.
Settings: length 20, A-Z + a-z + 0-9 + symbols Generated: rT#9qV$2wLx!mK7dBp3n Entropy: ~130 bits (Very Strong) Use case: Database root, SSH key passphrase
Memorable master password
A 7-word passphrase with capitalize + digit gives ~66 bits — strong, and you can type it from memory every day.
Settings: 7 words, hyphen, capitalize, add digit Generated: Lamp-River-Bold-Fence-Dust-King-Oval3 Entropy: ~66 bits (Strong) Use case: Password manager master password
Bulk API secrets
Generate 20 × 32-character passwords in one click and paste them directly into an environment file or secrets manager.
Settings: Bulk → 20 entries, Password type (adjust length slider to 32 first) Each key: ~192 bits (Very Strong) Use case: JWT secrets, webhook signing keys
About password and passphrase generation
Password security is not about visual complexity — it is about unpredictability. A password consisting of common dictionary words chosen by a person is weak even if it looks complex, because humans are predictable. A password generated by a cryptographically secure random source from a defined alphabet is strong in proportion to how many equally-likely outputs exist, regardless of what it looks like.
Character-based passwords derive their strength from two factors: the size of the character set (alphabet) and the length. The entropy formula log₂(C^L) — where C is charset size and L is length — quantifies this precisely. Including uppercase letters (26), lowercase letters (26), digits (10), and common symbols (approximately 32) creates a 94-character alphabet. Every character added to a password from this set contributes approximately 6.6 bits of entropy. A 12-character password has 78 bits; a 16-character password has 104 bits. These numbers grow multiplicatively, which is why adding just two characters to a short password dramatically increases resistance to brute-force attacks.
Passphrase-based generation works differently: instead of a character alphabet, the building blocks are words. Each word contributes log₂(wordlistSize) bits. This tool uses a curated 554-word list (approximately 9.1 bits per word), giving a 7-word passphrase about 63 bits of entropy. The EFF (Electronic Frontier Foundation) popularized this approach in 2016, publishing wordlists specifically designed for Diceware — words chosen to be short, unambiguous to spell, and easy to remember. Passphrases have a practical advantage that entropy numbers alone do not capture: they are far easier to type from memory, making them ideal for credentials you enter daily, such as disk encryption passphrases or password manager master passwords.
The source of randomness is critical. A generator using Math.random() — which most browser-based tools historically used — is backed by a pseudorandom algorithm that can be predicted if an attacker observes its output or knows the seed. crypto.getRandomValues(), the Web Crypto API standard, reads entropy directly from the operating system's cryptographic random pool: /dev/urandom on Linux, BCryptGenRandom on Windows, and SecRandomCopyBytes on macOS and iOS. This is the same entropy source used by OpenSSL, libsodium, and every serious cryptographic library. Every generation on this tool goes through crypto.getRandomValues().
Nothing you generate leaves your browser tab. The entire wordlist, character sets, and generation logic are compiled into this page's script block at load time. No credential, setting, or generated output is transmitted to any server. You can download this page and use it entirely offline. You can open DevTools → Network, clear the log, generate a hundred passwords, and observe zero outbound requests from the tool itself. The only network requests you will see are the AdSense script and the Cloudflare Analytics beacon, both loaded at page load before you interact with anything.
How much entropy do you need? For online accounts behind rate limiting and CAPTCHA, 40 bits is a floor and 60 bits is comfortable — most attackers cannot enumerate 10^18 guesses against a throttled login endpoint. For credentials that can be attacked offline — disk encryption, a password manager vault file, a private key passphrase — assume the attacker can perform billions of guesses per second with GPU hardware. At one billion guesses per second, a 60-bit credential takes 36 years on average; an 80-bit credential takes 38 million years. NIST SP 800-63B (the US federal password guideline, last updated 2024) no longer mandates periodic forced resets or complexity rules; instead it recommends long, randomly generated passwords or passphrases stored in a password manager.