Free Password Generator & Strength Checker

Create strong, cryptographically secure passwords with entropy-based strength meter and HIBP breach checking. 100% client-side.

Password Generator: Choose Password or Passphrase mode. For passwords, adjust the length (16+ recommended) and toggle uppercase/lowercase/numbers/symbols. For passphrases, pick the number of words (4-6 recommended). Click Regenerate for a new one. The tool shows strength in bits of entropy and estimated time to crack. Use the breach checker to verify any password hasn't appeared in known data breaches — your password never leaves your browser.

Loading Tool...

This tool requires JavaScript to run.

Please enable JavaScript in your browser to use this free online tool. All processing happens locally in your browser for maximum privacy and speed.

Key Takeaways

Uses window.crypto.getRandomValues() — cryptographically secure random, not the insecure Math.random()
Entropy-based strength meter shows strength in bits (16+ chars typically yields 96+ bits — very strong)
Have I Been Pwned integration via k-anonymity: only first 5 chars of SHA-1 hash sent — password never leaves your browser
Passphrase mode (Diceware-style) creates memorable high-entropy passwords: 4-word passphrase = ~52 bits entropy
Bulk generation: create up to 50 passwords at once for team accounts or batch migration
100% client-side processing — no signup, no ads, no tracking, no network calls with your password

What is Password Generator?

Password Generator — A password generator is a cryptographic tool that creates random, high-entropy passwords or passphrases using a cryptographically secure pseudo-random number generator (CSPRNG), producing credentials that are mathematically resistant to brute-force attacks and resistant to appearing in known breach databases.

This password generator creates cryptographically secure passwords and passphrases directly in your browser. Unlike many online generators that use the insecure Math.random() function, this tool uses window.crypto.getRandomValues() — the browser's built-in cryptographically secure random number generator (CSPRNG). Two modes are available: Password mode generates random character strings (4-64 characters) with configurable character sets (uppercase, lowercase, numbers, symbols, and exclude-ambiguous option). Passphrase mode generates Diceware-style memorable passwords from a word list (3-10 words) with customizable separators, capitalization, and optional random number injection. Each generated password displays its entropy in bits and estimated time to crack at 1 trillion guesses per second (modern GPU cluster attack). The built-in breach checker uses the Have I Been Pwned k-anonymity API — only the first 5 characters of the SHA-1 hash are sent, so your password never leaves your device while still allowing verification against 800+ million known breached passwords.

How to Use Password Generator

1
Choose a mode: Password (for website logins) or Passphrase (for master passwords you need to remember). Passwords are shorter and harder to crack per character; passphrases are longer but easier to remember.
2
For Password mode: Set the length (16 characters recommended minimum) and toggle which character types to include (uppercase, lowercase, numbers, symbols). Optionally enable 'Exclude ambiguous' to avoid characters like 0/O or 1/l/I.
3
For Passphrase mode: Set the word count (4-6 recommended), choose a separator (hyphen, underscore, etc.), and optionally enable capitalization or a trailing random number.
4
Click 'Regenerate' to create a new password, or use 'Generate count' slider for bulk generation (up to 50 at once). Click the copy icon to copy, or Download .txt to save the list.
5
Optionally use the Breach Checker to verify any password hasn't appeared in known data breaches. Only the first 5 characters of the SHA-1 hash are sent — your password stays on your device.

Key Features

Cryptographically Secure: Uses window.crypto.getRandomValues() — the browser's CSPRNG — not Math.random(). This is the same randomness source used by 1Password, Bitwarden, and all major password managers.

Password Mode: Generate 4-64 character passwords with any combination of uppercase, lowercase, numbers, and symbols. Toggle 'exclude ambiguous' to avoid easily-confused characters (0/O, 1/l/I, etc.).

Passphrase Mode: Generate Diceware-style memorable passwords from a word list. 3-10 words with customizable separators (-, _, ., space), capitalization option, and optional random number injection.

