Password Generator

Private by design. Your password is created in this browser with the Web Crypto API (crypto.getRandomValues). It is never sent to any server, never stored, and never leaves this page. Close the tab and it is gone.

16 characters

16 characters is a strong default. NIST requires passwords used on their own to be at least 15 characters, and CISA advises at least 16. Longer is stronger: every extra character multiplies the guesses an attacker must try.

Character sets

All four sets together give 94 possible characters. Turning a set off shrinks the pool and lowers the entropy, so keep all four on unless a site rejects a character type.

Exclude ambiguous removes 0, O, 1, l, and I, the characters that look alike in some fonts. No repeats means every character appears at most once, so the length cannot exceed the size of the character set.

How many words?

Words come from a curated 1,024-word list built for this tool. Each word adds exactly 10 bits of entropy, so 6 words give 60 bits. Six words is the strongest option here and matches the EFF recommendation of at least six words from a word list.

Separator between words

Capitalization is cosmetic: it changes how the passphrase looks, not how hard it is to guess. The separator is cosmetic too. The strength comes from the words and how they were picked.

Your password

Estimated time to crack

These times assume an attacker guesses at the stated rate and finds the password after trying half the possibilities on average. The four scenarios follow the zxcvbn method: online throttled, online unthrottled, offline slow hash, and offline fast hash. A crack time is an estimate, not a guarantee. Phishing, malware, and reused passwords bypass guessing entirely.

This tool generates passwords in your browser using the Web Crypto API. The passwords are never sent or stored. Crack-time estimates are based on stated guessing-speed assumptions and are estimates, not guarantees: a strong password does not protect against phishing, keylogging, or a password that has already leaked. Store generated passwords in a password manager.
Quick answer: This password generator creates a strong random password or a memorable passphrase in your browser, using the Web Crypto API, and never sends or stores it. Set a length from 8 to 64 characters with your choice of character sets, or pick 3 to 6 words from a curated 1,024-word list, and see the entropy in bits plus a crack-time estimate under four attack speeds.

Last reviewed: 20 November 2026. Reviewed every 180 days; next review due 19 May 2027.

How to use the Password Generator

Need a password nobody can guess? This password generator makes one for you in your browser, with no signup, no account, and nothing to install. It is one of the free tools on the Tools Elite home page, and it has two modes: a random password made of mixed characters, and a memorable passphrase made of ordinary words. Both are generated on this page with the browser's built-in cryptographic random number source, and both come with a strength meter that shows the entropy in bits and an honest estimate of how long guessing would take. Nothing you generate is sent anywhere or saved anywhere, so copy your password into a password manager before you leave the page.

  1. Pick a mode. The tabs at the top switch between Random password and Memorable words. Random password is the default and the strongest choice for most accounts, because it draws from up to 94 different characters. Memorable words builds a passphrase of 3 to 6 everyday words, which is easier to type and remember, and fits the one password you must remember yourself, such as your password manager's master password.
  2. Random password: set the length and the character sets. Drag the length slider from 8 to 64 characters. The default is 16, which is a solid length for most accounts. Below the slider, four switches control which characters can appear: lowercase letters, uppercase letters, digits, and symbols. All four are on by default, giving a pool of 94 characters. Turn a switch off and those characters are removed from the pool, which lowers the strength, and the meter updates as you change them.
  3. Random password: optional extras. Exclude ambiguous characters removes the five characters that are easy to mix up when reading or typing: the digit 0, the capital letter O, the digit 1, the lowercase letter l, and the capital letter I. It shrinks the pool from 94 to 89 characters, which costs a little entropy, and the meter shows the change. No repeat characters stops any character from appearing twice; with no repeats, the length cannot exceed the pool size, so a digits-only password with no repeats tops out at 10 characters, and the tool says so instead of guessing.
  4. Memorable words: set the word count and the separator. Pick 3, 4, 5, or 6 words. The default is 6, which is the strongest option here, and it matches the Electronic Frontier Foundation's recommendation of at least six words from a word list. Choose how the words are joined: a hyphen, a space, an underscore, or a period. Turn on Capitalize first letter if you want each word to start with a capital, which some sites require; capitalization changes how the passphrase looks but adds no entropy.
  5. Generate, copy, and check the strength. A password is generated as soon as the page loads, and every change to the settings generates a fresh one. Press Regenerate for a new password with the same settings. The Copy button copies the password to your clipboard; if your browser blocks clipboard access, the tool selects the password so you can copy it by hand. The eye button hides the password behind dots when someone might be looking over your shoulder. Below the result, the strength meter shows the entropy in bits, a strength label, and a crack-time estimate under four attack speeds.
  6. Save it somewhere safe. This tool keeps no history on purpose: a password generator that remembered your passwords would be a liability, not a feature. Before you close the page, store the password in a password manager, which is the single best habit in this whole guide.

