Skip to content
BetterPass logo

Base58 Encode / Decode — Base58Check & Bitcoin Address Inspector

Encode and decode Bitcoin's Base58 alphabet, add or verify the 4-byte double-SHA256 Base58Check checksum, inspect address prefixes (P2PKH, P2SH, bech32), and upload files up to 5 MB.

Result

What is Base58 Encoder / Decoder & Address Inspector?

Base58 is a binary-to-text encoding designed for humans. It drops the visually ambiguous characters 0, O, I and l, plus the URL-hostile + and /, leaving 58 safe characters.

58 characters — A–Z, a–z, 0–9 minus 0, O, I, l.
~37% overhead — a little heavier than Base64 (33%), but far more typo-safe to read and type.
Base58Check — Bitcoin appends a 4-byte double-SHA256 checksum so mistyped addresses are rejected instead of silently wrong.
Case-sensitive — every letter matters; changing case changes the decoded value.
Address inspector — decode a Base58Check address to reveal its version byte, type (P2PKH, P2SH, WIF…) and checksum validity.

Zero-Server Tool Data Guarantee

All encoding, decoding, checksum and address inspection run locally in your browser. Your text, files, and addresses never leave your device — no server upload, no logging, no tracking.

How to Use

01

Pick a Mode

Encode turns text or a file into Base58; Decode turns Base58 back into text or hex; Address Inspector reads a Base58Check address's prefix and checksum.

02

Add or Verify Base58Check

In Encode, toggle 'Base58Check' to append the 4-byte checksum (set the version byte, default 00). In Decode, toggle 'Verify Base58Check' to validate a full string.

03

Choose Decode Output

Toggle 'Show as hex' to render the raw decoded bytes as hex instead of text.

04

Enter Input or Drop a File

Type, paste, or drop a text file up to 5 MB. Output updates in real time.

05

Copy

Use the copy button to grab the encoded, decoded, or inspection result.

Common Use Cases

Bitcoin Addresses

Encode P2PKH (1...), P2SH (3...), and WIF keys with the Base58Check checksum, or inspect an existing address's prefix.

Transaction / Block IDs

Represent 32-byte hashes as compact, copy-paste-safe Base58 strings for explorers and wallets.

Short Unique Identifiers

Generate human-friendly, typo-resistant IDs for records, tokens, and invite codes.

Checksum Verification

Validate that a pasted Base58Check string is intact before relying on it.

Encoded QR Codes

Encode compact identifiers into QR codes using an alphabet safe for manual fallback entry.

Implementation Examples

JavaScriptBase58 Encode/Decode + Base58Check
const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';


function base58Encode(bytes) {
  let num = BigInt('0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join(''));
  let result = '';
  while (num > 0n) { result = ALPHABET[Number(num % 58n)] + result; num /= 58n; }
  for (const b of bytes) { if (b === 0) result = '1' + result; else break; }
  return result;
}


// Base58Check: version byte + payload + 4-byte double-SHA256 checksum
async function sha256d(bytes) {
  const h1 = await crypto.subtle.digest('SHA-256', bytes);
  return new Uint8Array(await crypto.subtle.digest('SHA-256', h1));
}
async function base58CheckEncode(payload, version = 0x00) {
  const full = new Uint8Array(1 + payload.length + 4);
  full[0] = version;
  full.set(payload, 1);
  full.set((await sha256d(full.slice(0, 1 + payload.length))).slice(0, 4), 1 + payload.length);
  return base58Encode(full);
}

Base58 vs Base64

FeatureBase58Base64
Alphabet size58 characters64 characters
Ambiguous charsNone (excludes 0, O, I, l)Possible (0, O, l, I, 1)
Special charactersNone+, /, =
Overhead~37%33%
Checksum?Optional (Base58Check)No
Primary useBlockchain addressesData transport, embedding

Production Best Practices & Security

Use Base58Check for anything that must survive hand-off — addresses, keys, and IDs. Why:the 4-byte double-SHA256 checksum turns typos into hard errors instead of silently wrong output, which is essential for money-like identifiers.
Never treat Base58 as bulk transport — it's ~37% overhead with slow arbitrary-precision math. Why:for large payloads, Base64 is shorter and orders of magnitude faster; Base58 exists for short, human-handled strings.
Always verify the checksum on input — don't trust a pasted address blindly. Why:the inspector here recomputes SHA256(SHA256(version + payload)) and flags mismatches, catching a single mistyped character.
Match the alphabet to the network — Bitcoin, Litecoin, Dogecoin and Ripple share the base58 idea but differ in details. Why:using the wrong alphabet or version byte yields an address other wallets reject.
Know that bech32 (bc1) is different — SegWit addresses are not Base58Check. Why:bech32 uses the BIP-173 checksum and alphabet; this tool's inspector flags bc1 inputs and points you to plain decode instead.
Prefer Base64 when size beats readability — 33% vs ~37% overhead. Why:choose Base58 only when human handling or an existing crypto convention matters more than length.

Frequently Asked Questions

Base58 is a binary-to-text encoding designed for human usability. It uses 58 characters — A-Z, a-z, and 0-9 — while deliberately excluding the visually ambiguous 0 (zero), O, I, and l, as well as the URL-hostile + and /.

That removes the classic 0/O and 1/I/l confusion when reading or typing. Base58 is not an official RFC standard, but it became the de facto encoding for cryptocurrency addresses.