Introduction
Base58Check is the encoding Bitcoin uses for addresses and private keys. It takes a binary payload, appends a 4-byte checksum derived from a double SHA-256 hash, and encodes the result using a 58-character alphabet that omits visually ambiguous characters (0, O, I, l). This tool encodes hex payloads to Base58Check and decodes Base58Check strings back to hex, showing the payload, checksum, and raw Base58 at each step. If you decode a string with a corrupted checksum, the tool flags it immediately. Everything runs in your browser.
What this tool does
- Encode a hex payload into a Base58Check string by appending a 4-byte double-SHA-256 checksum and converting to the Base58 alphabet
- Decode a Base58Check string back to its hex payload, extracting and verifying the 4-byte checksum against a recomputed value
- Display the encoding breakdown: the payload in hex, the 4-byte checksum in hex, and the raw Base58 (payload plus checksum without the alphabet conversion)
- Show the decoding breakdown: extracted payload, extracted checksum, expected checksum, and whether they match
- Report checksum verification failures clearly when a decoded string is corrupted or has a typo
- Run entirely client-side: no payload or encoded string is transmitted
How this tool works
In encode mode, the tool takes a hex string from the input field, converts it to bytes, and computes the checksum. The checksum is the first 4 bytes of SHA-256(SHA-256(payload)), where SHA-256 is applied twice. This double-hash construction provides extra protection against length extension attacks and is a pattern used throughout Bitcoin. The tool concatenates the payload and the 4-byte checksum, then encodes the combined bytes using the Base58 alphabet.
The Base58 alphabet is `123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`. It contains 58 characters, omitting zero (0), uppercase O, uppercase I, and lowercase l. These four characters are frequently confused when reading or transcribing, so removing them reduces human error. The encoding treats the byte array as a big-endian integer and converts it to base-58 digits, then maps each digit to the alphabet. Leading zero bytes in the payload are encoded as leading '1' characters.
In decode mode, the tool reverses the process. It converts the Base58Check string back to bytes, splits off the last 4 bytes as the checksum, and recomputes the expected checksum from the remaining payload bytes. If the extracted checksum matches the expected checksum, the decode succeeds and the payload is displayed in hex. If they do not match, the tool reports a checksum verification failure.
The tool also shows the raw Base58 encoding of just the payload (without the checksum), so you can see the difference between plain Base58 and Base58Check. All computation happens locally in your browser.
How Base58Check encoding works (Bitcoin Wiki, FIPS 180-4)
Base58Check was introduced by Satoshi Nakamoto in the original Bitcoin Core source code and is documented on the Bitcoin Wiki. The encoding serves two purposes: it produces compact strings that are easy to read and type, and it includes a checksum that catches transcription errors before funds are sent to a wrong address.
The Base58 alphabet is defined in the Bitcoin Core source code. The 58 characters were chosen by removing the four most ambiguous characters from a 62-character set (digits plus uppercase plus lowercase letters). The remaining alphabet has no characters that look alike in common fonts.
The checksum is the first 4 bytes of SHA-256(SHA-256(payload)). SHA-256 is specified in FIPS 180-4. The double-hash is a Bitcoin convention also used in proof-of-work and Merkle tree construction. A 4-byte checksum provides 32 bits of error detection, which catches over 99.999998% of random errors. This is sufficient for address validation because the most common errors are single-character typos, which the checksum catches with near-certainty.
Base58Check is used in several places in Bitcoin. Legacy addresses (P2PKH) use version byte 0x00. Pay-to-script-hash addresses (P2SH) use version byte 0x05. Private keys in Wallet Import Format (WIF) use version byte 0x80. Testnet addresses use 0x6F (P2PKH) and 0xC4 (P2SH). The version byte is part of the payload, so it is covered by the checksum.
SegWit addresses (P2WPKH, P2TR) do not use Base58Check. They use Bech32 (BIP 173) or Bech32m (BIP 350), which have a different checksum algorithm based on BCH error-correcting codes. For encoding and decoding Bech32, see the Bitcoin Address Generator.
How to use this tool
- Select a mode: Encode (hex to Base58Check) or Decode (Base58Check to hex)
- In encode mode, enter a hex string (even number of hex characters, using 0-9 and a-f or A-F). The tool converts it to bytes and computes the checksum
- Review the encoding breakdown: payload in hex, 4-byte checksum in hex, raw Base58 (payload plus checksum), and the final Base58Check string in the output field
- In decode mode, paste a Base58Check string. The tool converts it back to bytes and splits the payload from the checksum
- Check the decoding breakdown: extracted payload, extracted checksum, expected checksum, and whether they match. A red 'Checksum valid: No' means the string is corrupted
- Use the Swap button to switch between encode and decode modes, which reverses the operation direction
Real-world examples
Encoding a Bitcoin P2PKH address payload
Input: `00` followed by a 20-byte Hash160 (42 hex characters total). The version byte 0x00 marks this as a mainnet P2PKH address. The tool computes the 4-byte checksum, appends it, and Base58Check-encodes the 25 bytes. The output starts with '1' (because the leading 0x00 byte encodes as a leading '1' in Base58). This is how a Legacy Bitcoin address is constructed from a public key hash.
Decoding and verifying a Bitcoin address
Input: `1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2` (a known Bitcoin address). The tool decodes it to 25 bytes: the first byte is 0x00 (P2PKH mainnet version), the next 20 bytes are the Hash160 payload, and the last 4 bytes are the checksum. The tool recomputes the checksum from the payload and confirms it matches. If you change a single character in the input, the checksum will fail.
Detecting a corrupted Base58Check string
Input: `1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN3` (last character changed from 2 to 3). The tool decodes the string, extracts the checksum, recomputes the expected checksum, and finds they do not match. The result panel shows 'Checksum valid: No' in red and reports 'Checksum verification failed.' This is the protection that prevents sending Bitcoin to a mistyped address.
Encoding a WIF private key
Input: `80` followed by a 32-byte private key and `01` (compression flag), totaling 70 hex characters. The version byte 0x80 marks this as a mainnet private key. The tool computes the checksum and Base58Check-encodes the 38 bytes. The output starts with 'K' or 'L' (for compressed mainnet keys), which is the Wallet Import Format used by Bitcoin wallets to import and export private keys.
Comparison with similar methods
| Method | Complexity | Typical use |
|---|---|---|
| Base58Check | 58-char alphabet, 4-byte double-SHA-256 checksum | Bitcoin addresses, WIF private keys |
| Base58 (no checksum) | 58-char alphabet, no error detection | IPFS hashes, short identifiers (unsafe for value) |
| Base64 | 64-char alphabet, no checksum, case-sensitive | Email, JWTs, data URIs |
| Bech32 (BIP 173) | 32-char alphabet, BCH error code | Bitcoin SegWit addresses (P2WPKH, P2TR) |
| Hex | 16-char alphabet, no checksum | Raw binary display, debug output |
Limitations or considerations
Base58Check is an encoding, not encryption. It provides no confidentiality. Anyone who has the Base58Check string can decode the payload. Do not use it to hide sensitive data.
The 4-byte checksum catches most single-character errors but is not as strong as the Bech32 checksum, which uses a BCH error-correcting code that can detect up to 4 errors with a false-positive rate below 10^-9. Base58Check's 32-bit checksum has a false-positive rate of about 1 in 4 billion for random strings, which is sufficient for address validation but weaker than Bech32.
This tool does not interpret the version byte. It encodes and decodes raw payloads. To construct a Bitcoin address, you need to prepend the correct version byte (0x00 for P2PKH, 0x05 for P2SH) to the payload before encoding. For full address generation with version byte handling, see the Bitcoin Address Generator.
The tool does not handle Bech32 or Bech32m encoding, which is used for SegWit addresses. For Bech32 encoding, see the Bitcoin Address Generator. For plain Base58 without the checksum, see the Base58 Encode/Decode tool.
For multi-chain address validation that checks version bytes and network prefixes, see the Crypto Address Validator. For Ethereum's different checksum scheme, see the Ethereum Checksum Validator.
Frequently asked questions
What is the difference between Base58 and Base58Check?
Base58 is a plain encoding that converts bytes to a 58-character alphabet with no error detection. Base58Check adds a 4-byte checksum (the first 4 bytes of double SHA-256 of the payload) before encoding. When decoding a Base58Check string, the checksum is verified. If it does not match, the string is corrupted. Bitcoin always uses Base58Check, never plain Base58, for addresses and private keys.
Why does the Base58 alphabet omit 0, O, I, and l?
These four characters are visually ambiguous in many fonts. Zero (0) looks like uppercase O. Uppercase I looks like lowercase l. When users read or type an address, these characters cause confusion. Removing them from the alphabet eliminates the most common source of human transcription error. The alphabet goes from 62 characters (digits plus both cases of letters) to 58.
Why is the checksum computed with a double SHA-256?
Satoshi Nakamoto used double SHA-256 throughout Bitcoin (proof-of-work, Merkle trees, address checksums). The double hash provides defense against length extension attacks on SHA-256. For the 4-byte checksum, the practical benefit is minimal since only 4 bytes are used, but the convention is consistent with the rest of the Bitcoin codebase.
Can Base58Check be used for non-Bitcoin data?
Yes. Base58Check is a general-purpose encoding. Any binary payload can be encoded with it. However, the version byte conventions (0x00 for P2PKH, 0x05 for P2SH, 0x80 for WIF) are Bitcoin-specific. If you use Base58Check for your own application, you should define your own version byte scheme and document it.
How does Base58Check compare to Bech32 for error detection?
Base58Check uses a 32-bit checksum (4 bytes of double SHA-256), which catches most single-character errors but has a false-positive rate of about 1 in 4 billion for random strings. Bech32 uses a BCH error-correcting code with a 30-character checksum that detects up to 4 errors with a false-positive rate below 10^-9. Bech32 is also case-insensitive (all lowercase), while Base58Check is case-sensitive.
Conclusion
Base58Check is the encoding layer behind every Legacy Bitcoin address and WIF private key. This tool shows the payload, checksum, and alphabet conversion at each step, making it clear how a hex byte array becomes a '1...' address string. For full Bitcoin address generation with version byte handling and Bech32 support, see the Bitcoin Address Generator. For plain Base58 without the checksum, see the Base58 Encode/Decode tool. For Ethereum's checksum scheme, see the Ethereum Checksum Validator. For multi-chain address validation, see the Crypto Address Validator.