tech calculator

Password Entropy & Strength Calculator

Measure password or passphrase strength in bits of entropy and see the average time to crack it.

Password Entropy (bits) = Length × log₂(Character Pool Size); a passphrase uses Words × log₂(Wordlist Size). Example: 12 characters from the full 94-character pool is 78.66 bits, and a 6-word diceware passphrase is 77.55 bits — 80 bits is the usual bar for a strong password.

Formula Verified by Dr. James Callahan, PhD

Quick actions: Save inputs, view saved runs, print, share, or export results

Saved Runs

Inputs

What are you measuring?

Password Lengthchars

Character Classes Used

Lowercase a–z (26)Uppercase A–Z (26)Digits 0–9 (10)Symbols (32)

Attacker Capability

Guesses per Second (edit for a specific threat model)

Results

Entropy

78.66 bits

Strength BandReasonable

Character Pool Size94

Bits per Character6.5546

Total Combinations4.759e+23

Average Time to Crack7.5 thousand years

Tip

Useful whenever you set a password policy, evaluate a passphrase scheme, or need to justify a length requirement with a number rather than an opinion.

Formula

Password entropy formula

Character password:  Entropy (bits) = Length × log₂(Pool Size)
Passphrase:          Entropy (bits) = Words × log₂(Wordlist Size)
Pool Size = 26 (lowercase) + 26 (uppercase) + 10 (digits) + 32 (symbols)
Combinations = Pool Size ^ Length
Average Time to Crack = 2^(Entropy − 1) ÷ Guesses per Second

Entropy measures the size of the space a password was drawn from, in bits: each additional bit doubles the work an attacker has to do. The crack time uses half the keyspace, 2^(bits − 1), because an attacker searching randomly expects to find a uniformly random secret halfway through. Both formulas assume the password really was generated at random — a human-chosen password sits far below its theoretical entropy, and this is the one assumption that matters most.

Step by step

How the calculation works

1Choose whether you are measuring a random character string or a random-word passphrase. They are scored differently: a character password gets log₂(pool) bits per character, a passphrase gets log₂(wordlist) bits per word — about 12.9 bits per word from the standard 7,776-word diceware list.
2For a character password, switch on only the character classes actually used. The pool is the sum of the classes: 26 lowercase, 26 uppercase, 10 digits, and 32 symbols, for the familiar 94-character printable-ASCII total when all four are on.
3The guesses-per-second figure sets the attacker you are defending against, and it changes the answer by many orders of magnitude. A throttled online login endpoint might manage a thousand attempts per second; an offline attack on a stolen database of fast unsalted hashes can reach a trillion. Pick the threat that matches where the password is actually stored.
4Read the bits, not the crack time. Entropy is a stable property of how the password was generated; the crack time is that number divided by an attacker assumption that will keep getting faster. Sixty bits is a reasonable floor for an ordinary online account, eighty bits is strong, and a hundred or more suits long-term key material.
5This calculator scores a password you already have or are planning. To generate one instead, use the [password calculator](/calculators/password-calculator) — it produces random passwords and shows the entropy of what it makes, where this tool measures the strength of a specification you describe.

Related guides

Learn more about this calculation

Guide

Password Entropy Guide: Length, Character Pools, and the Limits of Complexity Rules

Understand how password entropy is estimated from length and character-pool size, how the current DTC password generator behaves, and why secure password policy depends more on length and uniqueness than on arbitrary complexity rituals.

Guide

How to Use Do The Calculation Calculators: A Practical Step-by-Step Guide

Learn the fastest reliable workflow for using Do The Calculation calculators, reading results, checking formulas, and using save, print, share, and export actions correctly.

Utility Tool

Password Generator

Generate a random password to the length and character pool you just scored here.

Tech Tool

Base64 Encoder / Decoder

Encode and decode Base64 strings when working with tokens, keys, and credentials.

Tech Tool

Binary, Hex & ASCII Converter

Convert between bases when inspecting raw key material and encoded secrets.