If the tool shows an error, the password cannot be built as entered: no character set is selected, the length is outside 8 to 64, a no-repeat password is longer than its character pool, or the word count is outside 3 to 6. Fix the setting it names and generate again.

Do not use the example passwords printed in this guide. The worked examples below are real outputs from this tool's test runs. Because they are published on a public page, anyone can read them, which makes them worthless as passwords.

How it works

Every password on this page is built from random fractions between 0 and 1, one fraction per character or per word. Each fraction is scaled to the size of the pool and rounded down to a whole number, which picks one character or one word. Because every fraction is equally likely to land in any slice of the range, every character in the pool has exactly the same chance of being picked, and every word in the list has exactly the same chance. There is no pattern, no favorite letter, and no dictionary bias: the password is only as predictable as the random source behind it, which is why the source matters so much. The same uniform-draw idea powers the random number generator on this site, where you can see it at work with dice rolls and coin flips.

The random source is the Web Crypto API, the browser's built-in cryptographic random number generator. The tool calls crypto.getRandomValues, which fills a buffer with random bytes drawn from the operating system's entropy pool. MDN describes crypto.getRandomValues as a method that lets you get cryptographically strong random values, from a pseudorandom number generator seeded with enough entropy to be suitable for cryptographic purposes. This tool never uses Math.random, the ordinary JavaScript random function, for passwords: MDN states plainly that Math.random does not provide cryptographically secure random numbers, and that it should not be used for anything related to security. If the browser cannot provide cryptographic randomness, the tool shows an error instead of silently falling back to a weaker source.

For a random password, the tool builds a character pool from the switches you have on. The four sets are 26 lowercase letters, 26 uppercase letters, 10 digits, and 32 symbols, which are all of the printable ASCII punctuation characters, from the exclamation mark through the tilde. With all four switches on, the pool holds 94 characters, and with exclude-ambiguous on, the five lookalike characters are removed and it holds 89. Each character is drawn independently, so repeats are normal: a 16-character password from 94 characters will usually contain at least one repeated character. When no-repeat is on, the tool draws one character at a time and keeps only characters it has not used yet, drawing again whenever a repeat turns up, which keeps every possible password equally likely.

For a passphrase, the tool draws words from a curated list of 1,024 common English words, built for this tool. The list is made of short, everyday words, each 3 to 8 letters long, chosen to be easy to read, type, and remember: words like apple, river, guitar, blanket, and volcano. It is not the Electronic Frontier Foundation's word list, and this page does not claim it is. The EFF publishes its own lists for dice-generated passphrases, with a long list of 7,776 words and short lists of 1,296 words, and this tool's list is smaller and simpler by design. Every word is drawn uniformly from all 1,024 words, no word repeats inside one passphrase, and the entropy is computed from the list size. The no-repeat rule trims the entropy by about 0.02 bits for 6 words, and capitalizing the first letter of each word adds no entropy at all, because the capitalization is fixed.

Entropy is the measure of how hard a password is to guess by brute force, and it is counted in bits. One bit doubles the number of possibilities: a password with 60 bits of entropy has about a million trillion possible values, and each extra bit doubles that again. The formula for a random password is the length times the base-2 logarithm of the pool size: bits equals length times log2 of the pool size. The base-2 logarithm of 94 is about 6.55, so each character drawn from all 94 characters adds about 6.55 bits, and a 16-character password has 104.9 bits. For a passphrase, the formula is the word count times log2 of the list size. The base-2 logarithm of 1,024 is exactly 10, so each word adds exactly 10 bits, and a 6-word passphrase has exactly 60 bits. The tool shows the formula with your numbers filled in, so the entropy is never a mystery number. When no-repeat is on, the meter counts only the passwords no-repeat can produce, so the bits shown are a little lower than the plain formula would give.