Entropy-Based Strength Meter: Shows password strength in bits of entropy (e.g., 96.5 bits). This is the academic standard — 60+ bits is strong, 80+ bits is very strong, 128+ bits is overkill (good).

Crack Time Estimate: Shows estimated time to crack at 1 trillion guesses per second (modern GPU cluster). A 16-character random password typically takes millions of years to crack.

HIBP Breach Checker: Integrated with Have I Been Pwned's k-anonymity API. Only the first 5 characters of your password's SHA-1 hash are sent — your actual password never leaves your browser. Checks against 800+ million breached passwords.

Bulk Generation: Generate 1-50 passwords at once. Copy all or download as .txt file — useful for team onboarding, database migrations, or creating multiple accounts.

Show/Hide Toggle: Click the eye icon to mask passwords with dots — protect against shoulder surfing while screen sharing or in public spaces.

Live Updates: In single-password mode, any setting change (length, character types) instantly regenerates a new password with the new settings.

No Tracking: Zero analytics, no ads, no scripts that track you. The page makes zero network calls with your generated passwords (only the optional HIBP check sends a hash prefix).

Works Offline: Once loaded, the entire tool works offline. No server dependency for password generation.

Keyboard Accessible: Full keyboard navigation, with Enter key triggering the breach check when focused on the input.

Use Cases

Creating Strong Account Passwords: Generate 16-20 character random passwords for every online account (banking, email, social media, work accounts).

Master Password for Password Managers: Use passphrase mode (6-8 words) to create a memorable master password you can type but attackers can't guess.

WiFi Passwords: Generate long random passwords for home or office WiFi — 20+ characters prevents dictionary attacks.

Database & Server Credentials: Create strong, unique credentials for servers, databases, and API services with the bulk generation feature.

Team Onboarding: Bulk-generate passwords for multiple new team accounts, download as .txt for secure distribution via password manager.

Breach Response: After a data breach notification, use the breach checker to verify your current password is safe and generate a replacement.

API Keys & Secrets: Generate high-entropy random strings for use as API keys, JWT secrets, encryption keys, or session tokens.

Crypto Wallet Passwords: Generate maximum-entropy passwords for crypto wallets where recovery is impossible if the password is guessed.

About Password Generator

What Makes a Password Strong?

Password strength is measured in bits of entropy — how many bits of randomness the password contains. Each bit doubles the number of possible passwords an attacker must try. A 60-bit password has 2⁶⁰ possibilities (1.15 quintillion) — already strong. An 80-bit password has 2⁸⁰ possibilities (1.2 septillion) — very strong. For reference: a random 16-character password using all character types yields approximately 96 bits. A 6-word Diceware passphrase yields approximately 77 bits. The current NIST recommendation is 64+ bits for user passwords and 128+ bits for high-value secrets like master passwords.

Password vs Passphrase: Which Is Better?

Passwords (random character strings) are high-entropy per character but hard to memorize — ideal for accounts you store in a password manager. Passphrases (random words strung together) are lower-entropy per character but much longer, and they're far easier to memorize and type — ideal for master passwords and anything you need to recall without a password manager. A 4-word passphrase (~52 bits) is stronger than most human-chosen passwords. A 6-word passphrase (~77 bits) is stronger than most 12-character random passwords. XKCD's famous "correct horse battery staple" comic popularized this idea in 2011.

How the Breach Checker Works (K-Anonymity)

The breach checker uses the Have I Been Pwned (HIBP) k-anonymity API to verify passwords against known breach databases without ever sending your password anywhere. Here's the math: Your browser computes the SHA-1 hash of the password, then sends only the first 5 characters of that hash to HIBP. HIBP returns a list of all hash suffixes that match that prefix (typically ~500 entries). Your browser then compares your password's full hash suffix locally. HIBP never sees your password or even its full hash — they only know "someone somewhere checked a password starting with hash prefix XXXXX." This technique is called k-anonymity because your query is indistinguishable from ~500 other possible queries.

Why Not Math.random()?

