How Base64 Encoding Works (The Math and Algorithms)

To truly master data transport in software engineering, a developer must understand how abstractions work under the hood. Base64 encoding might seem like magic—you input text, and a jumbled string of characters comes out—but it is actually a highly structured, mathematical process based on simple bitwise operations.

In this technical guide, we will break down the exact mechanics of the Base64 encoding algorithm, demonstrating step-by-step how a computer translates raw bytes into the 64-character ASCII alphabet.

The Core Concept: 8-bit Bytes to 6-bit Chunks

The foundation of computing is the byte, which consists of 8 bits (e.g., 01001000). Almost all modern computer architectures, file formats, and network protocols read and write data in 8-bit bytes.

The Base64 algorithm, however, operates on 6-bit chunks. Why 6 bits? Because 2 to the power of 6 equals 64. A 6-bit chunk can represent exactly 64 unique values (from 0 to 63). This perfectly aligns with the 64 safe ASCII characters in the Base64 index table.

Therefore, the entire goal of the Base64 algorithm is to take a stream of 8-bit bytes, strip the bits out, and regroup them into 6-bit chunks.

The Least Common Multiple: 24 Bits

If you have 8-bit inputs and you need 6-bit outputs, the math doesn't divide evenly right away. The lowest common multiple of 8 and 6 is 24.

This means the algorithm must process the input data in blocks of 3 bytes at a time. Three 8-bit bytes equal 24 bits. Those 24 bits can then be perfectly divided into four 6-bit chunks.

The Golden Rule of Base64: 3 bytes of raw data are converted into 4 characters of Base64 text.

Step-by-Step Example: Encoding "Cat"

Let's manually encode the word "Cat" into Base64 to see the algorithm in action. The word "Cat" consists of exactly 3 characters (3 bytes), making it a perfect example that requires no padding.

Step 1: Convert characters to ASCII values

First, we look up the standard ASCII/UTF-8 decimal value for each character:

Step 2: Convert decimals to 8-bit binary

Next, we convert those decimal values into their binary representations:

Concatenating these together gives us our 24-bit raw data stream:
010000110110000101110100

Step 3: Regroup into 6-bit chunks

Now, we take that continuous 24-bit stream and split it into four equal groups of 6 bits:

Step 4: Convert 6-bit chunks back to decimal

We convert each of these new 6-bit binary chunks back into standard decimal values:

Step 5: Map decimals to the Base64 Index Table

Finally, we look up these decimal values in the standard Base64 index table. The table maps 0-25 to A-Z, 26-51 to a-z, 52-61 to 0-9, 62 to +, and 63 to /.

Result: The plain text "Cat" is encoded as Q2F0 in Base64.

Handling Padding (The Equals Sign)

The example above was clean because the input was exactly 3 bytes long. But what happens if the input data does not divide perfectly by 3? This is where padding comes in.

Scenario 1: One byte left over

Suppose you encode a single letter, "A".

  1. 'A' = 65 = 01000001 (8 bits total)
  2. The algorithm needs groups of 6. So it takes the first 6 bits: 010000 (Value 16 = 'Q').
  3. There are only 2 bits left: 01. To make a full 6-bit chunk, the algorithm adds four zero bits to the right: 010000 (Value 16 = 'Q').
  4. Because the algorithm must output in blocks of 4 characters, it outputs 'QQ', and then appends two equals signs (==) to represent the missing bytes.
  5. Result: QQ==

Scenario 2: Two bytes left over

Suppose you encode two letters, "AB".

  1. 'A' = 01000001, 'B' = 01000010 (16 bits total).
  2. Chunk 1: 010000 (Value 16 = 'Q')
  3. Chunk 2: 010100 (Value 20 = 'U')
  4. Chunk 3 (remaining 4 bits + two zeros): 001000 (Value 8 = 'I')
  5. Because one byte was missing from the standard 3-byte block, one equals sign (=) is appended.
  6. Result: QUI=

Padding is strictly a signal to the decoder indicating how many bytes were absent from the final block. Some modern implementations (like Base64URL in JWTs) strip the padding entirely, as the decoder can mathematically deduce the missing bytes based on the length of the string.

Handling Unicode and Emojis

The examples above used simple ASCII characters, where 1 character equals 1 byte. Modern text, however, is heavily reliant on Unicode (UTF-8). In UTF-8, an emoji or a character from a non-Latin script can consume 2, 3, or even 4 bytes.

If you attempt to feed a 4-byte emoji directly into a legacy Base64 function that expects a 1-byte character mapping, the function will fail. This is why a proper Base64 Encoder must first invoke a TextEncoder to safely parse the complex Unicode string into a flat array of standard 8-bit bytes before applying the grouping algorithms described above.

Conclusion

Base64 encoding is an elegant mathematical solution to data formatting. By manipulating bits at the lowest level, regrouping them from 8-bit bytes to 6-bit chunks, and mapping them to a safe character set, the algorithm guarantees data survival across any network protocol.

If you want to test these algorithms yourself without doing the math by hand, you can use our Online Base64 Encoder.