About

Base58 encoding represents binary data using a 58-character alphabet that deliberately excludes visually ambiguous characters: 0 (zero), O (uppercase o), I (uppercase i), and l (lowercase L). Satoshi Nakamoto adopted this scheme for Bitcoin addresses precisely because a single misread character in a wallet address means irreversible fund loss. The encoding operates on raw bytes, not individual characters. A string of n bytes is treated as a single large integer, then decomposed into base-58 digits through repeated division. This tool implements that exact arithmetic using native BigInt, not a simulation or lookup shortcut.

Misapplying Base58 is common. Feeding Base64 input into a Base58 decoder produces garbage or errors because the alphabets differ: Base64 includes +, /, 0, O, I, l, none of which exist in Base58. This converter validates input strictly against the canonical Bitcoin Base58 alphabet before attempting decode. Note: this tool handles raw Base58, not Base58Check (which appends a 4-byte checksum). If you need checksum verification for cryptocurrency addresses, the trailing bytes must be validated separately against a double-SHA-256 hash.

Formulas

Base58 encoding treats the input byte sequence as a single unsigned integer N and converts it to base 58 using repeated division.

Encoding: given bytes B = [b₀, b₁, …, b_n−1], compute the integer:

N = n−1∑i=0 b_i ⋅ 256ⁿ⁻¹⁻ⁱ

Then extract Base58 digits by repeated modular division:

d_k = N mod 58, N = N58

Digits are collected least-significant first, then reversed. Each leading zero byte (0x00) in the input maps to a leading 1 character (value 0 in the alphabet).

Where b_i = individual byte value (0 - 255), N = big integer representation of the byte array, d_k = the k-th Base58 digit (0 - 57), and the alphabet maps each digit to its character: 0 → 1, 1 → 2, …, 57 → z.

Decoding reverses this: each Base58 character is mapped back to its numeric value, the values are accumulated into N via N = N × 58 + d_k, then N is decomposed into bytes via repeated division by 256. Leading 1 characters restore leading zero bytes.

Reference Data

Value	Char	Value	Char	Value	Char	Value	Char
0	1	15	G	30	X	45	n
1	2	16	H	31	Y	46	o
2	3	17	J	32	Z	47	p
3	4	18	K	33	a	48	q
4	5	19	L	34	b	49	r
5	6	20	M	35	c	50	s
6	7	21	N	36	d	51	t
7	8	22	P	37	e	52	u
8	9	23	Q	38	f	53	v
9	A	24	R	39	g	54	w
10	B	25	S	40	h	55	x
11	C	26	T	41	i	56	y
12	D	27	U	42	j	57	z
13	E	28	V	43	k
14	F	29	W	44	m

Frequently Asked Questions

Base64 uses a 64-character alphabet including +, /, 0, O, I, and l. Base58 removes these 6 ambiguous characters, reducing the alphabet to 58. This makes Base58 safer for manual transcription (handwriting, reading aloud) at the cost of roughly 2% storage overhead compared to Base64. Base64 is better for machine-to-machine transfer; Base58 is better for human-readable identifiers like cryptocurrency addresses.

These four characters are not part of the Base58 alphabet. The alphabet starts at 1 (not 0) and skips O, I, l intentionally. If your input contains any of these, you likely have a Base64 string, a corrupted address, or a miscopied value. Verify your source data.

It decodes the raw Base58 bytes, yes. However, Bitcoin addresses use Base58Check, which appends a 4-byte SHA-256 checksum. This tool does not validate that checksum. The decoded bytes will include the version byte and checksum bytes as raw data. Solana addresses use plain Base58 without a checksum, so decoded output directly yields the 32-byte public key.

The encoder uses UTF-8 encoding internally. A Unicode character like é becomes 2 bytes, and a 4-byte emoji becomes 4 bytes before Base58 encoding. The decoder reverses this process and reconstructs the original UTF-8 string. No data is lost as long as the Base58 string is not truncated.

Yes. Base58 is a bijective encoding scheme. Every unique byte sequence maps to exactly one Base58 string, and vice versa. The encode-then-decode round trip always recovers the original bytes identically. The only failure mode is feeding invalid characters (outside the 58-character alphabet) into the decoder.

An empty byte array has no integer value to encode. The algorithm correctly returns an empty string. Similarly, decoding an empty Base58 string yields zero bytes. This is defined behavior, not an error.

Value	Char	Value	Char	Value	Char	Value	Char
0	1	15	G	30	X	45	n
1	2	16	H	31	Y	46	o
2	3	17	J	32	Z	47	p
3	4	18	K	33	a	48	q
4	5	19	L	34	b	49	r
5	6	20	M	35	c	50	s
6	7	21	N	36	d	51	t
7	8	22	P	37	e	52	u
8	9	23	Q	38	f	53	v
9	A	24	R	39	g	54	w
10	B	25	S	40	h	55	x
11	C	26	T	41	i	56	y
12	D	27	U	42	j	57	z
13	E	28	V	43	k
14	F	29	W	44	m

Value	Char	Value	Char	Value	Char	Value	Char
0	1	15	G	30	X	45	n
1	2	16	H	31	Y	46	o
2	3	17	J	32	Z	47	p
3	4	18	K	33	a	48	q
4	5	19	L	34	b	49	r
5	6	20	M	35	c	50	s
6	7	21	N	36	d	51	t
7	8	22	P	37	e	52	u
8	9	23	Q	38	f	53	v
9	A	24	R	39	g	54	w
10	B	25	S	40	h	55	x
11	C	26	T	41	i	56	y
12	D	27	U	42	j	57	z
13	E	28	V	43	k
14	F	29	W	44	m

Value	Char	Value	Char	Value	Char	Value	Char
0	1	15	G	30	X	45	n
1	2	16	H	31	Y	46	o
2	3	17	J	32	Z	47	p
3	4	18	K	33	a	48	q
4	5	19	L	34	b	49	r
5	6	20	M	35	c	50	s
6	7	21	N	36	d	51	t
7	8	22	P	37	e	52	u
8	9	23	Q	38	f	53	v
9	A	24	R	39	g	54	w
10	B	25	S	40	h	55	x
11	C	26	T	41	i	56	y
12	D	27	U	42	j	57	z
13	E	28	V	43	k
14	F	29	W	44	m