Password Entropy Calculator

A password’s strength is genuinely measurable in numbers, and the measure is entropy: how many bits of uncertainty stand between an attacker and the right guess. This calculator computes it from the two things that determine it — length and the size of the character set drawn from — then translates the bits into strength bands and honest crack times at modern guessing speeds.

Length Times the Log of the Alphabet

The formula is one line — entropy = length × log₂(character set size) — because each character of a password, drawn independently and uniformly from a set of size N, multiplies the search space by N, and bits are logarithms of search spaces. The consequences are the two laws of password strength. Length is linear power: every added character contributes the set's full log₂ — about 6.55 bits per character from the full keyboard set, 5.95 from letters-and-digits, 4.70 from lowercase alone. Set size is logarithmic power: widening the alphabet helps far less than lengthening the string — going from lowercase (26) to everything (94) adds only 1.85 bits per character, less than a third of one extra full-set character. Every piece of sane password advice (long over clever, passphrases over symbol salads) is these two sentences wearing a coat.

Worked Example: Twelve Characters, Full Keyboard

The defaults: 12 characters drawn from all 94 printable keyboard characters. Entropy = 12 × log₂(94) = 12 × 6.555 ≈ 78.7 bits; the search space is 94¹² ≈ 4.76 × 10²³ passwords; an attacker expects to search half of it. At a throttled online rate (10,000 guesses a second, what a sane login endpoint permits) the average crack time is effectively geological; against a fast offline hash (10 billion a second — a serious GPU rig against a leaked, weakly-hashed database) it is about 754,000 years on average. The same length in lowercase only: 12 × 4.70 = 56.4 bits — still respectable, and the difference between the two is entirely the per-character alphabet, priced exactly by the formula.

Crack Time: The Two Attackers

Entropy is intrinsic; crack time depends on who is guessing, and the calculator quotes the two canonical attackers because confusing them produces nonsense in both directions. The online attacker knocks on the live service's door — rate limits, lockouts and monitoring cap them near thousands of guesses a second at most (and usually far fewer); against them, even 40-bit passwords hold comfortably. The offline attacker has stolen the hash database and guesses at hardware speed — 10¹⁰ per second is a fair modern figure for a fast hash on a good rig, with weak legacy hashing faster still and memory-hard schemes (bcrypt, argon2) orders of magnitude slower. When a breach headline says "passwords were hashed", the question that decides your safety is which of these two clocks your password was on — the calculator's spread between them, often a factor of a million, is the honest representation.

The Assumption That Does All the Work

Every figure on this page presumes the password was chosen uniformly at random from its set — and human choices are nothing of the kind. "Password1!" is formally 10 characters over the full set (≈65 bits by the formula) and practically among the first thousand guesses any attacker tries, because humans draw from a sliver of the space: dictionary words, names, keyboard walks, a capital at the front and punctuation at the back, the ritual substitutions (0 for o, 3 for e) that cracking dictionaries encode by the million. True entropy must be measured against the attacker's actual guessing order — which is why the professional instruments are password managers (which really do draw uniformly) and randomly generated passphrases (a 5-word diceware phrase carries about 64.6 bits of genuine entropy: 5 × log₂(7,776)). Use this calculator on generated passwords and it tells the truth; use it on human-invented ones and it tells an upper bound, flattering by an amount nobody can compute — least of all the human.

What the Bits Buy, Across Eras

Entropy's purchasing power inflates away as hardware quickens, which is why old passwords die in modern breaches. The worked example's 78.7 bits faces the offline attacker of 10¹⁰ guesses a second for ~754,000 years on average — but wind the clock to a 1990s workstation at a million guesses a second and the same password's average stands at roughly 7.5 billion years: it was never going to be brute-forced in either era, while its 40-bit contemporary (a fortune then) falls to today's rig in well under a day. The durable strategy is not to predict hardware but to buy margin: entropy is the cheapest security there is, priced at one character per 6.55 bits, and the calculator exists so the margin can be chosen as a number rather than a feeling.