tech calculator

Password Entropy & Strength Calculator

Measure password or passphrase strength in bits of entropy and see the average time to crack it.

Formula Verified by Dr. James Callahan, PhD

Quick actions: Save inputs, view saved runs, print, share, or export results

Saved Runs

Inputs

What are you measuring?

Password Lengthchars

Character Classes Used

Lowercase a–z (26)Uppercase A–Z (26)Digits 0–9 (10)Symbols (32)

Attacker Capability

Guesses per Second (edit for a specific threat model)

Results

Entropy

78.66 bits

Strength BandReasonable

Character Pool Size94

Bits per Character6.5546

Total Combinations4.759e+23

Average Time to Crack7.5 thousand years

Tip

Useful whenever you set a password policy, evaluate a passphrase scheme, or need to justify a length requirement with a number rather than an opinion.

Summary

Key output metrics

Entropy

78.7 bits

Reasonable

Average Time to Crack

7.5 thousand years

at 1e+12 guesses/second

Bits per Character

6.55

pool of 94

D3 visualization

Entropy Against the Standard Thresholds

Your password measured against the commonly cited 60-bit, 80-bit, and 100-bit bars for online accounts, strong passwords, and long-term key material.

Guide

How to understand and use this calculator

Quick Answer — How Is Password Entropy Calculated?

Password entropy is the base-2 logarithm of how many equally likely passwords could have been generated: H = L × log_2(R), where L is the length and R is the size of the character pool. With all four classes enabled the pool is 26 + 26 + 10 + 32 = 94 characters, worth 6.55 bits per character. A word-based passphrase uses the same formula with words in place of characters: the standard 7,776-word diceware list is worth 12.92 bits per word.

Each extra bit doubles the attacker's work. That is why length beats complexity — adding one character to a 94-character-pool password adds 6.55 bits, while switching a lowercase-only password to mixed case adds just 1 bit per character.

Entropy for common specifications, with average crack time against a fast offline attack at 10¹² guesses/second:

8 characters, lowercase only — 37.60 bits, *Very weak*, cracked in under 1 second
8 characters, all 94 — 52.44 bits, *Weak*, 50.8 minutes
10 characters, all 94 — 65.55 bits, *Reasonable*, 311.7 days
12 characters, all 94 — 78.66 bits, *Reasonable*, 7.5 thousand years
16 characters, letters + digits — 95.27 bits, *Strong*, 755.3 million years
16 characters, all 94 — 104.87 bits, *Excellent*, 588.7 billion years
6-word diceware passphrase — 77.55 bits, *Reasonable*, 3.5 thousand years

Note the 16-character letters-and-digits row: at 95.27 bits it beats a 12-character password that uses every symbol on the keyboard (78.66 bits) by a wide margin. Four extra characters are worth more than the entire symbol class.

How to Use This Calculator: A 12-Character Random Password

Set the mode to random characters, enter a length of 12, and leave all four character classes enabled. The pool is 26 lowercase + 26 uppercase + 10 digits + 32 symbols = 94, so each character carries log₂(94) = 6.5546 bits.

Entropy = 12 × 6.5546 = 78.66 bits. That corresponds to 94¹² ≈ 4.759 × 10²³ possible passwords. An attacker searching randomly expects to find it after about half of them, 2⁷⁷·⁶⁶ ≈ 2.38 × 10²³ guesses, so at 10¹² guesses per second the average time to crack is 7.5 thousand years — and at a throttled online login rate of 1,000 guesses per second, 7.54 × 10¹² years.

The strength band comes back as *Reasonable* rather than *Strong*, which surprises people. 78.66 bits sits just under the widely cited 80-bit bar. One more character takes it to 85.2 bits and clears it — a concrete illustration of why password policies should specify length rather than character classes.

A Second Example: A Six-Word Passphrase

Switch the mode to passphrase, enter 6 words, and leave the wordlist at 7,776 — the size of the standard diceware list, which is 6⁵ so that five dice rolls select each word. Each word is worth log₂(7,776) = 12.9248 bits.

