# Ethereum Vanity Address Difficulty: Attempts, Odds and Time

Source: https://www.ethvanity.com/blog/ethereum-vanity-address-difficulty

Published: 2026-11-02

Updated: 2026-11-12

![Independent search attempts. Probability p: Chance that one candidate meets the pattern; Expected work: 1 / p attempts, not a completion deadline; Success after N: 1 - (1 - p)^N for independent attempts.](https://www.ethvanity.com/images/blog/ethereum-vanity-address-difficulty-diagram-v2.webp)

Independent search attempts. Probability p: Chance that one candidate meets the pattern; Expected work: 1 / p attempts, not a completion deadline; Success after N: 1 - (1 - p)^N for independent attempts.

[Full-size diagram (SVG)](https://www.ethvanity.com/images/blog/ethereum-vanity-address-difficulty-diagram-v2.svg)

[Diagram download (PNG)](https://www.ethvanity.com/images/blog/ethereum-vanity-address-difficulty-diagram-v2.png)

An n-character case-insensitive hex prefix needs 16^n attempts on average, because each position has a 1 in 16 chance of matching. A 6-character prefix averages 16,777,216 attempts and an 8-character one 4,294,967,296. Requiring exact EIP-55 capitalization doubles the work for every letter, and the time is simply attempts divided by your generator's rate.

## The basic formula: 16^n

An Ethereum address is the tail of a Keccak-256 hash, so each of its 40 hex characters behaves like an independent uniform draw from 16 symbols. The probability that a single candidate matches a specific n-character pattern at a fixed position is p = 1/16^n. The number of candidates you need on average is the reciprocal, 16^n, which equals 2^(4n).

This applies to any fixed position: a prefix, a suffix or a pattern at a chosen offset. The characters themselves do not matter for case-insensitive matching, so 0xdead and 0x0000 have identical difficulty. What matters is how many characters are fixed.

Each extra character multiplies the work by 16, which is 4 more bits. That exponential growth means patterns jump quickly from trivial to impractical: going from 6 to 8 characters is 256 times harder, and from 8 to 12 characters is 65,536 times harder. Hardware improvements that double speed only buy a quarter of one extra character.


## Expected attempts for prefixes of 1 to 10 characters

The table lists expected attempts for case-insensitive prefixes, plus the number of attempts that gives a 50% chance of success, which is 16^n x ln 2, or about 0.693 times the expected value. Expected attempts is a mean; the 50% point shows that luck has a large spread.


| Prefix length | Expected attempts (16^n) | Attempts for 50% chance |
| --- | --- | --- |
| 1 | 16 | 11 |
| 2 | 256 | 177 |
| 3 | 4,096 | 2,839 |
| 4 | 65,536 | 45,426 |
| 5 | 1,048,576 | 726,817 |
| 6 | 16,777,216 | 11,629,080 |
| 7 | 268,435,456 | 186,065,279 |
| 8 | 4,294,967,296 | 2,977,044,472 |
| 9 | 68,719,476,736 | 47,632,711,549 |
| 10 | 1,099,511,627,776 | 762,123,384,786 |


## Probability of success after k attempts

The chance of at least one match after k attempts is P(k) = 1 - (1 - p)^k, which for small p is very close to 1 - e^(-k/16^n). Rearranging gives the attempts needed for a target probability: k = ln(1/(1 - P)) x 16^n. For 50% the multiplier is 0.693, for 90% it is 2.303, and for 99% it is 4.605.

So if your pattern's expected value is 4.29 billion attempts, you have a 63.2% chance of finding it within 4.29 billion attempts, and you need about 19.8 billion attempts to be 99% sure. Planning around the expected value alone underestimates the worst case by a factor of more than four.

Two quick rules of thumb follow from the formula. After exactly the expected number of attempts, the success probability is 1 - 1/e, about 63%. After half the expected number, it is about 39%, and after twice the expected number, about 86%. These ratios hold for every pattern length, so you can apply them to any row of the table above.


```sh
p      = 1 / 16**n                # one candidate matches
P(k)   = 1 - (1 - p)**k           # at least one match in k tries
k(P)   = ln(1 / (1 - P)) * 16**n  # tries for target probability P

# n = 8: 16**8 = 4,294,967,296
# k(0.50) = 0.693 * 16**8 = 2.98e9
# k(0.99) = 4.605 * 16**8 = 1.98e10
```


## Case-sensitive patterns, suffixes and combinations

EIP-55 capitalizes a letter when the matching nibble of keccak256(lowercase address) is 8 or higher, an event with probability 1/2. Requiring exact case therefore multiplies difficulty by 2 for each letter a-f in the pattern, and by 1 for each digit. The algorithm itself is explained in [hex characters and EIP-55](https://www.ethvanity.com/blog/ethereum-vanity-address-hex-checksum).

A prefix and a suffix are independent, so their difficulties multiply: a 4-character prefix plus a 4-character suffix is 16^4 x 16^4 = 16^8, exactly the same as an 8-character prefix. Accepting a pattern at either end roughly halves the work, since a candidate succeeds if it matches the start or the end, giving p close to 2/16^n.

Patterns in the middle of the address follow the same rule. A fixed n-character string at one specific offset needs 16^n attempts, while accepting it at any of the 41 - n possible offsets multiplies the probability by roughly that count. Searching for cafe anywhere in the address, with 37 possible positions, needs only about 65,536 / 37, or roughly 1,771, attempts on average, which is why such matches look impressive but are cheap.


| Pattern rule | Example | Expected attempts |
| --- | --- | --- |
| Prefix, any case | 0xbeef | 65,536 |
| Prefix, exact case | 0xBEEF | 1,048,576 |
| Prefix and suffix | 0xbeef...cafe | 4,294,967,296 |
| Prefix or suffix | beef at either end | about 32,768 |
| Leading zero bytes | 4 zero bytes (8 hex zeros) | 4,294,967,296 |


## Turning attempts into time

Time is expected attempts divided by the rate in attempts per second. Real rates vary by orders of magnitude between a browser script, a CPU tool and a GPU tool, and between keypair searches and CREATE2 salt searches, which skip elliptic-curve work as described in [EOA vs CREATE2 vanity](https://www.ethvanity.com/blog/ethereum-wallet-vs-create2-vanity). The figures below use two round, purely hypothetical rates so you can scale them to your own measured rate.

At a hypothetical 1 million attempts per second, an 8-character prefix averages 4,295 seconds, about 72 minutes, and a 10-character prefix about 12.7 days. At a hypothetical 1 billion attempts per second, the 10-character prefix averages about 18 minutes and a 12-character prefix about 3.3 days. Each added character multiplies every figure by 16.


| Prefix length | At 1M/s (hypothetical) | At 1B/s (hypothetical) |
| --- | --- | --- |
| 6 | about 17 seconds | under 0.02 seconds |
| 8 | about 72 minutes | about 4.3 seconds |
| 10 | about 12.7 days | about 18 minutes |
| 12 | about 8.9 years | about 3.3 days |


## Worked example: planning an 8-character search

Suppose you measure your tool at a hypothetical 2 million attempts per second and want an 8-character case-insensitive prefix. Expected attempts are 16^8 = 4,294,967,296, so the average time is 4,294,967,296 / 2,000,000 = 2,147 seconds, about 36 minutes. For 90% confidence multiply by 2.303 to get about 82 minutes, and for 99% multiply by 4.605 to get about 165 minutes.

The search is memoryless: having already run 30 minutes without success does not make the next minute more likely to succeed. Each new attempt still has the same 1 in 4.29 billion chance, and the expected remaining time is always the full average. This is why progress bars for vanity searches are misleading unless they display probability rather than percentage complete.

Parallel hardware divides time linearly because attempts are independent. Four machines at the same rate cut the 36-minute average to about 9 minutes, provided each one starts from an independent, securely random point so they do not repeat each other's work. Accepting several patterns also helps: if any of 10 different 8-character words would satisfy you, p becomes 10/16^8 and the expected attempts drop tenfold.


## Practical notes before you start a search

Difficulty also has a security side: it measures how hard your address is to imitate.

- Short patterns are cheap for attackers too; a look-alike matching 4 characters at each end costs 16^8 attempts, the basis of [address poisoning](https://www.ethvanity.com/blog/ethereum-address-poisoning).
- Leading zero bytes are a special pattern with a gas benefit, covered in [leading-zero addresses and gas](https://www.ethvanity.com/blog/ethereum-leading-zero-address-gas).
- Measure your generator's actual rate over a few minutes before trusting any time estimate, and plan for the 90% or 99% point rather than the average.

## Turn difficulty into a fallback decision

A fallback is most useful when it removes a constraint. Under the uniform, case-insensitive model used here, shortening cafe to caf reduces the expected attempt count from 65,536 to 4,096. Shortening it again to ca gives 256. These figures describe the mathematical model, not a service speed or a completion deadline.

Choose the shortest fragment that serves your purpose, then follow the [ETH address generation walkthrough](https://www.ethvanity.com/blog/how-to-generate-ethereum-vanity-address). If a run ends without a match, review its terminal status and budget before submitting another search.


## Explore the related mechanism

- [Ethereum Vanity Address Format: Hex Characters and EIP-55 Checksum](https://www.ethvanity.com/blog/ethereum-vanity-address-hex-checksum) — Which characters an Ethereum vanity address can use, how the EIP-55 checksum works, and why case-sensitive patterns need more attempts.
- [How Ethereum Addresses Are Derived from a Private Key](https://www.ethvanity.com/blog/how-ethereum-addresses-are-derived) — From secp256k1 private key to Keccak-256 hash, last 20 bytes and EIP-55 checksum, with an ethers v6 example and why it is one-way.
- [Open the complete workflow guide](https://www.ethvanity.com/guide) to place these checks in order.
- [Open the address generator](https://www.ethvanity.com/) when you have chosen a compatible format and pattern.

## Frequently asked questions

### How many attempts does a 6-character Ethereum vanity prefix need?

16^6 = 16,777,216 on average for a case-insensitive match, with a 50% chance of success after about 11.6 million attempts.

### Is a suffix easier than a prefix?

No. A fixed suffix of n characters has the same 16^n difficulty as a prefix of n characters. Allowing either end roughly halves the expected work.

### Does 0x count toward the pattern length?

No. 0x is only a notation prefix. Difficulty counts the hex characters after it.

### Why did my search take much longer than the expected value?

The number of attempts follows a geometric distribution. About 37% of searches take longer than the expected value, and about 1% take more than 4.6 times as long.

### Does running a vanity search longer make success more likely in the next minute?

No. Each attempt is independent, so the chance per minute stays constant. Past failures do not bring a match closer; only the total number of attempts determines the cumulative probability.

## Sources

- [EIP-55: Mixed-case checksum address encoding](https://eips.ethereum.org/EIPS/eip-55)

- [ethereum.org: Ethereum accounts](https://ethereum.org/en/developers/docs/accounts/)

- [Wikipedia: Geometric distribution](https://en.wikipedia.org/wiki/Geometric_distribution)



Editorial method: https://www.ethvanity.com/about#publication-method