The Hash Is Half the Story

One refinement completes the offline picture: the 10-billion-per-second attacker presumes a fast hash (MD5, SHA-1, a raw NTLM). Against a properly deployed memory-hard KDF — argon2id or bcrypt tuned to a few hundred milliseconds per verification — the same rig manages perhaps ten thousand guesses a second, and the worked example's average crack stretches from 754,000 years to roughly 750 billion. Same password, same entropy, three orders of magnitude of fate decided by the defender's storage choice. Entropy is the half of password security the user controls; the hash is the service's half — and breach post-mortems are the ledger of which half failed.

Uniqueness: The Multiplier Nobody Computes

One law outranks the bits in practice: a password used on one service only. Credential stuffing — replaying breached username-password pairs against other services — defeats entropy entirely, because the attacker is not guessing the space this page measures but reading it from a list. The strongest 100-bit password, reused, is worth its weakest custodian's security; a modest generated 65-bit password, unique per account inside a manager, is worth its full computation. Entropy prices the guessing attack honestly and completely — and the reuse attack is the reminder that guessing was never the only door.

Related Tools

More from the Other Calculators hub: the ASCII Converter Calculator — the character sets, enumerated — and the DPMO Calculator for probability at industrial scale.

Frequently Asked Questions

How many bits of entropy does a password need?

Against online guessing, roughly 40 bits is comfortable behind any sane rate limiting; against offline cracking of a leaked hash, 60 bits is a working minimum, 70–80 bits is strong, and beyond about 100 bits the brute-force question closes and the risks become reuse, phishing and the service's own storage. The calculator's bands encode exactly this ladder; note how length buys the rungs cheaply — at full-set characters, 80 bits is a 13-character password.

Is a passphrase stronger than a complex password?

Per character typed, usually yes — because passphrase words drawn from a large list carry about 12.9 bits each (log₂ of the standard 7,776-word diceware list) while remaining memorable, so five words reach ~65 bits at a length humans will actually use correctly. A random 10-character full-set password carries the same ~65 bits in fewer characters but at far higher memory and typing cost. Entropy per unit of human suffering is the real metric, and passphrases win it — provided the words are drawn randomly, not chosen as a quotation.

Does adding symbols really help?

A little, once: moving from letters-and-digits (62, 5.95 bits/character) to the full set (94, 6.55 bits/character) adds 0.6 bits per character — worth about one extra character across a whole 12-character password. The composition rituals (must contain a symbol, must contain a digit) mainly push humans toward predictable placements, which attackers model; modern guidance (NIST SP 800-63B) has accordingly shifted to length and breach-screening over composition rules. The calculator prices the set honestly so the trade can be seen, not preached.

Why is my "complex" password rated weak elsewhere?

Because strength meters that model human behaviour (zxcvbn and its kin) price the guessing order, not the raw space: patterns, words, dates and substitutions collapse the effective entropy far below the formula's figure. This calculator computes the combinatorial ceiling — the right number for generated passwords and for comparing policies — while behavioural meters estimate the floor for invented ones. The truth for a human password lives between, nearer the floor, which is the practical argument for letting a manager generate it.

How does two-factor authentication change the maths?

It retires the question: with a second factor, the password's entropy no longer stands alone between the attacker and the account — a cracked password buys nothing without the phone or key. Entropy still matters (weak passwords fall to credential stuffing against services where the second factor is absent or recoverable), but the marginal value of bits beyond a solid 60 collapses when a real second factor stands behind them. Spend effort there before chasing 120-bit passwords.

What about PINs?

A 4-digit PIN is log₂(10⁴) ≈ 13.3 bits — nothing, as a space — yet PINs secure the world's bank cards, because their attackers are throttled to three guesses before the card is eaten. The PIN is the purest illustration of this page's two-attacker doctrine: entropy requirements are set by the guessing environment, not by the secret's dignity, and the digits-only option in the calculator exists to let that arithmetic be run honestly.