Entropy = 6 × 12.9248 = 77.55 bits, or about 2.211 × 10²³ possible phrases, cracked on average in 3.5 thousand years at 10¹² guesses/second.

That is within 1.2 bits of the 12-character random string above — a phrase a person can actually memorise, matching a string they cannot. The trade-off is length in characters rather than in security: six diceware words run to roughly 30 typed characters. Drop to four words and entropy falls to 51.70 bits, cracked in 30.5 minutes against the same attacker; go to seven and it rises to 90.47 bits, or 27.2 million years. Five or fewer words is not enough for anything that matters.

Why Entropy Assumes Randomness — and What Happens When It Isn't

Every number on this page assumes the password was generated uniformly at random from the pool you described. That assumption is doing enormous work. If you chose the characters yourself, the real entropy is far below the calculated figure, because human choices are predictable in ways an attacker's wordlist already encodes: dictionary words with a capital at the front, a digit and an exclamation mark at the end, keyboard patterns, dates, and substitutions like 3 for e.

This is exactly why composition rules backfire. A policy demanding one uppercase, one digit, and one symbol nudges almost everyone toward the same shape — `Password1!` scores 65.55 bits on this calculator and would fall to a targeted wordlist in seconds. The calculator cannot tell the difference, because entropy describes the generation process, not the string. Use a generator, or physical dice for a passphrase, and the number means what it says.

The other half of the threat model is where the password is stored. The same 78.66-bit password survives 7.5 thousand years against a fast offline attack on unsalted hashes and 7.54 × 10¹² years against a throttled login endpoint — nine orders of magnitude apart, from an identical password. Set the guesses-per-second field to match the attack you are actually defending against, and remember that the fast figure keeps getting faster while the entropy does not change.

For the full derivation, the history of NIST's shift away from complexity rules, and why uniqueness across sites matters at least as much as strength, see the password entropy guide.

Limitations

This calculator scores a specification, not a specific string. It has no way to know whether your password is `xK9$mQ2pLw4z` or `Password123!` — both are 12 characters drawn from the full pool, both compute to 78.66 bits, and only one of them is actually strong. Entropy is an upper bound that holds only for genuinely random generation.

It also does not model the attacks that account for most real compromises. Credential stuffing reuses a password leaked from another site regardless of how strong it is; phishing captures it directly; keyloggers and malware bypass the maths entirely; and a password stored in a breached database with a weak hash is at risk however many bits it carries. A unique password per site, stored in a password manager and backed by multi-factor authentication, defends against all of those in ways extra entropy cannot.

The symbol class is counted as 32 characters, the convention that produces the familiar 94-character printable-ASCII pool. Systems that reject certain symbols shrink that pool and reduce your real entropy below the figure shown, so if a site bans particular characters, uncheck the class or shorten the pool accordingly. Crack times are also averages over a random search: an unlucky password can fall much sooner, and attackers do not search randomly when they have any reason to guess otherwise.

Related Calculators

This calculator measures the strength of a password you already have or are specifying. To create one, the Password Generator produces random passwords to a chosen length and character pool — generate there, score here. The Password Entropy Guide covers the underlying maths, the NIST length-over-complexity guidance, and why composition rules make passwords weaker in practice. For working with encoded secrets and key material, the Base64 Encoder/Decoder and the Binary, Hex ASCII Converter handle the conversions.

Related concepts

Bits of Entropy

The base-2 logarithm of how many equally likely passwords could have been generated. Each additional bit doubles the work required to guess it.

Character Pool

The set of characters a password could have been drawn from — 26 lowercase, 26 uppercase, 10 digits, and 32 symbols, giving the standard 94-character printable-ASCII total.

Diceware Passphrase

A phrase built from words chosen at random from a 7,776-word list, each worth 12.92 bits. Six words match a 12-character random password and are far easier to remember.

Frequently Asked Questions

How do I calculate password entropy?+

