Base64 Kodieren & Dekodieren: Der komplette Leitfaden (2026)

What Is Base64 Encoding?

Base64 is a group of binary-to-text encoding schemes that represent binary data in a printable ASCII string format. The name comes from the fact that the encoding uses a set of 64 characters to represent arbitrary binary sequences. These 64 characters are the uppercase letters A through Z, the lowercase letters a through z, the digits 0 through 9, and two additional symbols: + (plus) and / (slash). A 65th character, = (equals), is used as a padding suffix.

The primary purpose of Base64 encoding is to allow binary data to travel safely through text-based protocols and systems. Email (MIME), HTTP headers, JSON payloads, XML documents, and URL query parameters were all designed to handle text, not raw binary. When you need to embed a JPEG image inside an HTML document, send a PDF through a REST API, or store a cryptographic key in a configuration file, Base64 provides the bridge between binary and text worlds.

Base64 is defined in multiple RFCs. RFC 4648 is the most commonly referenced standard and defines both the standard Base64 alphabet and the URL-safe variant. RFC 2045 defines MIME Base64 used in email attachments. The algorithm itself is straightforward: take three bytes of input (24 bits), split them into four 6-bit groups, and map each group to one of the 64 characters. The result is always 33% larger than the input.

How Base64 Works: The Algorithm Explained

Understanding the inner workings of Base64 helps you debug encoding issues, calculate output sizes, and choose the right variant for your use case. Here is a step-by-step breakdown of how the encoding process transforms binary data into a Base64 string.

Step 1: Convert input to binary

Each byte of input data is represented as 8 bits. For example, the ASCII string Man consists of three bytes: M = 77 (01001101), a = 97 (01100001), n = 110 (01101110).

Step 2: Concatenate all bits

Join the binary representations into a single bit stream: 010011010110000101101110 (24 bits total).

Step 3: Split into 6-bit groups

Divide the stream into groups of 6 bits each: 010011, 010110, 000101, 101110. Each 6-bit group can represent a value from 0 to 63.

Step 4: Map to Base64 characters

Use the Base64 index table to convert each 6-bit value to a character: 19 = T, 22 = W, 5 = F, 46 = u. The result is TWFu.

The Base64 Alphabet Table

Padding with the = Character

Base64 processes input in blocks of 3 bytes (24 bits). When the input length is not a multiple of 3, padding is required. If there is 1 remaining byte (8 bits), the encoder adds two zero bits to make 12 bits, producing 2 Base64 characters followed by ==. If there are 2 remaining bytes (16 bits), the encoder adds four zero bits to make 24 bits, producing 3 Base64 characters followed by =. This is why you often see trailing equals signs in Base64 strings.

Input:     "M"     → 1 byte  → 2 chars + "==" → "TQ=="
Input:     "Ma"    → 2 bytes → 3 chars + "="  → "TWE="
Input:     "Man"   → 3 bytes → 4 chars         → "TWFu"
Input:     "Many"  → 4 bytes → 6 chars + "==" → "TWFueQ=="

Output Size Formula

The encoded output size can be calculated precisely. For n input bytes, the output length (including padding) is 4 * ceil(n / 3) characters. This means Base64 output is always approximately 33% larger than the input. For a 1 MB file, the Base64 representation will be about 1.33 MB.

Base64 Encode and Decode Online

If you need to quickly base64 encode or base64 decode a string without writing any code, use our free Base64 Online Encoder/Decoder. It runs entirely in your browser with no server-side processing, so your data stays private. Features include:

• Instant encoding and decoding as you type
• UTF-8 support for international characters and emoji
• URL-safe Base64 option (replaces + and / with - and _)
• File upload support for encoding binary files
• One-click copy to clipboard

For image-specific conversions, try our Image to Base64 converter which generates ready-to-use data URIs for HTML <img> tags and CSS background-image properties.

Base64 in JavaScript: btoa, atob, Buffer, and TextEncoder

JavaScript provides several ways to encode and decode Base64, depending on whether you are working in a browser environment or Node.js. Here are the main approaches with code examples.

Browser: btoa() and atob()

The global functions btoa() (binary to ASCII) and atob() (ASCII to binary) are available in all modern browsers. They work with ASCII strings only.

// Encode a string to Base64
const encoded = btoa("Hello, World!");
console.log(encoded); // "SGVsbG8sIFdvcmxkIQ=="

// Decode a Base64 string
const decoded = atob("SGVsbG8sIFdvcmxkIQ==");
console.log(decoded); // "Hello, World!"