The worked examples below are real outputs from this tool's test runs with fixed seeds. They are examples only: never use a password you found printed on a web page.

  • Random, 16 characters, all four sets: 4Q=!qXz6>Sx?)CsV. Pool 94, entropy 104.9 bits, rated Very strong. There are about 3.7 times 10 to the power of 31 possible passwords of this shape, and an attacker guessing at 10 billion guesses per second would need about 59 trillion years on average to find this one.
  • Random, 8 characters, all four sets: bf|$XMRw. Pool 94, entropy 52.4 bits, rated Fair. Eight characters is the shortest this tool allows, and the meter shows why it is not enough on its own: at 10 billion guesses per second, an offline attacker needs about 3.5 days on average.
  • Random, 12 characters, lowercase only: nnppwncnplmv. Pool 26, entropy 56.4 bits, rated Fair. Twelve lowercase letters carry 56.4 bits, only a little more than 8 characters from the full pool at 52.4 bits, because each lowercase letter adds only about 4.7 bits, against 6.55 bits per character from all four sets.
  • Random, 20 digits: 67260574927760438277. Pool 10, entropy 66.4 bits, rated Good. Twenty digits beat twelve lowercase letters, because length matters more than pool size: each digit adds about 3.32 bits, but there are 20 of them.
  • Words, 6 words, hyphen separator: cast-toffee-cyclone-farmer-violin-kettle. List size 1,024, entropy 60 bits, rated Good. There are about 1.2 times 10 to the power of 18 possible six-word passphrases from this list, and an offline attacker at 10 billion guesses per second needs about 1.8 years on average.
  • Words, 3 words, capitalized, space separator: Orange Sun Baker. List size 1,024, entropy 30 bits, rated Weak. Three words are easy to remember and easy to guess: at 10 billion guesses per second, an offline attacker needs less than a second on average.

What your result means

Below every generated password, the strength meter shows the entropy in bits, a strength label, the number of possible passwords, and a crack-time estimate under four different attack speeds. This section explains each one, including what the numbers assume, because a crack time without its assumptions is a guess dressed up as a fact.

The entropy in bits is the headline number. It measures the size of the search space: a password with N bits of entropy has about 2 to the power of N possible values, and an attacker guessing at random must try about half of them on average before hitting the right one. The tool's strength labels are bands on this number: under 40 bits is Weak, 40 to under 60 is Fair, 60 to under 80 is Good, 80 to under 100 is Strong, 100 to under 128 is Very strong, and 128 bits or more is Excellent. These bands are this tool's own scale, chosen so the labels line up with the crack times: a Fair password resists online guessing for years but falls to a fast offline attack in seconds to months, depending on where it sits in the band, while a Very strong password resists even a fast offline attack for trillions of years. The meter bar fills in proportion to the bits, reaching full at 128, because beyond 128 bits no attacker will ever brute-force the password, whatever hardware they own.

The crack-time estimate answers a narrower question: if an attacker knew exactly how your password was built, and guessed values at random at a fixed speed, how long would it take on average to stumble on yours? The tool shows four speeds, taken from the zxcvbn password strength estimator published by Dropbox, which models four realistic attack scenarios. The slowest is an online attack against a login page that throttles guesses, at 100 guesses per hour: most services lock an account or slow the login after a few wrong tries. The second is an online attack against a login page with no throttling, at 10 guesses per second. The third is an offline attack against a stolen password database that uses a slow hash, at 10,000 guesses per second: a slow hash is deliberately expensive to compute. The fourth is an offline attack against a stolen database that uses a fast hash, at 10 billion guesses per second, which is the rate a well-equipped attacker with modern graphics hardware can reach against a fast hash. These four rates are assumptions, labeled as assumptions on the page, and they are the reason the same password can show a crack time of billions of years online and a few hours offline: the attacker's speed, not the password, is what changes.

Two of those assumptions deserve a closer look. The average-guesses assumption says the attacker needs about half the search space, because the right password is equally likely to sit anywhere in the guessing order. The uniform-random assumption says the password was drawn uniformly from the stated pool, with no pattern the attacker can exploit. That is true for passwords this tool generates, and it is not true for passwords people invent: a human-chosen password like Summer2026 draws from a far smaller space of likely choices, and an attacker with a list of common passwords will try it early. Entropy measures the password you actually have, not the password you think you have.