Many free online password generators use JavaScript's Math.random() function, which is not cryptographically secure and produces predictable sequences. In 2013, researchers demonstrated that Math.random() output could be predicted from a few samples. This tool uses window.crypto.getRandomValues() — the Web Crypto API's CSPRNG (cryptographically secure pseudo-random number generator) — which uses OS-level entropy sources (hardware RNG, keyboard timing, mouse movements, etc.). This is the same randomness source used by 1Password, Bitwarden, NordPass, and all major password managers. The difference is critical for any password protecting real accounts.

Password Length vs Cracking Time

Length	Charset (a-zA-Z0-9 + symbols)	Entropy bits	Crack time at 10B guesses/sec
8	95 chars	~52	~7 hours
10	95 chars	~65	~2 months
12	95 chars	~78	~1,500 years
16	95 chars	~105	3.4 × 10¹³ years
20	95 chars	~131	Beyond universe age
24	95 chars	~157	Beyond universe age (quantum-resistant)

The sweet spot for random passwords is 16 characters with all character types (~105 bits of entropy). For master passwords, use 20+ chars or a 6-8 word passphrase.

2026 Password Best Practices (NIST SP 800-63B)

Length over complexity: NIST recommends minimum 8 chars, ideally 64+; complexity rules (must have number / symbol) are now considered harmful
No forced rotation: the "change every 90 days" rule is officially obsolete. Only change after a breach event
No password hints: hints often reveal too much; just use a password manager
No security questions: "mother's maiden name" is findable on social media; treat as a secondary password
Check against breach lists: NIST mandates checking submitted passwords against known-breached lists (this tool does via HIBP)
Allow all printable characters: sites that block special characters are doing it wrong
Don't truncate: bcrypt's 72-byte limit is a workaround issue, not user-facing policy
Show password option: users should be able to see what they typed (preventing typos)
2FA / passkeys for high-value accounts: password strength alone isn't enough against phishing

Password Manager Recommendations

You shouldn't memorize 100+ unique strong passwords — that's what password managers are for. Generate strong random passwords with this tool, save to a manager, use the manager's autofill. Reputable options:

1Password (paid): mature, family plans, business features. ~$3/month.
Bitwarden (free + paid): open-source, free tier is excellent, $10/year premium.
KeePassXC (free, open-source): local-only, no cloud sync built-in but works with Dropbox/etc.
Apple Passwords / iCloud Keychain (free for Apple users): built into macOS / iOS, syncs to Mac and iPhone.
Google Password Manager (free): built into Chrome / Android. Less feature-rich but better than nothing.

Avoid: LastPass (multiple security breaches), Dashlane Free (limited features), and any "free password manager" you've never heard of.

When Random Passwords Aren't Enough

Even the strongest password can be:

Phished: typed into a fake login page; password manager + 2FA / passkeys prevent this
Keylogged: malware on your device captures every keystroke; password manager autofill mitigates
Leaked via breach: the service's database is compromised; unique passwords + HIBP check limit blast radius
Captured via shoulder surfing: someone watches you type; use show/hide toggle
Forgotten and recovered insecurely: password reset email goes to compromised email account

Defense in depth: strong random password (this tool) + password manager + 2FA / passkeys + verified device + unique per service. Together these stop 99%+ of attacks.

Diceware Passphrase Math

Diceware uses a wordlist of 7,776 words (6^5) — exactly the number of possible 5-dice rolls. Each word contributes log₂(7776) ≈ 12.92 bits of entropy. So:

4 words: ~52 bits — strong against most online attacks, weak against offline
5 words: ~65 bits — strong against most attacks, borderline for offline
6 words: ~77 bits — secure against current offline attacks
7 words: ~90 bits — extremely secure, future-proof through 2050+
8 words: ~103 bits — equivalent to a 16-char random password, easier to type

Use 6 words minimum for password manager master passwords; 7-8 for cryptocurrency wallets or other "recovery is impossible" scenarios.

Frequently Asked Questions