// WARNING: btoa() fails with non-ASCII characters!
// btoa("Hello, 世界") → throws InvalidCharacterError

Handling Unicode in the Browser

Since btoa() only handles characters in the Latin-1 range (code points 0-255), you need an extra step for Unicode strings. The standard approach uses TextEncoder and TextDecoder:

// Encode Unicode string to Base64
function encodeBase64Unicode(str) {
  const encoder = new TextEncoder();
  const bytes = encoder.encode(str);
  let binary = '';
  bytes.forEach(byte => binary += String.fromCharCode(byte));
  return btoa(binary);
}

// Decode Base64 to Unicode string
function decodeBase64Unicode(base64) {
  const binary = atob(base64);
  const bytes = new Uint8Array(binary.length);
  for (let i = 0; i < binary.length; i++) {
    bytes[i] = binary.charCodeAt(i);
  }
  return new TextDecoder().decode(bytes);
}

// Works with any Unicode:
console.log(encodeBase64Unicode("Hello, 世界"));
// "SGVsbG8sIOS4lueVjA=="

Node.js: Buffer

In Node.js, the Buffer class provides the most straightforward way to handle Base64 encoding and decoding. It supports all character encodings natively.

// Encode to Base64 in Node.js
const encoded = Buffer.from("Hello, World!").toString('base64');
console.log(encoded); // "SGVsbG8sIFdvcmxkIQ=="

// Decode from Base64 in Node.js
const decoded = Buffer.from("SGVsbG8sIFdvcmxkIQ==", 'base64').toString('utf-8');
console.log(decoded); // "Hello, World!"

// Works with Unicode out of the box
const unicodeEncoded = Buffer.from("Hello, 世界").toString('base64');
console.log(unicodeEncoded); // "SGVsbG8sIOS4lueVjA=="

// URL-safe Base64 in Node.js
const urlSafe = Buffer.from("Hello, World!").toString('base64url');
console.log(urlSafe); // "SGVsbG8sIFdvcmxkIQ"

// Encode a file to Base64
const fs = require('fs');
const fileBase64 = fs.readFileSync('image.png').toString('base64');
console.log(`data:image/png;base64,${fileBase64}`);

Modern Browser Alternative: Uint8Array

Starting in 2024, modern browsers support Uint8Array.prototype.toBase64() and Uint8Array.fromBase64() (TC39 proposal, now shipping in Chrome 128+, Firefox 133+, Safari 18.2+):

// Modern browser API (2024+)
const bytes = new TextEncoder().encode("Hello, World!");
const base64 = bytes.toBase64();
console.log(base64); // "SGVsbG8sIFdvcmxkIQ=="

// Decode
const decoded = Uint8Array.fromBase64("SGVsbG8sIFdvcmxkIQ==");
const text = new TextDecoder().decode(decoded);
console.log(text); // "Hello, World!"

// URL-safe variant
const urlSafe = bytes.toBase64({ alphabet: "base64url" });

Base64 in Python

Python includes a base64 module in its standard library that supports multiple encoding variants. Here are the most common operations:

import base64

# Encode a string to Base64
text = "Hello, World!"
encoded = base64.b64encode(text.encode('utf-8'))
print(encoded)  # b'SGVsbG8sIFdvcmxkIQ=='
print(encoded.decode('ascii'))  # "SGVsbG8sIFdvcmxkIQ=="

# Decode a Base64 string
decoded = base64.b64decode("SGVsbG8sIFdvcmxkIQ==")
print(decoded.decode('utf-8'))  # "Hello, World!"

# URL-safe Base64 encoding
url_safe = base64.urlsafe_b64encode(text.encode('utf-8'))
print(url_safe.decode('ascii'))  # "SGVsbG8sIFdvcmxkIQ=="

# URL-safe Base64 decoding
decoded_url = base64.urlsafe_b64decode(url_safe)
print(decoded_url.decode('utf-8'))  # "Hello, World!"

# Encode binary file to Base64
with open("image.png", "rb") as f:
    file_base64 = base64.b64encode(f.read()).decode('ascii')
    print(f"data:image/png;base64,{file_base64[:50]}...")

# Decode Base64 to file
with open("output.png", "wb") as f:
    f.write(base64.b64decode(file_base64))

# Encode with Unicode characters
unicode_text = "Hello, 世界"
unicode_encoded = base64.b64encode(unicode_text.encode('utf-8'))
print(unicode_encoded.decode('ascii'))  # "SGVsbG8sIOS4lueVjA=="

