Base64 Characters Table

Complete reference of all 64 Base64 characters. See each character's 6-bit index, binary representation, ASCII code, and group. Essential reference for understanding how Base64 maps binary data to printable text.

100% Client-Side — Your data never leaves your device

Base64 Alphabet — All 64 Characters

Uppercaseidx 0–25
A0
B1
C2
D3
E4
F5
G6
H7
I8
J9
K10
L11
M12
N13
O14
P15
Q16
R17
S18
T19
U20
V21
W22
X23
Y24
Z25
Lowercaseidx 26–51
a26
b27
c28
d29
e30
f31
g32
h33
i34
j35
k36
l37
m38
n39
o40
p41
q42
r43
s44
t45
u46
v47
w48
x49
y50
z51
Digitsidx 52–61
052
153
254
355
456
557
658
759
860
961
Symbolsidx 62–63
+62
/63
=pad

Detailed Character Reference

Index6-Bit BinaryCharASCII DecASCII HexGroupDescription
0000000A650x41UppercaseFirst letter of alphabet
1000001B660x42UppercaseSecond letter
2000010C670x43UppercaseThird letter
3000011D680x44UppercaseFourth letter
4000100E690x45UppercaseMost common English letter
5000101F700x46UppercaseSixth letter
6000110G710x47UppercaseSeventh letter
7000111H720x48UppercaseEighth letter
8001000I730x49UppercaseNinth letter
9001001J740x4AUppercaseTenth letter
10001010K750x4BUppercaseEleventh letter
11001011L760x4CUppercaseTwelfth letter
12001100M770x4DUppercaseThirteenth letter
13001101N780x4EUppercaseFourteenth letter
14001110O790x4FUppercaseFifteenth letter
15001111P800x50UppercaseSixteenth letter
16010000Q810x51UppercaseSeventeenth letter
17010001R820x52UppercaseEighteenth letter
18010010S830x53UppercaseNineteenth letter
19010011T840x54UppercaseTwentieth letter
20010100U850x55UppercaseTwenty-first letter
21010101V860x56UppercaseTwenty-second letter
22010110W870x57UppercaseTwenty-third letter
23010111X880x58UppercaseTwenty-fourth letter
24011000Y890x59UppercaseTwenty-fifth letter
25011001Z900x5AUppercaseTwenty-sixth letter
26011010a970x61LowercaseFirst lowercase letter
27011011b980x62LowercaseSecond lowercase letter
28011100c990x63LowercaseThird lowercase letter
29011101d1000x64LowercaseFourth lowercase letter
30011110e1010x65LowercaseMost common letter in English
31011111f1020x66LowercaseSixth lowercase letter
32100000g1030x67LowercaseSeventh lowercase letter
33100001h1040x68LowercaseEighth lowercase letter
34100010i1050x69LowercaseNinth lowercase letter
35100011j1060x6ALowercaseTenth lowercase letter
36100100k1070x6BLowercaseEleventh lowercase letter
37100101l1080x6CLowercaseTwelfth lowercase letter
38100110m1090x6DLowercaseThirteenth lowercase letter
39100111n1100x6ELowercaseFourteenth lowercase letter
40101000o1110x6FLowercaseFifteenth lowercase letter
41101001p1120x70LowercaseSixteenth lowercase letter
42101010q1130x71LowercaseSeventeenth lowercase letter
43101011r1140x72LowercaseEighteenth lowercase letter
44101100s1150x73LowercaseNineteenth lowercase letter
45101101t1160x74LowercaseTwentieth lowercase letter
46101110u1170x75LowercaseTwenty-first lowercase letter
47101111v1180x76LowercaseTwenty-second lowercase letter
48110000w1190x77LowercaseTwenty-third lowercase letter
49110001x1200x78LowercaseTwenty-fourth lowercase letter
50110010y1210x79LowercaseTwenty-fifth lowercase letter
51110011z1220x7ALowercaseTwenty-sixth lowercase letter
521101000480x30DigitsZero digit
531101011490x31DigitsOne digit
541101102500x32DigitsTwo digit
551101113510x33DigitsThree digit
561110004520x34DigitsFour digit
571110015530x35DigitsFive digit
581110106540x36DigitsSix digit
591110117550x37DigitsSeven digit
601111008560x38DigitsEight digit
611111019570x39DigitsNine digit
62111110+430x2BSymbolsPlus sign (62nd character)
63111111/470x2FSymbolsForward slash (63rd character)

Showing 64 of 64 Base64 characters (plus padding =)

About the Base64 Alphabet

Base64 uses a 64-character alphabet to represent binary data as printable ASCII text. Each character maps to a 6-bit value (0–63), which is why there are exactly 64 characters. The alphabet is carefully designed:

  • A–Z (indices 0–25): 26 uppercase letters across ASCII 65–90
  • a–z (indices 26–51): 26 lowercase letters across ASCII 97–122
  • 0–9 (indices 52–61): 10 digits across ASCII 48–57
  • + (index 62): Plus sign at ASCII 43
  • / (index 63): Forward slash at ASCII 47
  • = (not indexed): Padding character at ASCII 61, used when input bytes aren't a multiple of 3

