How long does a Solana vanity address take to generate?

The short answer

A Solana vanity address takes, on average, 58^n attempts for n fixed characters, because each base58 character has 58 possible values. That is about 195,000 attempts for three characters, 11.3 million for four, 656 million for five and 38 billion for six. At 100,000 keys per second, four characters take about 2 minutes, five about 1.8 hours and six about 4.4 days. Ignoring capitalization and choosing a sensible first character can cut that by more than 10 times.

Why does each character multiply the work by 58?

Each character multiplies the work by 58 because a Solana address is the base58 encoding of a random 32-byte Ed25519 public key, and there is no way to choose the key's output. The only method is to generate a keypair, encode the public key, compare it with your pattern and try again. Base58 uses the digits 1 to 9 and the letters A to Z and a to z, minus four look-alikes: zero, capital O, capital I and lowercase L. That leaves 58 symbols, so a fixed character matches about 1 time in 58, two characters 1 time in 3,364, and so on.

The search is a lottery, not a countdown. Every attempt is independent, so a search that has run for an hour is no closer to finishing than one that just started. The expected number of attempts is an average:

• About 50% of searches finish within 0.69 times the expected attempts.
• About 63% finish within the expected attempts.
• About 90% finish within 2.3 times, and 95% within 3 times.
• About 1 in 100 searches needs 4.6 times the expected number.

How long does each length take at different speeds?

A Solana vanity search takes 58^n divided by your keys per second, on average. The table uses the uniform case, which applies exactly to a case-sensitive suffix and approximately to a prefix that starts with 2 to 9 or A to H (those are faster, see the next section). The second column is the same pattern with capitalization ignored, assuming every character is a letter that exists in both cases.

Characters	Expected attempts (case-sensitive)	Case-insensitive, all letters	At 100,000 keys/s	At 1 million keys/s	At 10 million keys/s
1	58	29	instant	instant	instant
2	3,364	841	instant	instant	instant
3	195,112	24,389	2 seconds	under a second	under a second
4	11,316,496	707,281	2 minutes	11 seconds	1 second
5	656,356,768	20,511,149	1.8 hours	11 minutes	66 seconds
6	38,068,692,544	594,823,321	4.4 days	10.6 hours	63 minutes
7	2.2 trillion	17.2 billion	256 days	26 days	2.6 days
8	128 trillion	500 billion	41 years	4.1 years	148 days

To translate those speeds into hardware: on my own machine, @solana/web3.js generated and encoded about 8,200 keypairs per second on a single thread in Node.js. A browser that spreads the work over 8 to 16 cores lands in the tens of thousands of keys per second. Native code such as solana-keygen grind is considerably faster per core, and GPUs are faster again. These are rough orders of magnitude; your own speed depends on the device, and any honest tool should measure it rather than assume it.

Which first characters are possible, and which are rare?

Not every first character is equally likely, and this is the detail most vanity calculators get wrong. A 32-byte key is a number below 2^256, and 2^256 is about 17.23 times 58^43. So most keys need 44 base58 characters, and a 44-character address can only start with the first 17 symbols of the alphabet after "1": the digits 2 to 9, the letters A to H, and J (partially). Only the keys small enough to fit in 43 characters, about 5.8% of them, can start with anything else.

I computed the exact share for every leading character by counting the integer ranges:

First character	Share of all addresses	Expected attempts for that one character
2 to 9, A to H (each)	about 5.9%	about 17
J	about 1.4%	about 70
1	about 0.4%	256 (needs a zero first byte)
K to Z, a to z (each)	about 0.1%	about 999

That changes real patterns a lot. The expected attempts for some four-character examples:

Pattern	Expected attempts	Compared with 58^4
Prefix ABCD, case-sensitive	3.3 million	3.4 times easier
Suffix abcd or pump, case-sensitive	11.3 million	exactly 58^4
Prefix abcd, case-sensitive	195 million	17 times harder
Prefix abcd, case-insensitive	406,000	28 times easier
Suffix abcd, case-insensitive	707,000	16 times easier

The case-insensitive prefix wins because it accepts a capital first letter, which is one of the common ones. pump.fun mint addresses are the familiar example of the suffix approach: they end in pump, which costs the same 58^4 no matter which letters you pick.

How much does ignoring capitalization help?

Ignoring capitalization doubles the odds for every letter that exists in both cases, so it halves the expected attempts per letter. A four-letter suffix goes from 11.3 million to about 707,000 attempts, 16 times fewer, and a five-letter one from 656 million to about 20.5 million, 32 times fewer.

