Trying every 11-character password from a 95-character pool takes about 18,024 years at 10 billion guesses per second. This free password crack time calculator shows that upper bound, the average time and the entropy for any password you type. Nothing you enter reaches our server. A password built from words or patterns falls far sooner.
Time to guess it (patterns first)
about 42 years
Guessing this 28-character password takes about 42 years at the speed chosen; trying every combination takes about 10^32 years.
- Time to guess it (patterns first)
- about 42 years
- Time to try every combination (upper bound)
- about 10^32 years
- Patterns an attacker tries first
- A dictionary word, a common password
- Strength
- Moderate: acceptable behind rate limiting, short of a strong secret.
- Average time by brute force alone
- about 10^31 years
- Entropy if every character were random (bits)
- 164.7
- Character pool
- 59
- Length
- 28
At other guessing speeds
| Attack or guessing speed | Time to guess it | Time to try every combination |
|---|
How this is calculated
- How it works
- The headline counts guesses in the order attackers try them, using the zxcvbn-ts estimator (MIT license): about 49,000 common passwords, English words and names, letter swaps such as @ for a, keyboard patterns, repeats, runs such as abc or 123, dates and recent years, plus published example passwords such as Tr0ub4dor&3. It shows the lower of that count and the brute-force average. The upper bound assumes every character was picked at random from the classes the password uses: 26 lowercase, 26 uppercase, 10 digits and 33 keyboard symbols. Both run in this page. The named attack speeds come from the Hashcat v6.2.6 benchmark on the Nvidia RTX 4090 (opens in new window) (one card at stock clocks, October 2022): bcrypt is measured at cost 5, so a site using cost 10, the PHP default, is 32 times slower to attack. The optional breach check asks Have I Been Pwned's Pwned Passwords API (opens in new window) for every breached hash sharing the first 5 characters of the password's SHA-1 hash, padded so the reply size gives nothing away, and looks for a match in this page.
- Not covered
- A built-in list of common passwords and words, plus an optional breach check you start; no rate limiting or lockouts.
- Data checked
- : The named attack speeds from hashcat 6.2.6 benchmark rates for one RTX 4090 at stock clocks.
- Privacy
- What you enter never reaches our server. Your password is scored inside this page and never sent. Only if you press Check breach lists does your browser send Have I Been Pwned the first 5 characters of the password's SHA-1 hash (and, as with any web request, your IP address); the match against the list it returns happens here.
- Corrections
- Report a wrong result to media@sqmagazine.co.uk; every report is reviewed and confirmed errors are corrected. Include the inputs and the answer you expected. With your permission, we thank you by name on this page.
- Updates
- Published.
- Feedback
- How useful was this tool?
Table of Contents
How to Use the Password Crack Time Calculator
The password crack time calculator needs two inputs: a password and a guessing speed. It then times a brute-force search of every password of that length and character mix, the brute-force attack MITRE files as Password Guessing. In MITRE’s words, an adversary may systematically guess the password using a repetitive or iterative mechanism.
- Type a password into “Password to test”. The field is masked. A safer habit is to test a made-up password with the same length and character types as yours.
- Pick a speed under “Guesses per second”. The menu offers 5 presets, listed below.
- Read “Time to try every combination (upper bound)”, then “Average time to find it”.
- Check “Entropy if every character were random (bits)”, “Character pool”, “Length” and “Strength”.
These are the speed presets, slowest to quickest.
- “A thousand a second”.
- “A million a second”.
- “A billion a second”.
- “10 billion a second” (the default).
- “A trillion a second”.
Below the results, the “At other guessing speeds” table repeats the time at every preset. “Copy all details” copies the results without the password, and “Share result” builds a link that keeps your speed but never the password. “Download CSV” saves the speeds table to your device.
Every number in that panel comes from one exponent.
How Password Crack Time Is Calculated
Password crack time is the number of possible passwords divided by the guesses per second. That count is the character pool raised to the power of the length, which grows fast. Halfway is where a search finds the password on average, so the average time is half the full search.
Per the fourth revision of NIST’s Digital Identity Guidelines, entropy is “The amount of uncertainty that an attacker faces to determine the value of a secret.” NIST adds that “A value with n bits of entropy has the same degree of uncertainty as a uniformly distributed n-bit random value.”
The tool builds the pool from the character classes it finds in what you typed:
- Lowercase letters add 26, uppercase letters add 26 and digits add 10.
- Any other character adds the 33 printable keyboard symbols, space included. An accented letter or an emoji counts as a symbol too.
- Each class counts in full or not at all: one digit adds all 10.
With N as the pool, L as the length and R as the guesses per second:
- Combinations = N to the power L.
- Time to try every combination = N to the power L, divided by R.
- Entropy in bits = L × log2(N).
The tool’s entropy is NIST’s figure for a password drawn at random from the pool, which is why the output is labeled “Entropy if every character were random (bits)”. A year is 31,557,600 seconds, or 365.25 days. From a thousand years up, the panel rounds the time and names the scale in words.
Run the default password through those steps and the tool’s result falls out.
Worked Example: Tr0ub4dor&3, the Tool’s Default
The tool loads with the password Tr0ub4dor&3 and the default speed selected. Six steps rebuild its result panel:
- Pool: lowercase, uppercase, digits and a symbol are all present, so 26 + 26 + 10 + 33 = 95, matching “Character pool”.
- Length: 11 characters, matching “Length”.
- Combinations: 95 to the power 11 = 5,688,000,922,764,599,609,375.
- Seconds: divided by the preset speed, that is about 568.8 billion seconds.
- Years: divided by 31,557,600, it is about 18,024 years to try every combination, and about 9,012 years on average. The panel rounds both to the nearest thousand years.
- Entropy: 11 × log2(95) = 72.3 bits, which sits in the tool’s Moderate band.
“Strength” then reads “Moderate: acceptable behind rate limiting, short of a strong secret”. Look at the password itself, though. Tr0ub4dor is a variant spelling of the word troubadour with 0 for o and 4 for a, followed by a symbol and a digit. The arithmetic treats it as 11 random characters, and it is nothing of the kind.
What the Result Means
The result is the longest a brute-force search could take for a random password of that length and character mix, at the speed you picked. It’s a ceiling, not a forecast. The tool’s thresholds turn entropy into four labels: Weak below 60 bits, Moderate from 60, Strong from 80 and Very strong from 128.
A long time on the dial means a pure guessing attack is unlikely to finish. It does not mean the account is safe. NIST is direct on this point: “Keystroke logging, phishing, and social engineering attacks are equally effective on lengthy and complex passwords as they are on simple ones.” A password typed into a fake login page is lost at any length, the pattern covered in how phishing works.
Read the number as a statement about the password’s shape. A long, random password helps reduce the risk of guessing attacks; it promises nothing about the rest.
Brute Force vs Dictionary Attacks
A brute-force attack tries every combination in order; a dictionary attack tries likely passwords before anything else, and most real attacks start there. MITRE’s ATT&CK knowledge base notes that an adversary may guess credentials by using a list of common passwords. NIST’s guidance puts it plainly: “Passwords that are too short yield to brute-force attacks and dictionary attacks.”
People also bend words in predictable ways. NIST’s own example: a user who might have chosen “password” would be relatively likely to choose “Password1” if required to include an uppercase letter and a number or “Password1!” if a symbol is also required. Tr0ub4dor&3 follows the same recipe, so the tool’s upper bound overstates it by an amount the tool can’t measure.
The pool model rewards that habit. Take the & out of the default and the pool drops from 95 to 62, and the bound falls to about 165 years. That one symbol multiplies the time by about 109, while a twelfth character multiplies it by 95. On paper, a tacked-on symbol beats extra length; against a dictionary attack, it is the first thing tried.
NIST’s guidelines require verifiers, the systems that check a login, to compare new passwords against a blocklist that contains known commonly used, expected, or compromised passwords, a list that may include dictionary words and passwords from earlier breaches. The reused and predictable choices those lists catch are tracked in our password statistics.
Online vs Offline Password Guessing
How fast passwords can be cracked depends on where the guessing happens. Against a live login, NIST’s guidelines tell verifiers to limit consecutive failed authentication attempts using a specific authenticator on a single subscriber account to no more than 100. The UK’s NCSC recommends throttling, a delay between attempts that restricts the number of guesses an attacker can attempt.
Offline, the limits vanish. MITRE describes password cracking as recovering plaintext when credential material such as password hashes are obtained, usually on the attacker’s own systems. NIST warns that attackers can compute many billions of hashes per second in an offline environment that is not subject to rate limiting. The tool’s speeds in the billions describe that offline case: a stolen hash file and no lockout.
The speed also depends on how the site stored the password.
A hash is the scrambled form a site keeps instead of the password itself. NIST’s guidelines require verifiers to store passwords salted and hashed using a suitable password hashing scheme, whose cost factor makes each guess more expensive. That factor should be increased over time to account for increases in computing performance, so the guess rates in the tool will keep moving. OWASP’s Password Storage Cheat Sheet says fast hashes such as SHA-256 allow attackers to perform large numbers of guesses quickly.
The help note under “Guesses per second” makes the same point: the speed is your assumption, and a slow hash such as bcrypt is guessed far more slowly than MD5. Breaches that expose password files are tracked in our data breach statistics.
How long does it take to crack a password?
At the tool’s default speed, the random password shapes below take from days to trillions of years. Shorter ones fall in seconds or minutes. The table runs the tool’s formula across settings it shows only one at a time:
| Password shape | Pool | Entropy (bits) | Time to try every combination |
|---|---|---|---|
| 11 lowercase letters | 26 | 51.7 | about 4 days |
| 11 letters and digits | 62 | 65.5 | about 165 years |
| 11, all four classes (default) | 95 | 72.3 | about 18,024 years |
| 12, all four classes | 95 | 78.8 | about 1.7 million years |
| 15, all four classes | 95 | 98.5 | about 1.5 trillion years |
| 16, all four classes | 95 | 105.1 | about 139.5 trillion years |
Source: values computed with the tool’s formula (pool to the power of length, divided by 10 billion guesses a second); entropy per NIST’s Digital Identity Guidelines
Length does most of the work, and the standards lead with it. NIST says that “Password length is a primary factor in characterizing password strength”. Its rules tell verifiers to require passwords used on their own to be a minimum of 15 characters in length, and CISA asks for “At least 16 characters”. Every row above assumes random characters, so the times apply only to a password a generator drew.
Good to Know Before You Use It
The password crack time calculator runs in your browser, and nothing you enter reaches our server; the password is also left out of the share link and the copied results. It assumes every character was picked at random from the classes the password uses, and that an attacker must search the whole space at one steady speed.
The method is a full brute-force count: pool to the power of length, divided by the speed you choose, with the average at half. It runs no dictionary, pattern or leaked-password checks and models no rate limiting or lockouts, so a password built from words, names or dates falls far sooner than the bound shows.
SQ Magazine publishes this page for information. A long, random password helps reduce the risk of guessing attacks; the page promises no security outcome and cannot stop phishing or malware.
Conclusion
At 10 billion guesses per second, Tr0ub4dor&3 holds out for about 18,024 years against a pure brute-force search, and far less against a dictionary attack that knows the word. Try your own password’s shape, then try it with four more characters and see how far the bound moves. A password manager makes long passwords painless to use; adoption is tracked in our password manager statistics.
























