Python base64 Module Variants

Base64 on the Command Line (Linux/macOS)

The base64 command is available by default on Linux and macOS. It is one of the fastest ways to encode and decode Base64 strings and files directly from the terminal. Check our detailed guide on Base64 encode/decode on the command line.

Encoding Strings

# Encode a string (Linux)
echo -n "Hello, World!" | base64
# Output: SGVsbG8sIFdvcmxkIQ==

# Encode a string (macOS)
echo -n "Hello, World!" | base64
# Output: SGVsbG8sIFdvcmxkIQ==

# IMPORTANT: Always use -n flag with echo to avoid
# encoding a trailing newline character!

# Without -n:
echo "Hello" | base64     # SGVsbG8K (includes \n)
# With -n:
echo -n "Hello" | base64  # SGVsbG8= (correct)

Decoding Strings

# Decode on Linux
echo "SGVsbG8sIFdvcmxkIQ==" | base64 -d
# Output: Hello, World!

# Decode on macOS
echo "SGVsbG8sIFdvcmxkIQ==" | base64 -D
# Output: Hello, World!

# Note: macOS uses -D (uppercase) while Linux uses -d (lowercase)

Encoding and Decoding Files

# Encode a file to Base64
base64 image.png > image.b64

# Decode a Base64 file back to binary
base64 -d image.b64 > image_restored.png  # Linux
base64 -D image.b64 > image_restored.png  # macOS

# Encode and pipe to clipboard (macOS)
base64 < image.png | pbcopy

# Encode from stdin using openssl
openssl base64 -in image.png -out image.b64
openssl base64 -d -in image.b64 -out image_restored.png

# Inline in a curl command (HTTP Basic Auth)
curl -H "Authorization: Basic $(echo -n 'user:pass' | base64)" \
  https://api.example.com/data

Base64 URL-Safe Encoding (RFC 4648)

Standard Base64 uses + and / characters which have special meanings in URLs. The + character is interpreted as a space in URL query parameters, and / is a path separator. URL-safe Base64 (also called Base64url) solves this by replacing these characters:

URL-safe Base64 is used extensively in JWTs (JSON Web Tokens), OAuth tokens, file names, and any context where the encoded string must be URL-safe. The JWT standard specifically requires Base64url encoding without padding for all three segments (header, payload, signature).

// JavaScript: Convert between standard and URL-safe Base64
function toBase64Url(base64) {
  return base64
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '');
}

function fromBase64Url(base64url) {
  let base64 = base64url
    .replace(/-/g, '+')
    .replace(/_/g, '/');
  // Add padding
  while (base64.length % 4 !== 0) {
    base64 += '=';
  }
  return base64;
}

// Node.js native support
Buffer.from("Hello!").toString('base64url'); // "SGVsbG8h"
Buffer.from("SGVsbG8h", 'base64url').toString(); // "Hello!"

Common Use Cases for Base64 Encoding

Base64 encoding appears throughout modern web development. Here are the most important use cases every developer should know:

1. Data URIs (Embedding Images in HTML/CSS)

Data URIs allow you to embed small files directly in HTML or CSS without additional HTTP requests. This is particularly useful for small icons, logos, and decorative images. Use our Image to Base64 converter for this.

<!-- HTML: Embed image directly -->
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUg..."
     alt="Small icon" width="16" height="16" />

<!-- CSS: Background image -->
<style>
.icon {
  background-image: url("data:image/svg+xml;base64,PHN2ZyB4bWxu...");
  width: 24px;
  height: 24px;
}
</style>

When to use data URIs: Files under 2-5 KB (the 33% size overhead is offset by eliminating an HTTP request). For larger files, traditional URLs with HTTP/2 multiplexing are more efficient.

2. HTTP Basic Authentication

The HTTP Basic authentication scheme transmits credentials as a Base64-encoded string in the Authorization header. The format is Basic {base64(username:password)}.

// JavaScript
const credentials = btoa('admin:secretpassword');
fetch('https://api.example.com/data', {
  headers: {
    'Authorization': `Basic ${credentials}`
    // "Authorization: Basic YWRtaW46c2VjcmV0cGFzc3dvcmQ="
  }
});

Security warning: Base64-encoded credentials can be instantly decoded by anyone who intercepts the request. Always use HTTPS when sending Basic auth headers.

3. Email Attachments (MIME)