It does not help for every character. Digits have no case. Lowercase o and i have no capital form in base58, and capital L has no lowercase form, so those letters still count as 1 in 58. That is why bonk as a case-insensitive suffix needs about 1.4 million attempts, twice as many as abcd. It also explains a common surprise: Sol can never match case-sensitively, because lowercase L is not in the alphabet, but case-insensitive sol can come out as SoL or soL.

Is a prefix or a suffix faster?

A case-sensitive suffix always costs exactly 58 per character, while a prefix is cheaper or more expensive depending on its first character. If your pattern starts with a digit from 2 to 9 or a capital A to H, use a prefix: it is about 3.4 times faster than the same suffix. If it starts with a lowercase letter or K to Z, use a suffix or turn off case sensitivity, or expect about 17 times the work. Requiring both a prefix and a suffix multiplies the two costs, so a three-character prefix plus a three-character suffix is roughly a six-character search.

Why are GPU vanity tools so much faster?

GPU tools are faster because a vanity search is millions of independent, identical computations, which is exactly what a graphics card is built for. A CPU core generates one keypair at a time; a GPU runs thousands of key generations side by side. Open-source GPU grinders publish benchmarks in the tens of millions of keypairs per second for a single high-end consumer card, against tens of thousands for a browser and hundreds of thousands for a many-core CPU. At 10 million keys per second a six-character pattern drops from days to about an hour.

Be careful with two things. Some of the very highest published figures come from tools that search for seed-derived account addresses rather than ordinary keypairs, which you cannot import into a wallet. And a GPU service you rent from someone else is a server generating your key, which brings back the problem in the next section.

Is a vanity address safe to use?

A vanity address is exactly as secure as any other Solana keypair, as long as nobody else ever saw the secret key. Nothing about the matching characters weakens the cryptography: the key is still a random 32-byte seed, you just threw away the ones you did not like. The risk is entirely in who generated it.

• Generate it on your own device. Use solana-keygen grind on your computer, an open-source GPU grinder you run yourself, or a browser tool whose code runs locally.
• Never accept a key someone sends you. A website, bot or "vanity service" that creates the keypair on its server, or delivers it by email or chat, can keep a copy and empty the address whenever it likes. Paying for a vanity address you did not generate yourself is paying someone to hold your key.
• Keep the secret key as your only backup. A ground keypair has no seed phrase, so store the base58 secret key or the JSON file somewhere safe; if it is lost, so is everything in the address.
• Do not trust a prefix as proof of identity. Attackers grind lookalike addresses with the same first and last characters to poison your transaction history, so always check the whole address before sending.

I built the SOLTidy Vanity Address generator around those rules. It is free, runs the search in Web Workers inside your browser using the platform's cryptographic random number generator, makes no network requests from the search threads, and re-derives the public key from the secret before showing a result. Its estimate uses the exact first-character math above rather than plain 58^n, and it caps patterns at 8 characters. It is still a browser, so a malicious extension or clipboard malware on your device could read what the page shows. Use browser-generated keys for branding, mint addresses and hot wallets, and keep savings on a hardware wallet, as covered in the Solana wallet security checklist.

When should you use the CLI or a GPU instead of a browser?

Use a browser for up to four or five characters and the CLI or a GPU for anything longer. In practice:

1. Three or four characters: a browser tool finishes in seconds to minutes. The vanity generator shows the expected attempts and your measured speed before you start.
2. Five characters: hours in a browser, minutes on a fast CPU with solana-keygen grind --starts-with abc12:1 --ignore-case, which writes the keypair to a JSON file you can import.
3. Six characters or more: a GPU you control, or a shorter pattern. Each extra character is 58 times the wait.

If you are setting up a branded mint address for a launch, generate the mint keypair first and then follow the order in how to launch a Solana token; spl-token create-token accepts the keypair file as the mint, including for a Token-2022 token with a transfer fee you set and claim yourself. If you just need many ordinary addresses rather than one pretty one, the wallet generator creates up to 1,000 keypairs offline in seconds. And if a vanity address is replacing an old wallet, run a Solana wallet cleanup scan on the old one first to reclaim SOL from empty token accounts before you abandon it.

Bottom line

A Solana vanity address costs 58^n attempts on average: 11.3 million for four characters, 656 million for five, 38 billion for six. Two choices change that more than hardware does: start a prefix with 2 to 9 or A to H, or use a suffix, and ignore capitalization when you can. Expect variance, because some searches take three times the average. Above all, generate the key yourself, on your own machine, and never use a vanity address that someone else created for you.