Sie haben Base64-Strings wahrscheinlich überall in Ihrer Codebasis gesehen — in JWT-Tokens, HTML <img>-Tags, HTTP-Authorization-Headern oder JSON-Payloads mit Dateidaten. Sie sehen aus wie Kauderwelsch: SGVsbG8sIFdvcmxkIQ==. Aber es gibt einen nachvollziehbaren Grund, warum sie existieren, und sobald Sie ihn verstehen, hört Base64 auf, mysteriös zu sein, und wird zu einem echten nützlichen Werkzeug in Ihrem Repertoire.

Was Base64 wirklich ist

Base64 ist ein Binär-zu-Text-Kodierungsschema. Das ist alles. Es nimmt beliebige Binärdaten — Bytes, die Null-Zeichen, Steuercodes oder beliebige Werte von 0 bis 255 enthalten können — und repräsentiert sie mit nur 64 druckbaren ASCII-Zeichen. Das Ergebnis ist eine Zeichenkette, die sicher durch jeden textbasierten Kanal übertragen werden kann, ohne beschädigt oder falsch interpretiert zu werden.

Die formale Spezifikation befindet sich in RFC 4648, veröffentlicht von der IETF. Sie definiert sowohl Standard-Base64 als auch die URL-sichere Variante. Es lohnt sich, diese zu bookmarken, wenn Sie jemals eine Diskussion über Auffüllregeln oder Alphabetauswahl klären müssen.

Das Base64-Alphabet

Das 64-Zeichen-Alphabet besteht aus: Großbuchstaben A–Z (26 Zeichen), Kleinbuchstaben a–z (26 Zeichen), Ziffern 0–9 (10 Zeichen), und zwei Symbolen: + und /. Das ergibt genau 64 Zeichen — daher der Name. Das =-Zeichen wird als Auffüllzeichen am Ende verwendet, wenn die Eingabelänge kein Vielfaches von 3 ist.

text
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

Jedes Zeichen kodiert genau 6 Bits Daten (2^6 = 64 mögliche Werte). Das ist der Kern- mechanismus der Kodierung — und der Grund für den ~33%-Größen-Overhead.

Wie die Kodierung funktioniert

Der Algorithmus arbeitet in Blöcken von 3 Bytes → 4 Base64-Zeichen. Drei Bytes = 24 Bits. Diese 24 Bits werden in vier 6-Bit-Gruppen aufgeteilt, und jede Gruppe wird einem Zeichen im Base64-Alphabet zugeordnet.

text
Input:  "Man"
Bytes:  M=77 (01001101)  a=97 (01100001)  n=110 (01101110)
Bits:   010011 010110 000101 101110
Index:  19     22     5      46
Output: T      W      F      u     →  "TWFu"

Wenn die Eingabe nicht durch 3 teilbar ist, kommt Auffüllen ins Spiel. Zwei verbleibende Bytes werden zu drei Base64-Zeichen plus einem =. Ein verbleibendes Byte wird zu zwei Base64-Zeichen plus ==. Das Auffüllen teilt dem Decoder nur mit, wie viele Bytes tatsächlich am Ende vorhanden sind — es ist kein Teil der eigentlichen Daten.

Der Größen-Overhead: Jede 3 Bytes Eingabe werden zu 4 Ausgabezeichen. Das ist eine 33%ige Größenzunahme. Bei kleinen Strings ist das vernachlässigbar. Bei großen Binärdateien — ein 10-MB-Bild wird zu ungefähr 13,3 MB Base64 — ist der Overhead relevant, und Sie sollten zweimal überlegen, bevor Sie direkt einbetten.

Kodieren und Dekodieren in JavaScript

Browser stellen btoa() und atob() als globale Funktionen bereit. Sie sind einfach, haben aber einen Haken: Sie verarbeiten nur Latin-1-Zeichen (Byte-Werte 0–255). Übergeben Sie direkt einen mehrbytigen Unicode-String, erhalten Sie einen InvalidCharacterError.

js
// Basic browser encoding/decoding
const encoded = btoa('Hello, World!');  // "SGVsbG8sIFdvcmxkIQ=="
const decoded = atob('SGVsbG8sIFdvcmxkIQ==');  // "Hello, World!"

// Safe Unicode version — encode to UTF-8 first
function encodeUnicode(str) {
  return btoa(
    encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (_, hex) =>
      String.fromCharCode(parseInt(hex, 16))
    )
  );
}