The crack time is an estimate, never a guarantee. It assumes the attacker must guess blindly, which is the hardest case for them and the best case for you. Real attackers rarely guess blindly: they try lists of leaked passwords first, they phish you into typing the password yourself, and they install keyloggers that record it as you type. NIST makes this point in the appendix to its password guidance, noting that keystroke logging, phishing, and social engineering attacks are equally effective on lengthy and complex passwords as on short ones. A 100-bit password protects you against guessing, and it protects you against nothing else, which is why the rest of this guide, about password managers, unique passwords, and multi-factor authentication, matters as much as the strength meter.

One more result detail: the composition checklist under a random password shows which character sets actually appear in it. This tool does not force one character from each set, because forcing composition is not a strength feature. The current NIST guidance says verifiers shall not impose composition rules, and its appendix explains why: rules like must contain a symbol produce predictable choices, with users adding a capital at the start and a digit and a symbol at the end, in patterns like Password1! that attackers try early. A uniform random draw from 94 characters will usually include all four sets anyway, and when it does not, the checklist tells you.

Random passwords vs passphrases

The two modes on this page solve different problems. A random password is the strongest secret per character, and it is the right choice whenever you do not need to remember it yourself, which is nearly every account if you use a password manager. A passphrase is weaker per character but far easier to remember, type, and say aloud, and it is the right choice for the few secrets you must carry in your head. The table below compares them on the numbers that matter.

FeatureRandom password, 16 charactersPassphrase, 6 words
Entropy104.9 bits60 bits
Strength labelVery strongGood
Possible valuesAbout 3.7 × 10^31About 1.2 × 10^18
Offline fast attack, 10 billion guesses per secondAbout 59 trillion yearsAbout 1.8 years
Offline slow attack, 10,000 guesses per secondAbout 5.9 × 10^19 yearsAbout 1.8 million years
Online throttled attack, 100 guesses per hourAbout 2.1 × 10^25 yearsAbout 658 billion years
Typical length16 charactersAbout 37 characters with separators
Easy to memorizeNoYes
Easy to type on a phoneSlow, symbols need extra keyboardsYes, plain words
Best forEvery account stored in a password managerMaster passwords, Wi-Fi passwords, anything you type by hand

The gap between the two columns looks dramatic, and it is, but the right reading is not that passphrases are weak. A 6-word passphrase at 60 bits resists an online attack for billions of years and a slow-hash offline attack for 1.8 million years, which is more than enough for any account whose password database is properly hashed. Its weak spot is the fast-hash offline attack, where 1.8 years is uncomfortably short if a service stores passwords with a fast hash and then loses the database. That is why the strongest advice is to use a random password wherever a manager can fill it in, and to reserve passphrases for the secrets you must remember.

The passphrase numbers also depend on the word list, and this tool's list is smaller than the best-known one. The Electronic Frontier Foundation's long word list for dice-generated passphrases has 7,776 words, picked with five dice per word, and six words from it give about 77.5 bits of entropy, because log2 of 7,776 is about 12.9 bits per word. This tool's list of 1,024 words gives exactly 10 bits per word and 60 bits for six words. The trade is deliberate: a smaller list of very common words is easier to remember and type than a large list that includes rarer words, and the meter shows the exact cost, so the choice is informed rather than hidden.

One thing the table cannot show is how people actually behave. A random password that a person tries to memorize usually ends up written on a sticky note, reused across accounts, or simplified until it is no longer random. A passphrase that a person can actually remember gets used properly: unique to one account, never written down, never shared. For the master password that guards all your other passwords, a memorable passphrase you can recall under stress beats a random string you cannot.

What the official guidance says

Password advice has changed in the last few years, and some of the rules people remember from a decade ago are now officially discouraged. The authority most often cited is the U.S. National Institute of Standards and Technology, whose Special Publication 800-63B, Digital Identity Guidelines: Authentication and Lifecycle Management, sets the rules for federal systems and is widely followed by the private sector. The current edition, 800-63B-4, was published in August 2025, and this tool's design follows it. The U.S. Cybersecurity and Infrastructure Security Agency, CISA, gives the same advice in plainer language for the general public.

The first rule is length over complexity. NIST requires verifiers to accept passwords of at least 15 characters for single-factor use, and recommends they permit a maximum length of at least 64 characters, so users are never forced into short passwords by an arbitrary cap. This tool's length range, 8 to 64, covers the full NIST range at the top end and goes below it at the bottom end only because some older sites still cap passwords at short lengths; the default of 16 sits above the NIST minimum. CISA's public advice is simpler: make it at least 16 characters, and longer is better. The reason length wins is arithmetic: every character multiplies the search space by the pool size, so adding four characters to a 12-character password multiplies the guessing work by 94 to the power of 4, about 78 million times.