The MIME (Multipurpose Internet Mail Extensions) standard uses Base64 to encode binary attachments in email messages. When you attach a PDF or image to an email, your email client Base64-encodes the file and includes it in the message body with a Content-Transfer-Encoding: base64 header.

4. Kubernetes Secrets

Kubernetes stores secret values as Base64-encoded strings in YAML manifests. This is not for security but to allow binary data in YAML (which is a text format).

apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: YWRtaW4=       # base64("admin")
  password: cDRzc3cwcmQ=   # base64("p4ssw0rd")

5. JSON Payloads with Binary Data

JSON does not support binary data natively. When APIs need to transmit images, documents, or other binary content within a JSON body, Base64 encoding is the standard approach.

{
  "filename": "report.pdf",
  "contentType": "application/pdf",
  "data": "JVBERi0xLjQKJeLjz9MKMSAwIG9iago8PAovVHlwZS..."
}

6. JWT (JSON Web Tokens)

JWTs consist of three Base64url-encoded parts separated by dots: header.payload.signature. The header and payload are JSON objects encoded with URL-safe Base64 (without padding).

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.    ← Base64url(header)
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6Ikpv  ← Base64url(payload)
aG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c  ← Base64url(signature)

Base64 Image Encoding

Converting images to Base64 is one of the most common encoding tasks for frontend developers. Base64-encoded images can be embedded directly in HTML, CSS, JSON APIs, and even database fields. Use our Image to Base64 tool to convert any image format.

// Browser: Convert uploaded image to Base64
const fileInput = document.querySelector('input[type="file"]');
fileInput.addEventListener('change', (event) => {
  const file = event.target.files[0];
  const reader = new FileReader();
  reader.onload = () => {
    const base64String = reader.result;
    // "data:image/png;base64,iVBORw0KGgo..."
    document.querySelector('img').src = base64String;
  };
  reader.readAsDataURL(file);
});

// Node.js: Read image file and create data URI
const fs = require('fs');
const imagePath = './logo.png';
const imageBuffer = fs.readFileSync(imagePath);
const mimeType = 'image/png';
const dataUri = `data:${mimeType};base64,${imageBuffer.toString('base64')}`;
console.log(dataUri);

Image Size Comparison

Performance Considerations: The 33% Size Increase

The biggest downside of Base64 encoding is the inherent 33% size increase. Every 3 bytes of input produce 4 bytes of output. This overhead has real performance implications that developers must consider:

• Bandwidth: A 100 KB image becomes 133 KB when Base64-encoded. Over millions of requests, this adds up to significant additional bandwidth costs.
• Parse time: Browsers must decode Base64 strings before rendering, adding CPU overhead. For large files, this can cause noticeable delays.
• Caching: Base64 images embedded in HTML or CSS cannot be cached independently. If the image changes, the entire document cache is invalidated.
• Memory: The entire Base64 string must be held in memory during decoding. For server-side processing of large files, this can cause memory pressure.
• Bundle size: Base64 images in JavaScript bundles increase download and parse time for the entire application.

Rules of thumb:

• Inline images smaller than 2-4 KB as data URIs (the HTTP request overhead exceeds the Base64 overhead).
• For images over 10 KB, use external URLs and let the browser cache them.
• In APIs, consider streaming binary content or using multipart uploads instead of Base64-encoded JSON.
• Gzip and Brotli compression partially offset the Base64 size increase in HTTP responses (Base64 compresses reasonably well).

Base64 vs Hex vs Binary: Encoding Comparison

Base64 is not the only way to represent binary data as text. Here is how it compares to hexadecimal and raw binary representations:

Example: Encoding the bytes [72, 101, 108, 108, 111]  ("Hello")

Binary (raw):  48 65 6c 6c 6f  (5 bytes)
Hex string:    "48656c6c6f"     (10 characters, +100%)
Base64:        "SGVsbG8="       (8 characters, +60%)

For comparison, encoding 3 bytes [77, 97, 110] ("Man"):
Binary (raw):  4d 61 6e         (3 bytes)
Hex string:    "4d616e"         (6 characters, +100%)
Base64:        "TWFu"           (4 characters, +33%)

Security: Base64 Is NOT Encryption

This is one of the most common misconceptions in software development. Base64 encoding provides absolutely zero security. It is a reversible encoding scheme, not an encryption algorithm. Anyone can decode a Base64 string instantly without any key, password, or secret.