function decodeUnicode(str) {
  return decodeURIComponent(
    atob(str)
      .split('')
      .map(c => '%' + c.charCodeAt(0).toString(16).padStart(2, '0'))
      .join('')
  );
}

const emoji = encodeUnicode('Héllo wörld 🌍');
console.log(emoji);                  // "SMOpbGxvIHfDtnJsZCDwn4yN"
console.log(decodeUnicode(emoji));   // "Héllo wörld 🌍"

Node.js — Buffer verwenden

In Node.js ist der idiomatische Ansatz die Buffer-API, die Unicode von Haus aus korrekt verarbeitet und viel sauberer ist als der obige Browser-Workaround.

js
// Encoding
const encoded = Buffer.from('Hello, World!', 'utf8').toString('base64');
console.log(encoded);  // "SGVsbG8sIFdvcmxkIQ=="

// Decoding
const decoded = Buffer.from('SGVsbG8sIFdvcmxkIQ==', 'base64').toString('utf8');
console.log(decoded);  // "Hello, World!"

// Encoding a file to Base64 (e.g. to embed in a JSON payload)
const fs = require('fs');

function fileToBase64(filePath) {
  const fileBuffer = fs.readFileSync(filePath);
  return fileBuffer.toString('base64');
}

function base64ToFile(base64String, outputPath) {
  const fileBuffer = Buffer.from(base64String, 'base64');
  fs.writeFileSync(outputPath, fileBuffer);
}

const avatarBase64 = fileToBase64('./uploads/avatar.png');
const payload = {
  userId: 'usr_8f3k2',
  avatarData: avatarBase64,
  mimeType: 'image/png'
};

Python — Das base64-Modul

Die Python-Standardbibliothek enthält ein base64-Modul, das Kodierung, Dekodierung und die URL-sichere Variante verarbeitet. Die Funktionen arbeiten mit Bytes-Objekten, daher kodieren/dekodieren Sie Strings typischerweise mit einem expliziten Zeichensatz.

python
import base64

# Encoding a string
message = "Hello, World!"
encoded = base64.b64encode(message.encode("utf-8"))
print(encoded)           # b'SGVsbG8sIFdvcmxkIQ=='
print(encoded.decode())  # 'SGVsbG8sIFdvcmxkIQ=='

# Decoding
decoded_bytes = base64.b64decode("SGVsbG8sIFdvcmxkIQ==")
print(decoded_bytes.decode("utf-8"))  # 'Hello, World!'

# Encoding a file
with open("report.pdf", "rb") as f:
    pdf_base64 = base64.b64encode(f.read()).decode("utf-8")

# Embedding it in a JSON-compatible structure
import json
payload = {
    "filename": "report.pdf",
    "content": pdf_base64,
    "encoding": "base64"
}
print(json.dumps(payload, indent=2))

URL-sicheres Base64

Standard-Base64 verwendet + und /, die Sonderzeichen in URLs sind. Fügen Sie einen Standard-Base64-String in einen Query-Parameter ein und Sie erhalten eine stille Beschädigung, es sei denn, Sie Prozent-kodieren ihn zuerst. URL-sicheres Base64 (auch definiert in RFC 4648 §5) löst dies, indem + durch - und / durch _ ersetzt wird. Füll-=-Zeichen werden in URL-Kontexten oft komplett weggelassen.

