Vanity Address

What Is a Vanity Address?

A vanity address is a Bitcoin address that contains a recognizable, human-readable pattern chosen by the owner. Instead of a seemingly random string of characters, a vanity address might start with "1Armory", "1dice", or "bc1qspark". The address is cryptographically valid and functions identically to any other Bitcoin address: the only difference is that its owner invested computational effort to find a key pair that produces a matching pattern.

Because Bitcoin addresses are derived from public keys through a one-way hash function pipeline, there is no shortcut to producing a specific pattern. The generator must create random key pairs, derive the address for each, and check whether it matches the desired prefix. This process is repeated millions or billions of times until a match is found.

Well-known examples include 1ArmoryXcfq7TnCSuZa9fQjRYwJ4bkRKfv (used by the Bitcoin Armory wallet for donations), the family of 1dice addresses used by the early gambling platform Satoshi Dice, and the famous burn address 1BitcoinEaterAddressDontSendf59kuE, which has received over 2.1 BTC despite having no valid private key.

How It Works

Vanity address generation is a brute-force search over the secp256k1 key space. The process follows the same steps as normal address derivation, repeated until the output matches:

1. Generate a random 256-bit private key from the valid range on the secp256k1 curve
2. Derive the corresponding public key via elliptic curve point multiplication
3. Hash the public key: first SHA-256, then RIPEMD-160 (producing a 20-byte public key hash)
4. Encode the result as a Bitcoin address (Base58Check for legacy formats, Bech32 for SegWit)
5. Check whether the address starts with the desired prefix. If yes, output the key pair. If not, discard and repeat from step 1.

Each iteration is independent of every other, making the problem "embarrassingly parallel" and well-suited for GPU acceleration. No information from a failed attempt helps with the next one.

Computational Cost

The difficulty of finding a vanity address grows exponentially with the length of the desired pattern. For legacy P2PKH addresses encoded in Base58 (which uses 58 characters: digits 1-9, uppercase A-Z minus O and I, lowercase a-z minus l), each additional character multiplies the expected number of attempts by approximately 58:

For Bech32 (SegWit) addresses, the character set is only 32 characters, so each additional character multiplies difficulty by ~32x instead of ~58x. However, the Bech32 alphabet excludes several common letters (including "b", "i", and "o"), which limits what words can be spelled.

Address Format Differences

Vanity generation works across all Bitcoin address types, but the fixed prefix and encoding differ:

• Legacy P2PKH (starts with "1"): Base58 encoding, 58 possible characters per position, case-sensitive
• P2SH (starts with "3"): Base58 encoding, commonly used for multisig scripts
• P2WPKH (starts with "bc1q"): Bech32 encoding, 32 characters, lowercase only
• Taproot (starts with "bc1p"): Bech32m encoding, 32 characters, uses Schnorr key derivation

GPU Acceleration

Modern vanity generators like VanitySearch use CUDA or OpenCL to parallelize the search across thousands of GPU cores. A single NVIDIA RTX 4090 achieves roughly 6 billion key checks per second, approximately 1,200x faster than a single CPU thread. Multi-GPU setups can scale linearly, though even with hundreds of GPUs, prefixes longer than 10 characters remain impractical for legacy addresses.

Split-Key Generation

Split-key generation allows outsourcing the computational work without trusting the generator with the final private key. The process relies on a property of elliptic curve cryptography: two private keys can be added together modularly, and their corresponding public keys combine to produce the public key for the summed private key.

1. The owner generates a key pair locally and shares only the public key plus the desired prefix
2. The generator searches for a complementary key pair whose combined public key produces the vanity address
3. The generator returns the partial private key
4. The owner combines both private keys via modular addition to derive the final private key

The generator never learns the final private key because they hold only one component. Tools like VanitySearch support this mode via the -sp flag.

Use Cases

Business Branding and Donations

Organizations use vanity addresses to create recognizable receiving addresses. A donation address starting with the project's name is easier to verify and harder for attackers to substitute via man-in-the-middle attacks. Satoshi Dice, one of the earliest Bitcoin gambling platforms, used a family of 1dice vanity addresses to represent different bet types, and at its peak accounted for more than half of all Bitcoin transactions.

