CodeCraft
← Back to Blog
Encoding2026-04-05·7 min read

Base64 Encoding: What It Is and When to Use It

#base64#encoding#binary#data-uri
C
CodeCraft Team· Engineering

If you've ever inspected an HTTP request, dug into an email header, or embedded an image directly in CSS, you've encountered Base64 encoding. It's one of those foundational technologies that appears everywhere in web development, yet many developers use it without fully understanding what it does, why it exists, or when they should — and shouldn't — use it.

This guide explains Base64 from first principles and covers the real-world scenarios where it matters most.

Why Base64 Exists

Computers process everything as bytes — sequences of 8-bit values from 0 to 255. When early internet protocols (SMTP, HTTP/1.0) were designed, they were text-based and focused on ASCII characters (values 0–127). Binary data like images, audio files, and executables could not be transmitted directly without corruption.

Base64 was created to solve this problem: encode any binary data using only 64 printable ASCII characters. The name "Base64" comes from the 64-character alphabet it uses.

Those 64 characters are: A-Z (26), a-z (26), 0-9 (10), + and / (2) = 64 total. The = character is used for padding.

How Base64 Encoding Works

Base64 works by converting every 3 bytes (24 bits) of binary data into 4 Base64 characters (6 bits each).

Step-by-step example — encoding the string "Man":

1. Convert to ASCII bytes: M=77, a=97, n=110

2. In binary: 01001101 01100001 01101110

3. Group into 6-bit chunks: 010011 010110 000101 101110

4. Convert to decimal: 19, 22, 5, 46

5. Look up in Base64 alphabet: T, W, F, u → TWFu

The resulting string is always 33% larger than the original because 3 bytes → 4 characters (4/3 ratio).

Padding: If the input length isn't divisible by 3, = or == is appended to ensure the output is a multiple of 4 characters. This is why you often see Base64 strings ending with =.

URL-Safe Base64

Standard Base64 uses + and /, which are special characters in URLs. URL-safe Base64 (Base64url) replaces them:

- + → -

- / → _

- Padding (=) is often omitted

You'll find Base64url in JWT tokens, Google Cloud Storage URLs, and many modern web APIs. Never mix up standard Base64 and Base64url — they produce different outputs for the same input.

Common Use Cases

Embedding images in HTML/CSS: Using a data URI (data:image/png;base64,...) you can embed small images directly into HTML without a separate HTTP request. Ideal for tiny icons (< 5KB) but counterproductive for larger images.

Email attachments: The MIME standard uses Base64 to encode binary attachments (images, PDFs, Word documents) so they can be transmitted through text-based email systems.

JWT tokens: The header and payload sections of a JWT are Base64url-encoded (not encrypted). This is why you can decode them without a secret key.

Basic HTTP authentication: The Authorization: Basic header transmits username:password as a Base64-encoded string. Note: this provides no encryption — always use HTTPS.

Storing binary data as text: When a system can only store text (like environment variables or JSON fields), Base64 lets you encode arbitrary binary data (like encryption keys or certificates).

Cryptographic operations: Hashes, HMAC signatures, and public keys are commonly serialized as Base64 strings in configuration files and APIs.

Base64 Is Not Encryption

This is the most important misconception to address. Base64 encoding is completely reversible without any key — anyone can decode it instantly. It provides zero security.

btoa("password123") → "cGFzc3dvcmQxMjM="

Anyone who sees cGFzc3dvcmQxMjM= can decode it back to "password123" in seconds.

Never use Base64 for:

- Storing passwords (use bcrypt, Argon2, or PBKDF2)

- Hiding sensitive data (use AES-256 encryption)

- Security through obscurity

Base64 is about encoding (changing representation), not encryption (protecting confidentiality) or hashing (one-way transformation).

Base64 in JavaScript

Browsers provide two built-in functions:

// Encode
const encoded = btoa("Hello, World!");  // "SGVsbG8sIFdvcmxkIQ=="

// Decode
const decoded = atob("SGVsbG8sIFdvcmxkIQ==");  // "Hello, World!"

Caveat: btoa() and atob() only handle Latin-1 characters. For Unicode strings, encode to UTF-8 bytes first:

// Unicode-safe encode
function b64Encode(str) {
  return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,
    (_, p1) => String.fromCharCode(parseInt(p1, 16))));
}

// Unicode-safe decode
function b64Decode(str) {
  return decodeURIComponent(atob(str).split('').map(
    c => '%' + c.charCodeAt(0).toString(16).padStart(2, '0')
  ).join(''));
}

In Node.js, use Buffer:

Buffer.from("Hello").toString("base64");  // "SGVsbG8="
Buffer.from("SGVsbG8=", "base64").toString("utf8");  // "Hello"

Performance Considerations

Base64-encoded data is 33% larger than the original binary. This overhead matters in several contexts:

Network transfer: A 100KB PNG becomes 133KB when Base64-encoded. For large resources, this overhead adds measurable latency. Use raw binary transfers (multipart/form-data) for files when possible.

CSS/HTML inlining: Inlining images as Base64 data URIs increases HTML/CSS file sizes and prevents the browser from caching the image separately. Only worthwhile for very small images (icon sprites < 2KB).

CPU overhead: Encoding/decoding Base64 is fast in modern environments, but for extremely high-throughput systems (thousands of large payloads per second), it can become a bottleneck.

Base64 is an elegant solution to a specific problem: representing binary data in text-based systems. Understanding that it's an encoding (not encryption), knowing its 33% size overhead, and recognizing where URL-safe Base64 is needed will prevent common bugs and security misunderstandings. Try our free Base64 Encoder/Decoder to encode text and files, or decode any Base64 string, entirely in your browser.