js
// Standard → URL-safe conversion in JavaScript
function toBase64Url(base64) {
  return base64
    .replace(/+/g, '-')
    .replace(///g, '_')
    .replace(/=+$/, '');  // strip padding
}

function fromBase64Url(base64url) {
  // Restore padding
  const padded = base64url + '=='.slice(0, (4 - (base64url.length % 4)) % 4);
  return padded.replace(/-/g, '+').replace(/_/g, '/');
}

const standard = btoa('some binary  data');
const urlSafe  = toBase64Url(standard);

console.log(standard);  // "c29tZSBiaW5hcnkAAGRhdGE="
console.log(urlSafe);   // "c29tZSBiaW5hcnkAAGRhdGE"  (safe for URLs)

In Python verwenden Sie base64.urlsafe_b64encode() und base64.urlsafe_b64decode() — diese führen die Substitution automatisch durch.

Häufige reale Anwendungsfälle

  • Bilder in HTML/CSS einbetten — ein data:-URI wie src="data:image/png;base64,iVBORw0KGgo..." eliminiert eine separate HTTP-Anfrage. Hervorragend für kleine Icons und Sprites; nicht geeignet für große Bilder aufgrund des 33%-Größen-Overheads.
  • JWT-Tokens — die Header- und Payload-Abschnitte eines JSON Web Tokens sind URL-sicher Base64-kodierte JSON-Objekte. Die drei punktgetrennten Teile, die Sie in einem JWT sehen, sind Base64Url(Header).Base64Url(Payload).Base64Url(Signatur).
  • HTTP-Basisauthentifizierung — der Authorization: Basic ...-Header kodiert Benutzername:Passwort als Base64. Definiert in RFC 7617. Hinweis: Das ist Kodierung, keine Verschlüsselung — verwenden Sie immer HTTPS.
  • Binärdaten in JSON einbetten — JSON hat keinen Binärtyp, daher werden Dateien, Bilder und Zertifikate, die über APIs gesendet werden, typischerweise Base64-kodiert in ein Zeichenfolge-Feld. Für diesen Workflow verwenden Sie die Tools Datei zu Base64 und Bild zu Base64.
  • E-Mail-Anhänge — MIME (das Format, das E-Mails zugrunde liegt) verwendet Base64, um Binäranlagen zu kodieren, damit sie die Übertragung durch nur-Text-Mail-Relay-Server überstehen. Das ursprüngliche Problem, für das Base64 konzipiert wurde.
  • Binärdaten in Datenbanken speichern — wenn Sie ein kleines Blob (ein Zertifikat, ein Thumbnail) in einer Textspalte oder innerhalb eines JSON-Dokuments speichern müssen, ist Base64 die Standardwahl.

Base64 ist KEINE Verschlüsselung

Das verwirrt Menschen ständig — besonders beim Code-Review. Base64 ist Kodierung, keine Verschlüsselung. Kodierung ist eine umkehrbare Transformation, die die Darstellung von Daten ändert. Verschlüsselung scrambled Daten mit einem geheimen Schlüssel, sodass nur jemand mit dem Schlüssel sie rückgängig machen kann.

Jeder kann einen Base64-String in Sekunden dekodieren — fügen Sie ihn in den Base64-Decoder ein und fertig. Verwenden Sie Base64 niemals, um sensible Werte wie Passwörter, API-Schlüssel oder persönliche Daten zu "verstecken". Wenn Sie Vertraulichkeit benötigen, verwenden Sie echte Verschlüsselung (AES, RSA oder eine Bibliothek wie die Web Crypto API im Browser oder cryptography in Python).

Auch erwähnenswert: Base64 ist keine Komprimierung. Die Ausgabe ist immer größer als die Eingabe — um etwa ein Drittel. Wenn Sie die Größe reduzieren müssen, komprimieren Sie zuerst (gzip, Brotli, zstd) und Base64-kodieren Sie dann die komprimierten Bytes, wenn der Kanal Text erfordert.

Tools für die Arbeit mit Base64

Wenn Sie täglich mit Base64 arbeiten, machen schnelle Tools einen echten Unterschied. Verwenden Sie den Base64-Encoder, um beliebige Textstrings zu kodieren, den Base64-Decoder, um Base64-Werte zu dekodieren und zu untersuchen, Datei zu Base64, um Binärdateien für API-Payloads oder Speicher zu konvertieren, und Bild zu Base64, um Daten-URIs zu generieren, mit denen Bilder direkt in HTML oder CSS eingebettet werden können.

Zusammenfassung

Base64 existiert, um ein spezifisches Problem zu lösen: Binärdaten durch reine Textkanäle zu übertragen, ohne Beschädigung. Es tut dies, indem es jede 3 Bytes Eingabe auf 4 druckbare ASCII-Zeichen abbildet, unter Verwendung eines Alphabets von 64 Zeichen (A–Z, a–z, 0–9, +, /). Das Ergebnis ist sicher für E-Mail, HTTP-Header, JSON-Felder und URLs (mit der URL-sicheren Variante). Der Kompromiss ist eine feste 33%ige Größenzunahme. Es ist keine Verschlüsselung, keine Komprimierung — es ist eine transparente, umkehrbare Kodierung. Sobald Sie das verinnerlicht haben, wissen Sie sofort, wann Sie es einsetzen sollten und wann ein anderes Werkzeug besser geeignet ist.

← All Base64 articles Browse all categories →