The second rule is that composition requirements are out. NIST says verifiers shall not impose composition rules, meaning they must not require a mix of character types, and they shall not require passwords to be changed on a schedule. Both rules are reversals of older guidance, and both have the same reason: they backfire. When a site demands a capital, a digit, and a symbol, users do not become more random; they become more predictable, capitalizing the first letter and tacking a digit and a symbol onto the end. NIST's appendix names the pattern directly, citing choices like Password1 and Password1! as the predictable result of composition rules. Forced rotation has the same problem: when people must change a password every 90 days, they change it as little as possible, turning Summer1 into Summer2. The current rule is to change a password only when there is evidence it has been compromised. This tool follows the same principle: it never forces a character set on you, and it never suggests changing a password that is still secret.

The third rule is about what verifiers must do behind the scenes. NIST requires verifiers to compare a new password against a blocklist of known, commonly used, expected, or compromised passwords, so that a password like password123 is refused even if it passes a length check. It recommends verifiers accept all printing ASCII characters and the space, and to check the entire password, with no truncation, so that a 64-character password is really a 64-character password. It forbids password hints and knowledge-based prompts, the security questions about your first pet and your mother's maiden name, because the answers are often public. And it requires verifiers to allow password managers and autofill, and recommends they permit pasting, so that a user with a manager is never forced to type a long random password by hand.

CISA's public advice compresses the same guidance into three words: long, random, and unique. Long means at least 16 characters, with more being better. Random means a mix of upper and lowercase letters, numbers, and symbols, or a passphrase of five to seven unrelated words. Unique means used for only one account, so that a breach at one service cannot spill into another. CISA also recommends a password manager for everyone, and multi-factor authentication wherever it is offered, especially for email, social media, and financial accounts: a stolen password alone is not enough to sign in when a second factor is required.

The EFF's guidance on passphrases completes the picture. The EFF recommends a passphrase of at least six words from a word list, generated with dice for the most sensitive secrets, because dice give a physical source of randomness that no software can quietly bias. Its long list of 7,776 words gives a six-word passphrase about 77.5 bits of entropy, against 60 bits for six words from this tool's 1,024-word list. Both agree on the core point: a passphrase of unrelated words, chosen at random, is far stronger than a sentence made of words you picked yourself, because your own choices are predictable in ways a random draw is not.

How long should a password be?

The table below gives the numbers for the most common case: a random password drawn from all 94 characters, attacked offline at 10 billion guesses per second, the fastest of the four scenarios this tool models. Each extra character multiplies the guessing time by 94, so a password that is four characters longer takes about 78 million times longer to crack.

LengthEntropyStrength labelOffline fast attack
8 characters52.4 bitsFairAbout 3.5 days
12 characters78.7 bitsGoodAbout 754 thousand years
15 characters98.3 bitsStrongAbout 626 billion years
16 characters104.9 bitsVery strongAbout 59 trillion years
20 characters131.1 bitsExcellentAbout 4.6 × 10^21 years
24 characters157.3 bitsExcellentAbout 3.6 × 10^29 years
32 characters209.7 bitsExcellentAbout 2.2 × 10^45 years
64 characters419.5 bitsExcellentAbout 3 × 10^108 years

Three conclusions follow. First, 8 characters is not enough for anything important: 3.5 days against a fast offline attack is within reach of any determined attacker, and 8 lowercase-only characters fall in about 10 seconds. Second, 12 characters is the practical floor, and 16 is the sensible default: at 16 characters the offline-fast crack time is 59 trillion years. Third, beyond 20 characters the numbers stop mattering for guessing resistance: a 20-character password at 131 bits is already beyond the reach of any attacker. There is no downside to a longer password when a manager fills it in, so for accounts that hold money or email, 20 to 32 characters is a reasonable choice.

For passphrases, the equivalent table uses the word count, with each word adding exactly 10 bits from this tool's 1,024-word list. Both offline attacks are shown, because a passphrase's real-world protection depends heavily on how the service stores its passwords.

WordsEntropyStrength labelOffline fast attackOffline slow attack
3 words30 bitsWeakLess than a secondAbout 15 hours
4 words40 bitsFairAbout 55 secondsAbout 1.7 years
5 words50 bitsFairAbout 16 hoursAbout 1.8 thousand years
6 words60 bitsGoodAbout 1.8 yearsAbout 1.8 million years

