Tool / Text & Dev

Password Generator

Use Kitly Password Generator to create random passwords locally in your browser for accounts, admin panels, Wi-Fi sharing, and temporary credentials. Store a generated value in a password manager and never reuse page examples.

Generated passwordChoose options and generate a password.
Guidance published by Kitly

How to create and keep a strong password

A generated password is most useful when it is long, unique to one account, and stored safely.

  1. Choose the account requirements

    Set a supported length and character groups. Use at least 16 random characters when the service allows it.

  2. Generate a random password

    Create a new value in the browser. Regenerate if the destination rejects a symbol or has a different length rule.

  3. Store it safely

    Save the password in a trusted password manager and remove it from temporary notes, messages, or clipboard history when practical.

Better account security habits

  • Use a different password for every account so one breach does not unlock other services.
  • Turn on multi-factor authentication, preferably with a passkey or authenticator app when available.
  • Use a password manager instead of making generated passwords shorter enough to memorize.

What the strength indicator means

  • The on-page strength label is an estimate, not a guarantee that an account cannot be compromised.
  • A strong password cannot protect against phishing, malware, account recovery attacks, or a breached service.
  • Kitly does not save generated passwords, so a lost value cannot be recovered from this site.

Practical guidance

These examples show how length and the selected character pool change the upper-bound estimate. The printed passwords are public illustrations. Never reuse them.

The generator needs JavaScript because the browser uses Web Crypto to draw a new password locally. The setting notes and the estimate assumptions below stay readable without JavaScript. This page cannot generate a password without it.

How to read the estimate

The bit number is length times log2 of the filtered pool, then rounded. The time assumes an offline attacker at 10^12 guesses per second and an average search of half the space. It is not a security guarantee. Never reuse the example strings.

16 characters from the full filtered pool

With every set on and ambiguous characters removed, a 16-character password has an upper bound of 101 bits. The page calls that Very strong and about 54 billion years. The string below is public: never reuse it.

Illustrative password, never reuse

kT7#mP2$qR9&nS4!
Settings
Length 16 characters
Lowercase, uppercase, numbers, symbols On
Avoid ambiguous characters On (removes 0, O, I, l, and 1)

Estimate

101 bits. Very strong. About 54 billion years at 1 trillion guesses per second.

What to check

Removing ambiguous characters leaves 81 symbols: 25 lowercase, 24 uppercase, 8 digits, and 24 symbols. 16 × log2(81) is 101.4376 bits, which the page rounds to 101. The Very strong label starts at 100 bits. The same unrounded value, halved and divided by 10^12 guesses per second, rounds to 54 billion years. This published string only shows the length and one character from each set. Generate a new password for a real account.

Caveats

  • Never reuse kT7#mP2$qR9&nS4!. It is printed on a public page.
  • The required mix makes the real combination count smaller, so 101 bits is an upper bound.
  • The duration is not a measured attack, a hash-cost test, or protection against phishing, reuse, or a breach of the site that stores the password.

Example files

12 letters and digits, symbols off

Turning symbols off is reasonable when a site rejects them. The upper bound falls to 70 bits, which this page labels Fair. Never reuse the example.

Illustrative password, never reuse

kT7mP2qR9nS4
Settings
Length 12 characters
Lowercase, uppercase, numbers On
Symbols Off
Avoid ambiguous characters On

Estimate

70 bits. Fair. About 19 years at 1 trillion guesses per second.

What to check

The filtered pool is 57 characters. 12 × log2(57) is 69.9947 bits, shown as 70. Fair covers 48 bits up to but not including 72, so 70 stays Fair. The time formula rounds to 19 years. That figure still assumes a uniform offline search at exactly 10^12 guesses per second. It does not mean an account is safe for 19 years.

Caveats

  • Never reuse kT7mP2qR9nS4.
  • A site can still reject a remaining character or require a symbol. Generate again after you change the sets. Do not shorten a saved password by hand.
  • Composition checkboxes here select the random pool. They are not evidence that adding a symbol to a human-chosen word makes it strong.

Example files

8 digits from the filtered digit set

The shortest length and digits only produce a 24-bit upper bound. The page labels it Weak and says the average search would take less than a second. Never reuse the example.

Illustrative password, never reuse

38472956
Settings
Length 8 characters
Numbers On
Letters and symbols Off
Avoid ambiguous characters On, so the digits are 2–9

Estimate

24 bits. Weak. Less than a second at 1 trillion guesses per second.

What to check

Eight filtered digits are an alphabet of 8, and 8 × log2(8) is exactly 24 bits. Anything under 48 bits is Weak. 2^23 / 10^12 seconds is 0.00000839, which the page collapses to less than a second. Use a combination this small only when the service truly allows nothing longer. NIST SP 800-63B-4 sets 15 characters as the minimum for a password used as the only factor, and allows 8 when that password is used only with another factor. This slider starts at 8 so it can match a short field. It does not check that a second factor exists.