Why this order? The characters are ordered so that sorting by index produces a lexicographically stable result that's roughly the same as ASCII sorting. Uppercase letters (earliest in ASCII) map to the lowest indices, followed by lowercase (mid-range ASCII), then digits (higher ASCII), and finally the two symbols.

URL-safe variant: For URLs, + and / are replaced with - (hyphen) and _ (underscore) respectively. Padding is often omitted in URL-safe Base64 since the length can be inferred. This variant is used in JWTs, cookies, and URL parameters.

Why this tool is safe

Your data never leaves your device — everything runs in your browser.

No server uploads. Other tools send your files to their servers. Ours don't.
Zero tracking of content. We never see, store, or log anything you convert.
Works offline. Once loaded, the tool works without an internet connection.

Build a Base64 Lookup Table in Code

Generate the Base64 alphabet, look up characters by index, and encode binary data.

JavaScript
// The standard Base64 alphabet
const BASE64_ALPHABET =
  "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
  "abcdefghijklmnopqrstuvwxyz" +
  "0123456789+/";

// Look up Base64 character by 6-bit index
function base64Char(index: number): string {
  return BASE64_ALPHABET[index];
}

// Build a lookup table object
function buildBase64Table() {
  const table: Record<number, {
    char: string;
    ascii: number;
    hex: string;
    group: string;
  }> = {};
  for (let i = 0; i < 64; i++) {
    const ch = BASE64_ALPHABET[i];
    let group = "Uppercase";
    if (i >= 26 && i < 52) group = "Lowercase";
    else if (i >= 52 && i < 62) group = "Digits";
    else if (i >= 62) group = "Symbols";
    table[i] = {
      char: ch,
      ascii: ch.charCodeAt(0),
      hex: `0x${ch.charCodeAt(0).toString(16)}`,
      group,
    };
  }
  return table;
}

// Encode 3 bytes to 4 Base64 chars
function encode3Bytes(b0: number, b1: number, b2: number): string {
  const n = (b0 << 16) | (b1 << 8) | b2;
  return (
    BASE64_ALPHABET[(n >> 18) & 63] +
    BASE64_ALPHABET[(n >> 12) & 63] +
    BASE64_ALPHABET[(n >> 6) & 63] +
    BASE64_ALPHABET[n & 63]
  );
}
console.log(encode3Bytes(77, 97, 110)); // "TWFu"
console.log(base64Char(25)); // "Z"

Frequently Asked Questions

Search below or browse through our most commonly asked questions.

Base64 uses exactly 64 characters to represent binary data: uppercase letters A-Z (indices 0-25), lowercase letters a-z (indices 26-51), digits 0-9 (indices 52-61), plus sign + (index 62), and forward slash / (index 63). The = character is used for padding when input bytes aren't evenly divisible by 3. Each character represents a unique 6-bit value (000000 to 111111).
Base64 encodes 6 bits per character (2^6 = 64). The encoding takes 3 bytes (24 bits) of input and splits them into 4 groups of 6 bits each, producing 4 Base64 characters. This 3-to-4 ratio is why Base64 increases data size by about 33% — 4 output characters for every 3 input bytes. The number 64 was chosen as the smallest power of 2 that can encode all standard bits with a manageable alphabet size.
The order is carefully designed for stability: uppercase letters (earliest in ASCII, 65-90) map to indices 0-25, lowercase letters (ASCII 97-122) to 26-51, digits (ASCII 48-57) to 52-61, and + and / to 62-63. This roughly follows ASCII sorting order, which means sorting Base64 strings lexicographically produces results that correlate with sorting the underlying binary data for the same input length.
Standard Base64 uses + (index 62) and / (index 63) which are not safe in URLs. URL-safe Base64 replaces + with - (hyphen) and / with _ (underscore). Additionally, URL-safe Base64 often omits the trailing = padding. This variant is used for JWT tokens, URL query parameters, and cookies where + and / would cause encoding issues.
The = character (ASCII 61) is not part of the 64-character alphabet — it's padding. When encoding data, if the input length is not a multiple of 3, padding is added: 1 padding = for 2 input bytes, and 2 padding == for 1 input byte. The padding signals to the decoder how many bytes the original input had — it's essential for correct decoding. Some implementations (like URL-safe Base64) omit padding and infer the length instead.
The index (0-63) directly maps to a character. In code, you can create a string of all 64 characters and use it as a lookup table: characters[index] gives you the character. For example, index 0 is 'A', index 25 is 'Z', index 26 is 'a', index 51 is 'z', index 52 is '0', index 61 is '9', index 62 is '+', and index 63 is '/'. Our reference table shows all 64 mappings at a glance.
Yes. The search box filters the reference table in real time. You can search by index number (like '0' or '63'), by character (like 'A' or '+'), by binary pattern (like '000000' or '111111'), by ASCII decimal or hex value, or by group name (like 'Uppercase' or 'Symbols'). You can also filter by group using the category buttons.