The passphrase table makes the case for six words plainly: five words fall in 16 hours to a fast offline attack, while six hold for 1.8 years, and the slow-hash column shows that six words hold for 1.8 million years when the service hashes passwords properly. Three words are not a password at all by modern standards: less than a second offline, and only 15 hours even against a slow hash. If a site limits you to a short password, use random characters instead of a short passphrase, because 8 random characters from the full pool at 52.4 bits beat 4 words at 40 bits.

Common mistakes to avoid

Reusing a password across accounts. This is the single most damaging password habit, and it defeats even a 100-bit password. When a service is breached and its password database leaks, attackers try every leaked password against every other major service, a practice called credential stuffing. If your password is unique to one account, a breach costs you that account only. If it is shared across ten accounts, one breach costs you all ten. Unique passwords are the reason password managers exist.

Choosing a password yourself instead of generating one. Human-chosen passwords cluster around a small set of patterns: a name, a date, a word, and a digit, with a capital at the start and an exclamation mark at the end. Attackers know these patterns and try them first, using lists built from billions of leaked passwords plus rules that generate the common variations. A password that looks random to you, like Guitar2026!, sits in a space of perhaps a few billion likely choices, not the sextillions that a truly random password of the same length occupies.

Trusting a password because it contains a symbol. A symbol does not make a password strong; randomness and length do. The password Password1! contains an uppercase letter, a digit, and a symbol, and it passes most composition checks, yet it is one of the first passwords an attacker tries, because millions of people have chosen exactly it or something close to it. NIST's appendix uses this pattern as its example of why composition rules fail. Judge a password by its entropy, not by whether it ticks the boxes on a signup form.

Changing a strong password on a schedule. The old advice to change passwords every 90 days is retired. NIST says verifiers shall not require periodic changes, because forced rotation produces weaker passwords: people make the smallest change that passes, turning Summer1 into Summer2. Change a password when there is evidence it has been compromised, when a service tells you it was breached, or when you have shared it with someone who should no longer have it. Otherwise, leave a strong, unique password alone.

Storing passwords in a document, a note, or an email. A password written in a plain text file, a notes app without encryption, a spreadsheet, or an email draft is a password waiting to be found. Anyone with access to the device, the account, or a backup has access to every password in the file. A password manager encrypts the vault with your master password, so the stored passwords are useless without it.

Ignoring multi-factor authentication. A password, however strong, is one factor: something you know. If it leaks, it is all an attacker needs. Multi-factor authentication adds a second factor, something you have, like a phone that receives a code, or something you are, like a fingerprint. CISA recommends enabling it everywhere it is offered, especially for email, social media, and financial accounts, because email is the key to password resets on every other service. An authenticator app or a hardware security key is stronger than a code sent by text message, but any second factor is far better than none.

Answering security questions truthfully. Your mother's maiden name, your first pet, and the street you grew up on are often public information, discoverable from social media or public records. NIST forbids verifiers from using knowledge-based prompts for exactly this reason. Where a site still asks for security questions, treat the answers as extra passwords: generate random answers with this tool, store them in your password manager, and never give a true answer that anyone could look up.

Frequently asked questions

How long should a password be?

At least 16 characters for anything important, and longer when a password manager fills it in for you. NIST requires verifiers to accept passwords of at least 15 characters for single-factor use, and CISA advises at least 16 characters, with more being better. The numbers explain why: a random 8-character password from all 94 characters has 52.4 bits of entropy and falls to a fast offline attack in about 3.5 days, while a 16-character password has 104.9 bits and holds for about 59 trillion years. For accounts that hold money or email, 20 to 32 characters is a reasonable choice.

Is a passphrase as strong as a random password?

Not character for character, but a long passphrase is strong enough for the job it is meant to do. A 6-word passphrase from this tool's 1,024-word list has 60 bits of entropy and resists a fast offline attack for about 1.8 years, while a 16-character random password has 104.9 bits and holds for about 59 trillion years. The passphrase wins on memorability: it is the right choice for the few secrets you must remember yourself, such as your password manager's master password. For every other account, use a random password and let the manager remember it.

Are the passwords this tool generates really random?

