Base58 is a binary-to-text encoding that uses 58 characters drawn from the Bitcoin alphabet, omitting the visually confusing digits 0, O, I, and l. A Base58 converter treats the input as a big-endian base-256 number, divides it by 58 repeatedly, and writes one alphabet symbol per remainder, while preserving every leading zero byte as a leading "1" symbol. Decoding performs the reverse: each leading "1" becomes one zero byte and the remaining digits are converted back from base 58 into base 256. The conversion is local and reversible, so anyone who has the alphabet can recover the exact bytes — Base58 is a compact representation of binary data, not encryption, and it provides no confidentiality, integrity check, or signature. Use the Base58 Encode / Decode tool when you want to turn printable UTF-8 text into a Bitcoin-style alphanumeric string, or when you have a raw Base58 value and need to see the exact hexadecimal bytes underneath, including any leading zeros that ordinary integer conversion would silently drop.
The Bitcoin Base58 Alphabet and What It Contains
The Bitcoin Base58 alphabet has exactly 58 symbols, one per digit value from 0 to 57. The order is fixed and every conforming implementation must agree on it:
123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz
Four characters are deliberately missing. The digit zero (0), the uppercase letter I, the uppercase letter O, and the lowercase letter l are visually too similar to symbols that are present, so they are excluded to reduce copy-paste and transcription mistakes. A Base58 converter that encounters any of those four characters, along with whitespace or punctuation, must reject the input rather than guess what was meant.
The remaining alphabet includes the digits 1 through 9 (note that 0 is absent while 1 is present), the uppercase letters A through Z with I and O removed, and the lowercase letters a through z with l removed. Letter case is significant, so "Ab" and "aB" stand for different numeric values in the output. That case sensitivity is also why Base58 carries roughly 5.86 bits of information per symbol: log2(58) ≈ 5.86, which means Base58 strings end up slightly longer than Base64 for the same payload but stay safe to type by hand.
How to Encode UTF-8 Text to Base58
- Open the Base58 Encode / Decode tool in your browser. Because the conversion runs locally, nothing leaves your device while you work.
- Confirm the mode is set to "UTF-8 text to Base58". If you see a toggle between encode and decode, choose encode.
- Type or paste the text you want to encode into the input field. The tool treats the text as a UTF-8 byte sequence, so accents, emoji, and non-Latin scripts are accepted as long as the final byte count stays under the size limit.
- Trigger the conversion. The page typically refreshes as you type, showing both the Base58 result and the source bytes as lowercase hexadecimal.
- Read the hex column first to confirm that the byte sequence matches what you expected — for example a known prefix or any leading zero bytes that must survive the round trip.
- Copy the Base58 string exactly, character by character. Do not add spaces, line breaks, quotes, or trailing newlines, and do not strip leading or trailing "1" symbols because each one represents a real zero byte.
- Treat the result as case-sensitive: paste it back into any checker application the same way it was produced, and never run it through a lowercasing or trimming function.
For a closer look at how the base-256 to base-58 conversion loop is structured, including Java and JavaScript equivalents, see the Base58 Decode: Java Code and Browser Alternatives walkthrough.
How to Decode a Raw Base58 String Back to Bytes
- Switch the Base58 Encode / Decode tool into "Base58 to bytes and text" mode.
- Paste the full, exact, case-sensitive Base58 value into the input field. If your copy contains any of the excluded characters (0, O, I, l), spaces, punctuation, or Unicode symbols, the tool will reject it rather than silently clean it for you.
- Run the decoder. The tool always shows the recovered bytes as lowercase hexadecimal — that is the lossless representation and the only authoritative result.
- Check whether a UTF-8 text interpretation is printed below the hex. It appears only when the bytes happen to form valid UTF-8; otherwise the page keeps the hex and states that a text interpretation is unavailable.
- Inspect leading "1" symbols in the original string. Each one corresponds to one leading zero byte in the recovered hex, so a string that begins with two "1" characters should produce hex that begins with 00 00.
- If the source called the value "Base58Check", remember that the tool proves only the raw byte conversion. The version byte and double-SHA-256 checksum are not validated here.
For a focused walkthrough of the decode side, including how to interpret the hex output when the source is a Bitcoin address or a serial number, see the guide on decoding Base58 strings back to readable data in one click.
Raw Base58 vs Base58Check vs Base64
The three encodings look superficially similar but behave very differently. The table below highlights the properties that affect how each one is parsed and what an application can rely on after parsing.
| Property | Raw Base58 | Base58Check | Base64 |
|---|---|---|---|
| Alphabet size | 58 symbols | 58 symbols | 64 symbols |
| Allowed characters | 1-9, A-Z (no I, O), a-z (no l) | 1-9, A-Z (no I, O), a-z (no l) | A-Z, a-z, 0-9, +, / |
| Padding character | None | None | = at the end |
| Embeds version byte | No | Yes (1 leading byte) | No |
| Includes checksum | No | Yes (4-byte double-SHA-256) | No |
| Detects typos | No | Yes, via checksum | No |
| Case sensitive | Yes | Yes | Yes |
| Typical uses | Compact IDs, raw byte transport | Bitcoin addresses, WIF keys | Generic binary-to-text |
A Base58Check value is a raw Base58 string with one leading version byte and a four-byte checksum appended before encoding, so its visible form is roughly five characters longer than the equivalent raw string. Base64 strings are typically about 4/3 the size of the source bytes and use +, /, and = padding; they are larger than Base58 but encode any byte sequence without ambiguity. Knowing which of these you actually hold is the first step to choosing the right decoder: only Base58Check can tell you whether a string was meant to be a Bitcoin address or just an arbitrary byte payload.
Where Base58 Conversions Go Wrong
The most common error is treating the Base58 alphabet as if it were Base64. People paste values that contain +, /, =, or the missing 0, O, I, l and then wonder why the decoder refuses. A second mistake is pre-processing the Base58 string as text: stripping whitespace, lowercasing letters, normalizing punctuation, or applying URL decoding all change the numeric value and break the round trip. A clean raw value cannot be cleaned further.
A third mistake is treating the leading "1" characters in a Base58 string as decorative padding. Each leading "1" stands for one original zero byte, and discarding them collapses those bytes into nothing on the way back. A fourth mistake is using a successful raw decode as proof that a Bitcoin address or private key is valid. Raw decode proves only that the bytes are well-formed and recoverable; it does not check the version byte, the network, or the checksum, so it cannot confirm that the value is actually yours.
A fifth mistake is pasting a live secret into an online converter, even one that processes locally. Base58 is reversible by anyone with the alphabet, and a URL bar, log line, screenshot, or browser extension can leak the input. When a sensitive value must be debugged, prefer an offline tool or a reviewed library, and assume that the input has been exposed the moment you hit enter.
Limits, Performance, and Privacy
The implementation caps decoded input at 4,096 bytes because arbitrary-base conversion grows quadratically with input length and can otherwise block the browser tab. That ceiling is generous for printable text, identifiers, hash digests, and short binary blobs, but it rules out large files; when the payload is bigger, switch to a streaming format such as Base64 with tooling designed for files.
Empty programmatic vectors are still defined, so the empty string decodes to zero bytes rather than throwing, even though the user interface asks for non-empty input. Output is never silently truncated: when a result fits within the limit you get the full string, and when it does not you get a clear rejection instead of a corrupted partial answer.
All conversion runs locally in the browser, so the tool does not upload your input, your output, or any intermediate state. That property is what makes it safe to use on text values, but it does not make the resulting Base58 string safe to share — the string is still the same bytes in a more compact form, and any system that sees the output can read it back exactly. Compatibility with the canonical alphabet and the leading-zero rule is anchored against the official Bitcoin Core base58_encode_decode test vectors, so values produced by well-reviewed Bitcoin implementations should round-trip cleanly through this tool.