Caveats

  • Never reuse 38472956.
  • An online service that rate-limits guesses is a different situation from this offline illustration. The page does not model that service.
  • A larger estimate would still not prevent phishing, malware, account-recovery abuse, or a leaked password database.

Example files

Settings that change the pool

Length runs from 8 to 64. Each checked set adds its characters, and Avoid ambiguous characters removes 0, O, I, l, and 1 before the draw.

Length

Use when: Use 16 or more when the service allows it. NIST's current single-factor minimum is 15 characters; this control starts at 8 because some fields are still shorter, including passwords used only with a second factor.

Trade-offs: The upper bound grows linearly with length. A short pool, as in the 8-digit example, stays weak even though the form accepts it.

Character sets

Use when: Match the characters the destination accepts. Keep symbols on when they are allowed. The symbol set is !@#$%^&*()-_=+[]{};:,.?/ (24 characters).

Trade-offs: A set the site rejects wastes a generation. Uncheck it and generate again. The checkboxes do not make a human-chosen password stronger by themselves.

Avoid ambiguous characters

Use when: Someone may have to read or retype the password. The removed characters are 0, O, I, l, and 1.

Trade-offs: The full filtered pool shrinks from the unfiltered mix to 81 characters. Digits alone shrink from 10 to 8. That lowers the upper bound.

Uniqueness, storage, and the clipboard

Use when: You need a new value for one account. Store it in a password manager. Kitly does not save it, and a lost value cannot be recovered here.

Trade-offs: Each click draws again from Web Crypto. The tool does not check breach lists or your other accounts. Copy uses the clipboard, which the system or another app may keep. This page does not clear the clipboard afterward.

What the time figure leaves out

Use when: You want to compare two settings on this page. Read it as an illustration under the stated assumptions.

Trade-offs: It assumes uniform random choices and exactly 10^12 offline guesses per second. Phishing, reused passwords, and a breach of the destination are outside that picture. A high bit number does not prevent them.

When generation or copying fails

Problem: Select at least one character type.

Likely cause: No set is checked, or every checked set became empty after ambiguous characters were removed.

What to do: Check at least one set that still contains characters. The previous password is cleared.

Problem: Secure random generation is not available in this browser.

Likely cause: crypto.getRandomValues is missing, so the rejection-sampling draw cannot run.

What to do: Use a current browser with Web Crypto. The page clears the password instead of showing a weak fallback.

Problem: The password could not be copied.

Likely cause: The clipboard write failed, and the older document copy command also failed.

What to do: Select the visible password and copy it with the browser's own command, then clear the clipboard history when you can. Do not send it in a message you do not control.

Problem: The site rejected the generated password.

Likely cause: Its length or a character is outside that site's rules. The estimate does not know those rules.

What to do: Change the length or turn off the rejected set, then generate again. Do not edit a saved password down to a memorable word.

Relevant sources

The bit and time figures are this page's formula. The length guidance and the limits of complexity come from NIST. The random source and the clipboard are the web platform APIs the button uses.

  • NIST SP 800-63B-4, passwords Requires at least 15 characters for a password used as the only factor, allows 8 when it is used only with another factor, and says verifiers should allow at least 64 characters.
  • NIST SP 800-63B-4, strength of passwords Treats length as the main strength factor, finds limited benefit in composition rules for user-chosen passwords, and states that phishing and keystroke logging are not stopped by length or complexity.
  • MDN: Crypto.getRandomValues The Web Crypto method this generator requires. If it is missing, the page clears the password.
  • MDN: Clipboard.writeText The clipboard write used by Copy password. Clipboard history is outside this page.

Frequently asked questions

Does the password generator send passwords to a server?

No. Password generation runs in your browser with the Web Crypto secure random generator, so the password is not sent to Kitly servers. If Web Crypto is unavailable, the page clears any generated value.

What makes a strong generated password?

A longer password using a larger character set raises the upper-bound estimate. That figure assumes an offline attacker at 10^12 guesses per second and does not prevent phishing, reuse, or a compromised account.

Why avoid ambiguous characters?

Ambiguous characters such as 0, O, I, l, and 1 can be hard to read or type correctly when passwords are copied into notes, messages, or shared verbally.

Can I use the example passwords printed on this page?

No. They are public examples so the length and character mix can be checked. Never reuse them for an account or a network. Generate a new password and store that private value in a password manager.

Does a high bit estimate prevent phishing or a compromised account?

No. The figure is an upper bound for an offline guessing illustration at 10^12 guesses per second. It does not stop phishing, malware, reused passwords, leaked databases, or weak storage at the service. The page states that limit next to the estimate.