# Password Entropy & Strength Calculator Measure password or passphrase strength in bits of entropy and see the average time to crack it. --- - **Canonical URL:** https://dothecalculation.com/calculators/password-entropy-calculator - **Category:** AI & Tech Development - **Publisher:** Do The Calculation (https://dothecalculation.com) - **Cost:** Free, no account or sign-up required - **Privacy:** Runs entirely in the browser; inputs are never sent to a server - **Methodology:** https://dothecalculation.com/methodology --- ## Measure Password Strength in Bits of Entropy Score a password or passphrase by the size of the space it was drawn from — then see how long that actually survives against a specific attacker. - Entropy in bits for character passwords and word-based passphrases - Crack time against a throttled login, a slow hash, or a fast offline attack - Measures strength — the password generator creates passwords instead ## 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 \times \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](/blog/utility/password-entropy-estimation). ## 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](/calculators/password-calculator) produces random passwords to a chosen length and character pool — generate there, score here. The [Password Entropy Guide](/blog/utility/password-entropy-estimation) 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](/calculators/base64-codec-calculator) and the [Binary, Hex & ASCII Converter](/calculators/binary-hex-ascii-calculator) handle the conversions. ## 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. ## 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. ## Related guides - [Password Entropy Guide: Length, Character Pools, and the Limits of Complexity Rules](https://dothecalculation.com/blog/utility/password-entropy-estimation) — 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. - [How to Use Do The Calculation Calculators: A Practical Step-by-Step Guide](https://dothecalculation.com/blog/site-guides/how-to-use-calculators) — Learn the fastest reliable workflow for using Do The Calculation calculators, reading results, checking formulas, and using save, print, share, and export actions correctly. ## Related calculators - [Internet Download/Upload Time Calculator](https://dothecalculation.com/calculators/internet-download-time-calculator) — Calculate download or upload time from file size and connection speed, with the bits-vs-bytes conversion made explicit. - [Compression Ratio Calculator](https://dothecalculation.com/calculators/compression-ratio-calculator) — Convert between compression ratio and space saved, and price the storage and transfer time it buys. - [Docker Image Layer Size Optimizer](https://dothecalculation.com/calculators/docker-image-optimizer-calculator) — Model Docker container layer sizing, registry storage needs, and deployment transfer time overhead for image optimization planning. - [LLM API Cost Calculator](https://dothecalculation.com/calculators/llm-api-cost-calculator) — Project monthly and annual LLM API spend from request volume, average token counts, per-token pricing, and prompt caching discounts. - [Software TCO Calculator](https://dothecalculation.com/calculators/software-tco-calculator) — Total cost of owning software over 3-5 years: licences, renewal uplift, setup, support, and admin time. - [Typing Speed (WPM) Calculator](https://dothecalculation.com/calculators/typing-speed-calculator) — Calculate gross and net words-per-minute and accuracy from characters typed, time, and uncorrected errors. --- _Entropy describes how a password was generated, not the string itself: every figure here assumes uniform random generation from the pool you described. A human-chosen password of the same length and character mix carries far less real entropy than the number shown. Crack times are averages against the guess rate you select and will only shrink as hardware improves — and no amount of entropy defends against phishing, credential stuffing, or a database breach, which is why unique passwords and multi-factor authentication matter alongside strength._ --- _Source: [Do The Calculation](https://dothecalculation.com/calculators/password-entropy-calculator). Quote freely with attribution and a link to this page._