Is this password generator secure?: Yes. It uses window.crypto.getRandomValues() — the browser's cryptographically secure random number generator (CSPRNG) — which is the same source used by 1Password, Bitwarden, and all major password managers. The tool runs entirely in your browser; passwords are never sent to any server. You can verify this in your browser's DevTools Network tab.
Is this password generator free?: Yes, 100% free with no signup, no ads, no tracking, and no paywalls. All features — password generation, passphrase generation, strength meter, breach checker, and bulk generation up to 50 — are free forever.
How long should a password be?: For accounts stored in a password manager, 16-20 random characters is recommended. For master passwords and anything you need to memorize, use a 6-8 word passphrase (Diceware style). Per NIST SP 800-63B, minimum length is more important than complexity rules — a 20-character random password is far stronger than 'P@ssw0rd1!'
What is entropy in passwords?: Entropy measures randomness in bits. Each bit doubles the number of possible passwords an attacker must try. 60+ bits is strong, 80+ bits is very strong. A random 16-character password with all character types yields ~96 bits. A 6-word Diceware passphrase yields ~77 bits. Human-chosen passwords typically have only 20-40 bits of entropy — far weaker than they appear.
Is a passphrase stronger than a password?: A passphrase of equivalent length is about the same strength, but passphrases are much easier to memorize and type. For example, a 4-word passphrase (~52 bits) is stronger than most human-chosen 12-character passwords. Passphrases are recommended for master passwords (password manager vaults) and any credential you need to type manually.
How does the breach checker work without revealing my password?: The breach checker uses Have I Been Pwned's k-anonymity API. Your browser computes the SHA-1 hash of your password, then sends only the FIRST 5 CHARACTERS of that hash to HIBP. HIBP returns all matching hash suffixes (~500 entries), and your browser compares locally. HIBP never sees your password or its full hash. You can verify this in your browser's DevTools Network tab.
What does 'exclude ambiguous characters' do?: It removes characters that can be easily confused when reading or typing: 0 vs O, 1 vs l vs I, | vs l, quotes, commas, periods, etc. Useful when passwords need to be transcribed by humans (e.g., WiFi passwords for guests, or passwords shared verbally). Note: this slightly reduces entropy per character but improves usability.
How often should I change my passwords?: Only when there's a specific reason: a breach notification, a reused password, a compromised device, or a known exposure. Per NIST SP 800-63B (2017), the old advice to rotate passwords every 90 days is now considered counterproductive — it leads to weaker passwords as users make small, predictable modifications. Strong, unique passwords stored in a password manager don't need rotation.
What are the ambiguous characters this tool excludes?: When 'Exclude ambiguous' is enabled, these characters are removed: 0 (zero), O (capital o), 1 (one), l (lowercase L), I (capital i), and punctuation that's hard to distinguish in some fonts: quotes, commas, periods, semicolons, colons, and backticks.
Can I generate multiple passwords at once?: Yes. Use the 'Generate count' slider to create 1-50 passwords at once. Useful for team onboarding, database migrations, or API key generation. Click 'Copy All' to copy the entire list or 'Download .txt' to save a file.
What is Diceware?: Diceware is a method for creating memorable, high-entropy passphrases by rolling dice to randomly select words from a long word list. Originally invented by Arnold Reinhold in 1995, it was popularized for password use by XKCD's 'correct horse battery staple' comic. This tool's passphrase mode uses the same principle with secure random selection via crypto.getRandomValues().
Why not use Math.random() for passwords?: Math.random() is NOT cryptographically secure — its output can be predicted from a few samples. Many cheap online password generators use it, which means their passwords are theoretically breakable. This tool uses window.crypto.getRandomValues(), the Web Crypto API's CSPRNG, which uses OS-level entropy (hardware RNG, event timing) and is used by all major password managers.
Does this work offline?: Yes. Once the page is loaded, all password generation works offline. The only network call is the optional breach checker, which contacts HIBP's API (and only sends a 5-character hash prefix).

Loading your tools...