Free Password Entropy & Strength Calculator

1. The Mathematics of Information Entropy (Claude Shannon)

In 1948, mathematician Claude Shannon published A Mathematical Theory of Communication, defining the mathematical measure of information entropy. Applied to cybersecurity, Password Entropy quantifies the exact number of bits of computational uncertainty an attacker faces when attempting to guess a secret credential.

The mathematical formula is expressed as:

Where L represents the total character length of the secret, and R represents the size of the character pool from which each character is independently selected (e.g. 26 for lowercase, 52 for mixed case, 62 for alphanumeric, 94 for printable ASCII).

Two things follow from the shape of that formula, and both matter more than the number it produces. First, entropy is linear in length and only logarithmic in pool size: doubling the length doubles the bits, while doubling the pool adds exactly one bit per character. Second, the word independently is doing real work. The formula measures the size of the space a secret was drawn from at random. It says nothing at all about a secret that was chosen — a point Section 4 returns to, because it is where most password-strength advice goes wrong.

The pool is not something you pick; it is read off the string. Every class that appears anywhere in the password contributes its whole size, because an attacker who knows a digit is in play has to search all ten at every position, not just the one you used:

Read down the last two columns rather than across the rows. Every step of added complexity — from lowercase all the way to full punctuation — buys a 16-character password about 30 bits. Going from 16 characters to 21 at the same lowercase pool buys 23. Complexity rules run out of room; length does not.

2. Why the ASCII Pool Is 94, Not 95 or 33

The 94-character figure is worth deriving, because a surprising number of entropy calculators get it wrong by one and quietly overstate every password they are shown. Printable ASCII occupies code points 0x20 to 0x7E, which is 95 characters including the space. Passwords conventionally exclude the space — many systems trim it, and some reject it outright — leaving 94.

Of those 94, letters and digits account for 62. The remaining 32 punctuation marks are not contiguous; they sit in four separate gaps between the alphanumeric ranges:

Fifteen plus seven plus six plus four is 32, and 26 + 26 + 10 + 32 is 94. Tools that use 33 are usually carrying the space in the punctuation count while still calling the maximum 94 — an internal contradiction. The size of the error is small: log2(95) − log2(94) is about 0.015 bits per character, so a fifth of a bit on a 14-character password. What is not small is that the number on screen and the explanation beside it cannot both be right, and you have no way to tell which one the tool believes.

This calculator counts 32, and it treats anything outside printable ASCII as a floor rather than a measurement. A space, an accented letter or an emoji adds one to the pool per distinct character seen. The true alphabet behind an emoji is thousands of code points wide, so the real entropy is higher — but an attacker targeting you specifically may know you use one, and a floor is the honest thing to report when the alphabet is unknowable.

3. How Many Bits Do You Actually Need?

Bits are hard to feel. The table below turns them into time, using the same engine that powers this page and the IncogSay password generator — every figure is computed, not estimated by hand. The rate is 100 billion guesses a second against a fast unsalted hash, and the time is to exhaust half the keyspace, which is where an exhaustive search finds the answer on average.

The jump from 12 characters to 14 is the one to look at: 75 thousand years to 666 million, from two extra keystrokes. That is what "linear in length" means once the number is exponentiated back into time.

The verdict column uses six bands, and they are the same bands the password generator reports, so the two tools can never disagree about the same string:

"Reasonable" is the band to be suspicious of. It runs from 36 to 59 bits, which at a fast hash is anything from under a second to two months — an enormous spread for one label. It is named for the online case, where an attacker has to come through a login form that rate-limits and locks out, and where 40-odd bits genuinely is enough. It is not a pass mark for anything whose hash could end up in a dump. For an account you would mind losing, aim for Strong at minimum and Very strong for the account that can reset all the others — your email, and the master password on your password manager.

Past 128 bits the label stops being a compliment. There is no attack the extra bits defend against, because the ones below them already exceed the energy budget of the observable universe; the cost is all borne by you, in a string you have to type. 128 bits is where a password stops being a password and becomes a key, and keys belong in files and hardware tokens rather than in muscle memory.

4. What This Number Does Not Measure

E = L × log2(R) answers one question exactly: how large is the space this secret was drawn from, if it was drawn uniformly at random. For a password that came out of a generator, that condition holds and the number is the truth. For a password you invented, the condition fails, and the number becomes an upper bound — usually a very generous one.

Here are three 11-character passwords. The formula cannot tell them apart:

Only the third figure is honest, and the only reason it is honest is that nobody chose those characters. This is the single most important thing to understand about any password strength meter, including this one: the score is a property of how the password was made, not of how it looks.

The reason is that real cracking is not a brute-force sweep through the keyspace. It is an ordered guess list, and the order is built from how people behave:

• Wordlists first. Leaked password corpora, sorted by frequency. The most common few million passwords are tried before any brute force begins, and they cost effectively nothing.
• Then rules. Hashcat's stock rule sets append years, capitalise first letters, double words, add trailing punctuation and apply every common letter-to-symbol substitution. A ruleset multiplies a wordlist by a few thousand and still finishes in seconds.
• Then masks. If the shape is predictable — one uppercase, six lowercase, two digits, one symbol — an attacker searches only that shape. A mask can cut a nominal 52-bit search to a real 30-bit one.
• Brute force last, and only over lengths short enough to finish.

Every one of those stages exploits structure, and the entropy formula is blind to all of it. A meter that scores P@ssw0rd123 highly for containing four character classes is measuring compliance with a composition rule, not resistance to an attack.

There is a second, wider blind spot. Entropy measures resistance to guessing, and guessing is only one of the ways passwords are lost. None of the following move the number on this page by a single bit:

• Reuse. Once a password appears in one breach it is replayed verbatim against every other account you hold. Credential stuffing needs one guess, whatever the password is worth.
• Phishing. A 200-bit password typed into a convincing fake login page is worth zero bits. Checking where a link actually goes is a different tool: our safe link checker and redirect checker exist for exactly that.
• Keyloggers and clipboard scrapers. Strength is irrelevant to a device that is already compromised.
• Breach exposure. A password already in a public corpus is one guess away regardless of length, which is why NIST asks services to screen against breach lists rather than to demand symbols.
• Server-side storage. You do not control whether a site salts and stretches your password or stores it in plain text, and the difference between those two is larger than anything you can do to the password itself.

The practical reading of all this is short. Generate your passwords rather than inventing them, so the number is true; make them unique per site, so a breach stays local; keep them somewhere that does not require you to remember them, so length costs you nothing; and treat any figure above 80 bits as the point where the password has stopped being the weakest link in your account.

5. GPU Cluster Compute Benchmarks & Hashcat Physics

Modern password auditing does not occur via slow web forms. Attackers capture password hashes from breached corporate databases and run offline brute-force attacks across dedicated GPU server rigs:

That is the same password, the same attacker and the same hardware. The only thing that changed is a decision made by the site you signed up to, and it is worth roughly 22 bits — more than you can buy by adding punctuation to a 12-character password twice over. You have no visibility into which choice was made and no way to influence it, which is the whole reason the crack times on this page assume the fast case.

Rates for slow hashes depend entirely on the parameters chosen, so read the orders of magnitude rather than the digits. The pattern is what matters: a well-chosen hash is worth about as much as adding four characters to every password on the site at once, which is why the choice belongs to the engineer and the length belongs to you.

6. Passphrases: Counting in the Right Model

The best-known password advice in computing is xkcd 936, which put four common words together as correct horse battery staple and labelled it 44 bits of entropy. That number is worth pausing on, because it is not what the character formula gives. Twenty-eight lowercase letters over a 26-character pool is about 132 bits. The comic said 44, and the comic was right.

Forty-four bits is 4 × log2(2048) — four independent draws from a two-thousand-word list. The difference between 44 and 132 is the difference between two threat models, and only one of them describes a real attacker. Kerckhoffs's principle says to assume your opponent knows the method: they know you used a passphrase, they know the kind of list it came from, and so they guess whole words rather than letters. Under that assumption the search space is the list raised to the number of words, and the letters inside each word are not free choices at all.

So the honest formula for a passphrase is E = W × log2(N), for W words drawn from a list of N. Everything follows from that:

The uncomfortable line is the second one. The most-cited passphrase recommendation in the field is 44 bits, and 44 bits is a minute and a half against a fast hash. The comic's arithmetic has not aged; the hardware has. Four words was a fair recommendation in 2011 and is a floor to build up from now — six words is the modern equivalent of what four words used to buy.

Two levers control that figure, and they are not equally worth pulling. Adding a seventh word to a six-word passphrase from a 2,048-word list buys 11 bits. Quadrupling the list to 8,192 words buys 12 — nominally more, but it costs several thousand new entries, and every entry added to a curated list is a longer, rarer, harder-to-type word than the ones already in it. Word count is the lever you control; list size is the author's problem.

What is definitely not a lever is decoration. The habits people add to passphrases to satisfy composition rules are worth very little, and some are worth nothing at all:

• Appending a digit:log2(10), or 3.3 bits — if the digit is actually random. If it is the year, it is under 3 bits and an attacker's rule set tries it first.
• Capitalising every word: zero bits. It is deterministic, so it adds one candidate transformation to the attacker's rule list and nothing to the search space.
• Capitalising a random word:log2(6), or 2.6 bits for a six-word phrase — real, but less than half of one extra word.
• Substituting @ for a throughout: zero bits, and it makes the phrase harder to type. Every stock rule set contains this substitution.
• Choosing an unusual separator: a couple of bits at most, and only if the choice was random rather than your habit across every passphrase you own.

This is why the IncogSay generator reports what it reports. Its word list holds exactly 256 entries, so each word is exactly 8 bits and the arithmetic is checkable by hand; the optional appended digit is counted as log2(10) and nothing more; and the capitalisation toggle adds no bits to the figure, because it is applied to every word and therefore adds nothing. A generator that inflated its own number for the sake of a nicer-looking meter would be lying about the only thing it exists to tell you.

7. NIST SP 800-63B, in Specifics

"NIST compliant" appears on a great many password meters without much explanation. The document in question is NIST Special Publication 800-63B, Digital Identity Guidelines: Authentication and Lifecycle Management, and the section that matters is the one on memorized secrets. Its third revision, published in 2017, is what overturned two decades of received wisdom about symbols and 90-day expiry; the fourth revision strengthened several of those recommendations from SHOULD into SHALL and raised the recommended minimum length. Revisions move, so check the current text before quoting it in a policy document.

Most of the guidance is addressed to the people building the login form rather than to the person choosing the password, which is worth knowing: several of its most-quoted lines are instructions to stop doing something to users.

Read as a whole, the guidance makes one argument twice: put the burden on the verifier, not on the user's memory. Screening against breach lists, throttling attempts and hashing properly are all things a service does, and each is worth more than any rule it could impose on the shape of your password.

That is also the reason this page scores what it scores. It measures length and pool — the things NIST says determine strength — and it does not award marks for containing a symbol, because the guidance explicitly asks verifiers to stop demanding one. A password of 20 lowercase letters reports 94 bits here and would be rejected by a great many corporate password policies that happily accept Summer2026! at a real strength of minutes.