// Demonstration: Base64 is trivially reversible
const secret = btoa("my-api-key-12345");
console.log(secret);  // "bXktYXBpLWtleS0xMjM0NQ=="

// Anyone can decode it:
console.log(atob("bXktYXBpLWtleS0xMjM0NQ=="));
// "my-api-key-12345"  ← Zero security!

// For actual encryption, use the Web Crypto API:
async function encryptData(data, key) {
  const encoder = new TextEncoder();
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const encrypted = await crypto.subtle.encrypt(
    { name: 'AES-GCM', iv },
    key,
    encoder.encode(data)
  );
  return { iv, encrypted };
}

Base64 in Different Programming Languages

Beyond JavaScript and Python, here is how to encode and decode Base64 in other popular languages:

Java

import java.util.Base64;

// Encode
String encoded = Base64.getEncoder()
    .encodeToString("Hello, World!".getBytes("UTF-8"));
// "SGVsbG8sIFdvcmxkIQ=="

// Decode
byte[] decoded = Base64.getDecoder().decode(encoded);
String text = new String(decoded, "UTF-8");
// "Hello, World!"

// URL-safe
String urlSafe = Base64.getUrlEncoder()
    .withoutPadding()
    .encodeToString("Hello, World!".getBytes("UTF-8"));

Go

package main

import (
    "encoding/base64"
    "fmt"
)

func main() {
    // Encode
    encoded := base64.StdEncoding.EncodeToString(
        []byte("Hello, World!"))
    fmt.Println(encoded) // "SGVsbG8sIFdvcmxkIQ=="

    // Decode
    decoded, _ := base64.StdEncoding.DecodeString(encoded)
    fmt.Println(string(decoded)) // "Hello, World!"

    // URL-safe
    urlSafe := base64.URLEncoding.EncodeToString(
        []byte("Hello, World!"))
    fmt.Println(urlSafe)
}

PHP

<?php
// Encode
$encoded = base64_encode("Hello, World!");
echo $encoded; // "SGVsbG8sIFdvcmxkIQ=="

// Decode
$decoded = base64_decode($encoded);
echo $decoded; // "Hello, World!"

// Validate before decoding
if (base64_decode($input, true) !== false) {
    echo "Valid Base64";
}

C# / .NET

using System;
using System.Text;

// Encode
byte[] bytes = Encoding.UTF8.GetBytes("Hello, World!");
string encoded = Convert.ToBase64String(bytes);
// "SGVsbG8sIFdvcmxkIQ=="

// Decode
byte[] decoded = Convert.FromBase64String(encoded);
string text = Encoding.UTF8.GetString(decoded);
// "Hello, World!"

Ruby

require 'base64'

# Encode (strict = no line breaks)
encoded = Base64.strict_encode64("Hello, World!")
# "SGVsbG8sIFdvcmxkIQ=="

# Decode
decoded = Base64.decode64(encoded)
# "Hello, World!"

# URL-safe
url_safe = Base64.urlsafe_encode64("Hello, World!")
decoded_url = Base64.urlsafe_decode64(url_safe)

Troubleshooting Common Base64 Issues

When working with Base64, developers frequently encounter these problems:

1. Invalid Character Errors

The most common cause is whitespace or line breaks in the encoded string. MIME Base64 inserts a newline every 76 characters, but standard decoders may not handle this. Solution: strip all whitespace before decoding.

// Fix: Remove whitespace before decoding
const cleanBase64 = dirtyBase64.replace(/\s/g, '');
const decoded = atob(cleanBase64);

2. Unicode/UTF-8 Encoding Errors

Using btoa() with non-ASCII characters throws InvalidCharacterError. Always encode the string to UTF-8 bytes first (see the Unicode section above).

3. Missing or Incorrect Padding

Some systems strip the trailing = padding. If decoding fails, try adding padding back:

// Fix: Add missing padding
function addPadding(base64) {
  while (base64.length % 4 !== 0) {
    base64 += '=';
  }
  return base64;
}

const decoded = atob(addPadding("SGVsbG8"));

4. Newline Character in Input

Forgetting -n with echo on the command line is extremely common. echo “Hello” | base64 encodes Hello\n (with a newline), giving a different result than echo -n “Hello” | base64.

Frequently Asked Questions

Summary: When to Use Base64

Base64 is a fundamental tool in every developer’s toolkit. Use our free Base64 encoder and decoder online for quick conversions, or our Image to Base64 tool for embedding images. Understanding when and how to use Base64 (and when not to) will help you build more efficient, more secure applications.