Multiply the password length by the base-2 logarithm of the character pool size: entropy = length × log₂(pool). With lowercase, uppercase, digits, and symbols enabled the pool is 94 characters, worth 6.55 bits each, so a 12-character password carries 78.66 bits.

How many bits of entropy is a strong password?+

Sixty bits is a reasonable floor for an ordinary online account, 80 bits is genuinely strong, and 100 or more suits master passwords and long-term key material. A 12-character password from the full 94-character pool reaches 78.66 bits — just under the strong threshold, which one more character clears.

Is a passphrase as strong as a random password?+

It can be. A six-word diceware passphrase carries 77.55 bits, within 1.2 bits of a 12-character random string from the full character pool, and it is far easier to remember. The cost is typing length — six diceware words run to about 30 characters. Four words (51.70 bits) is not enough; six or seven is.

Does adding symbols help more than adding length?+

No, and it is not close. Adding one character to a full-pool password adds 6.55 bits; adding the entire symbol class to a letters-and-digits password adds only about 0.6 bits per character. A 16-character letters-and-digits password scores 95.27 bits against 78.66 for a 12-character password using every symbol available.

What does 'average time to crack' actually mean?+

It is 2^(entropy − 1) divided by the attacker's guess rate: an attacker searching a space of uniformly random secrets expects to find the target about halfway through. It is an average, not a guarantee — an unlucky password can fall much sooner, and the rate assumption keeps getting faster over time while the entropy does not change.

Why does the same password show wildly different crack times?+

Because the attacker's capability changes the answer by orders of magnitude. A 78.66-bit password survives about 7.5 thousand years against a fast offline attack at 10¹² guesses/second and about 7.5 trillion years against a throttled login endpoint at 1,000 guesses/second. Set the rate to match where the password is actually stored.

How is this different from the password generator?+

The password generator creates a random password to your chosen specification. This calculator measures the strength of a specification — a length and character pool, or a word count and wordlist size — that you describe. Use the generator to make a password, and this tool to check whether a policy or an existing scheme is strong enough.

Does high entropy mean my account is safe?+

No. Entropy defends against guessing and nothing else. Credential stuffing, phishing, keyloggers, and database breaches all bypass it entirely. A unique password per site, kept in a password manager and protected by multi-factor authentication, matters at least as much as the bit count.

Formula

Password entropy formula

Character password:  Entropy (bits) = Length × log₂(Pool Size)
Passphrase:          Entropy (bits) = Words × log₂(Wordlist Size)
Pool Size = 26 (lowercase) + 26 (uppercase) + 10 (digits) + 32 (symbols)
Combinations = Pool Size ^ Length
Average Time to Crack = 2^(Entropy − 1) ÷ Guesses per Second

Step by step

How the calculation works

1Choose whether you are measuring a random character string or a random-word passphrase. They are scored differently: a character password gets log₂(pool) bits per character, a passphrase gets log₂(wordlist) bits per word — about 12.9 bits per word from the standard 7,776-word diceware list.
2For a character password, switch on only the character classes actually used. The pool is the sum of the classes: 26 lowercase, 26 uppercase, 10 digits, and 32 symbols, for the familiar 94-character printable-ASCII total when all four are on.
3The guesses-per-second figure sets the attacker you are defending against, and it changes the answer by many orders of magnitude. A throttled online login endpoint might manage a thousand attempts per second; an offline attack on a stolen database of fast unsalted hashes can reach a trillion. Pick the threat that matches where the password is actually stored.
4Read the bits, not the crack time. Entropy is a stable property of how the password was generated; the crack time is that number divided by an attacker assumption that will keep getting faster. Sixty bits is a reasonable floor for an ordinary online account, eighty bits is strong, and a hundred or more suits long-term key material.
5This calculator scores a password you already have or are planning. To generate one instead, use the [password calculator](/calculators/password-calculator) — it produces random passwords and shows the entropy of what it makes, where this tool measures the strength of a specification you describe.

Related guides

Learn more about this calculation

Guide