Yes. Every character and every word is drawn with crypto.getRandomValues, the browser's built-in cryptographic random number generator, which MDN describes as providing cryptographically strong random values from a generator seeded with enough entropy for cryptographic purposes. The tool never uses Math.random for passwords, because MDN states that Math.random does not provide cryptographically secure random numbers and should not be used for anything related to security. Each character is drawn uniformly from the pool you selected, so every possible password of that shape is equally likely.

Does this tool store or send my password?

No. Your password is generated inside your browser and never leaves it: nothing is sent to a server, nothing is saved in a cookie or a database, and the tool keeps no history of what it generated. That is deliberate, because a password generator that remembered your passwords would be a liability. Copy it into a password manager or another safe place before you leave the page.

Should I change my password every few months?

No. The current NIST guidance says verifiers shall not require periodic password changes, because forced rotation makes passwords weaker: people change the password as little as possible, turning one guessable password into another. Change a password when there is evidence it has been compromised, when a service reports a breach, or when someone who should no longer have it has seen it. A strong, unique password that is still secret should be left alone.

What is password entropy?

Entropy is the measure of how hard a password is to guess by brute force, counted in bits. Each bit doubles the number of possible passwords: a password with 60 bits of entropy has about a million trillion possible values. For a random password, the entropy is the length times the base-2 logarithm of the pool size, so a 16-character password from 94 characters has 16 times log2 of 94, which is 104.9 bits. For a passphrase, it is the word count times the base-2 logarithm of the list size, so 6 words from a 1,024-word list give exactly 60 bits.

Why does the strength meter not require a symbol in every password?

Because forcing a symbol does not make passwords stronger, and the current NIST guidance says verifiers shall not impose composition rules. When a site demands a symbol, users add one predictably, usually at the end, in patterns like Password1! that attackers try early. A uniform random draw from 94 characters usually includes symbols anyway, and when it does not, the checklist under the result tells you. If a site you use still demands a symbol, press Regenerate until the checklist shows one.

Sources

Every figure on this page comes from one of the sources below, each accessed 20 November 2026, or from arithmetic shown in full on the page.

  • pages.nist.gov — NIST Special Publication 800-63B-4, Digital Identity Guidelines: Authentication and Lifecycle Management, August 2025: memorized secrets shall be at least 15 characters for single-factor use, at least 8 where a second factor is required, and verifiers should permit a maximum length of at least 64 characters; verifiers shall not impose composition rules, shall not require periodic changes, shall not permit hints or knowledge-based prompts, shall verify the entire password, shall compare new passwords against a blocklist of known, commonly used, expected, or compromised passwords, and shall allow password managers and should permit pasting; the appendix notes that composition rules produce predictable choices such as Password1!, that offline attackers can compute many billions of hashes per second, and that keystroke logging, phishing, and social engineering are equally effective on lengthy and complex passwords. Accessed 20 November 2026.
  • developer.mozilla.org — Crypto: getRandomValues method: lets you get cryptographically strong random values, from a pseudorandom number generator seeded with enough entropy to be suitable for cryptographic purposes. Accessed 20 November 2026.
  • developer.mozilla.org — Math.random: does not provide cryptographically secure random numbers, and should not be used for anything related to security; the Web Crypto API, and more precisely window.crypto.getRandomValues, is the replacement. Accessed 20 November 2026.
  • github.com — zxcvbn, a realistic password strength estimator by Dropbox: crack-time scenarios of 100 guesses per hour for an online attack with throttling, 10 guesses per second for an online attack without throttling, 10,000 guesses per second for an offline attack against a slow hash, and 10 billion guesses per second against a fast hash. Accessed 20 November 2026.
  • eff.org — Electronic Frontier Foundation, Dice-Generated Passphrases: a six-word passphrase is suggested for most applications, and a minimum of six words from the long wordlist is recommended; a six-word passphrase from the long list is one of about 2 to the power of 77 alternatives; the long list has 7,776 words, picked with five dice per word, and the short lists have 1,296 words each. Accessed 20 November 2026.
  • cisa.gov — CISA, Four Cybersecurity Essentials for Businesses: passwords should be long, at least 16 characters, random, a mix of upper and lowercase letters, numbers, and symbols, or a passphrase of 5 to 7 unrelated words, and unique, used for only one account; organizations should provide a company-wide password manager. Accessed 20 November 2026.
  • cisa.gov — CISA, Use Strong Passwords: use a password manager to generate and store unique passwords, and enable multi-factor authentication wherever it is offered, especially for email, social media, and financial accounts. Accessed 20 November 2026.