Identifiable Exchange Addresses

Exchanges and payment processors can use vanity addresses for deposit or withdrawal addresses, making it easier for customers to confirm they are sending to the correct destination. A recognizable prefix provides an additional visual verification step beyond simply comparing the full address string.

Proof-of-Burn Addresses

Vanity addresses are sometimes used to create provably unspendable burn addresses. The address 1CounterpartyXXXXXXXXXXXXXXXUWLpVr was used during the Counterparty token launch to demonstrate that coins were permanently destroyed. Because the address was crafted to be clearly artificial, it serves as evidence that no one holds the corresponding private key.

Risks and Considerations

Untrusted Generators

The most critical risk with vanity addresses: if someone else generates the address for you, they know the private key and can steal your funds at any time. Web-based vanity generators are especially dangerous because there is no way to verify that the server-side code is honest, and JavaScript-based generators could silently transmit keys to a remote server. The only safe options are generating locally on your own hardware or using split-key generation (described above).

The Profanity Vulnerability

Profanity was a popular GPU-accelerated vanity generator for Ethereum that contained a critical flaw: it seeded its random number generator with a 32-bit integer, reducing the key space from the intended 2²⁵⁶ possible keys to just ~4.3 billion. In September 2022, researchers from 1inch publicly disclosed that private keys from Profanity-generated addresses could be recovered in roughly the same time it originally took to generate them.

Days after the disclosure, the Wintermute market maker lost $160 million when attackers exploited a Profanity-generated admin wallet key. While this vulnerability was Ethereum-specific (Bitcoin tools like VanitySearch generate fully random 256-bit keys), it illustrates the danger of trusting any generator without auditing its randomness source.

Address Poisoning

Address poisoning exploits the visual similarity that vanity generation makes possible. Attackers generate addresses matching the first and last several characters of a target's frequently-used address, then send a small dust transaction to "poison" the target's transaction history. When the victim later copies an address from their wallet history, they may accidentally select the attacker's look-alike address.

In May 2024, a single Ethereum address poisoning incident resulted in a loss of 1,155 WBTC (approximately $68 million). On Bitcoin, research by Jameson Lopp identified nearly 48,000 poisoning-pattern transactions between July 2023 and January 2025, though the success rate was significantly lower than on Ethereum. For a deeper look at how Bitcoin privacy practices help mitigate these risks, see the related research article.

Address Reuse and Privacy

Vanity addresses encourage address reuse, which degrades privacy by linking multiple transactions to the same identity. Modern best practice favors generating a fresh address for each transaction using HD wallets with BIP-44 derivation paths. A vanity address used as a long-term receiving address makes it trivial for blockchain observers to track all incoming payments to that entity. For users who prioritize privacy, technologies like silent payments offer a way to publish a static identifier without the reuse problem.

How to Generate a Vanity Address Safely

If you choose to use a vanity address, follow these precautions:

1. Generate locally using open-source, audited software (such as VanitySearch) on an air-gapped or offline machine
2. Never use web-based generators or closed-source tools that could retain your private key
3. If outsourcing computation, use split-key generation so the generator never holds the complete key
4. Verify the tool's randomness source: ensure it uses cryptographically secure random number generation with full 256-bit entropy
5. Keep patterns short: a 4-5 character prefix is practical and still recognizable, while longer patterns require excessive computation

# Example: generate a vanity address locally with VanitySearch
# Search for a legacy address starting with "1Spark"
./VanitySearch -o result.txt 1Spark

# Search for a Bech32 address starting with "bc1qspark"
./VanitySearch -o result.txt -bech32 bc1qspark

# Split-key mode (safe for outsourcing)
# Step 1: Generate your key pair locally
./VanitySearch -sp myPublicKey 1Spark
# Step 2: Combine the partial key with your private key

For most users, the risks of vanity addresses outweigh the benefits. Layer 2 solutions like Spark and Lightning addresses provide human-readable payment identifiers without requiring brute-force generation or exposing users to the security risks of static address reuse.

For more on how Bitcoin address formats have evolved from legacy to modern standards, see the research article on Bitcoin address types from P2PKH to Taproot.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.