Base64 dekodieren Python — b64decode() Guide

Wenn eine API ein content-Feld zurückgibt, das wie eyJob3N0IjogImRiLXByb2Qi… aussieht, oder dein Secrets Manager dir eine kodierte Zugangsdaten übergibt, oder du eine JWT-Nutzlast extrahieren musst – ist Python Base64 Decode deine erste Anlaufstelle. Das eingebaute base64-Modul deckt alles ab, aber die kleinen Details rund um bytes vs. Strings, URL-sichere Alphabete und fehlende Auffüllung erwischen fast jeden Entwickler mindestens einmal – ich habe diese spezielle Fehlerkategorie in Code-Reviews häufiger debuggt, als mir lieb ist. Dieser Leitfaden behandelt base64.b64decode(), urlsafe_b64decode(), automatische Padding-Korrektur, Dekodierung aus Dateien und HTTP-Antworten, CLI-Tools, Eingabevalidierung und vier häufige Fehler mit Vorher/Nachher-Korrekturen – alles lauffähige Python-3.8+-Beispiele. Wenn du nur eine schnelle Einmal-Dekodierung ohne Code benötigst, ToolDecks Base64 Decoder verarbeitet sowohl Standard- als auch URL-sicheres Base64 sofort im Browser.

Was ist Base64-Dekodierung?

Base64 ist ein Kodierungsschema, das beliebige Binärdaten als Zeichenkette aus 64 druckbaren ASCII-Zeichen darstellt: A–Z, a–z, 0–9, + und /, mit = als Auffüllung. Jeweils 4 Base64-Zeichen kodieren genau 3 Originalbytes, sodass die kodierte Form etwa 33 % größer ist als die Quelle. Die Dekodierung kehrt diesen Prozess um – die ASCII-Darstellung wird zurück in die ursprünglichen Bytes umgewandelt.

Base64 verschlüsselt keine Daten. Es ist eine reine Binär-zu-Text-Kodierung – die kodierte Zeichenkette ist für jeden vollständig lesbar, der sie durch einen Decoder laufen lässt:

base64.b64decode() — Dekodierung mit der Standardbibliothek

Pythons base64-Modul wird mit der Standardbibliothek geliefert – keine Installation, immer verfügbar. Die primäre Funktion ist base64.b64decode(s, altchars=None, validate=False). Sie akzeptiert str, bytes oder bytearray und gibt immer bytes zurück.

Minimales funktionsfähiges Beispiel

import base64
import json

# Encoded database config received from a secrets manager
encoded_config = (
    "eyJob3N0IjogImRiLXByb2QubXljb21wYW55LmludGVybmFsIiwgInBvcnQiOiA1NDMyLCAid"
    "XNlciI6ICJhcHBfc3ZjIiwgInBhc3N3b3JkIjogInM0ZmVQYXNzITIwMjYifQ=="
)

# Step 1: decode Base64 bytes
raw_bytes = base64.b64decode(encoded_config)
print(raw_bytes)
# b'{"host": "db-prod.mycompany.internal", "port": 5432, "user": "app_svc", "password": "s4fePass!2026"}'

# Step 2: convert bytes → str
config_str = raw_bytes.decode("utf-8")

# Step 3: parse into a dict
config = json.loads(config_str)
print(config["host"])    # db-prod.mycompany.internal
print(config["port"])    # 5432

Erweitertes Beispiel: sort_keys, ensure_ascii und strenge Validierung

import base64
import binascii

# Token from an internal event bus — validate strictly (external input)
encoded_event = (
    "eyJldmVudCI6ICJvcmRlci5zaGlwcGVkIiwgIm9yZGVyX2lkIjogIk9SRC04ODQ3MiIsICJ"
    "0aW1lc3RhbXAiOiAiMjAyNi0wMy0xM1QxNDozMDowMFoiLCAicmVnaW9uIjogImV1LXdlc3QtMSJ9"
)

try:
    # validate=True raises binascii.Error on any non-Base64 character
    raw = base64.b64decode(encoded_event, validate=True)
    event = raw.decode("utf-8")
    print(event)
    # {"event": "order.shipped", "order_id": "ORD-88472", "timestamp": "2026-03-13T14:30:00Z", "region": "eu-west-1"}

except binascii.Error as exc:
    print(f"Invalid Base64: {exc}")
except UnicodeDecodeError as exc:
    print(f"Not UTF-8 text: {exc}")

URL-sicheres Base64 dekodieren (base64url)

Standard-Base64 verwendet + und /, die in URLs reservierte Zeichen sind. Die URL-sichere Variante (RFC 4648 §5, auch “base64url” genannt) ersetzt sie durch - und _. Dies ist die Kodierung, die in JWT-Tokens, OAuth 2.0 PKCE Challenges, Google Cloud Credentials und den meisten modernen Web-Authentifizierungsabläufen verwendet wird.

URL-sicheres Base64 an b64decode() zu übergeben ohne das Alphabet anzupassen, wird Daten still beschädigen oder binascii.Error auslösen. Verwende stattdessen base64.urlsafe_b64decode() – es übernimmt die Substitution - → + und _ → / automatisch.

import base64
import json

# JWT payload segment (the middle part between the two dots)
# JWTs use URL-safe Base64 without trailing "=" padding
jwt_payload_b64 = (
    "eyJ1c2VyX2lkIjogMjg5MywgInJvbGUiOiAiYWRtaW4iLCAiaXNzIjogImF1dGgubXljb21w"
    "YW55LmNvbSIsICJleHAiOiAxNzQwOTAwMDAwLCAianRpIjogImFiYzEyMzQ1LXh5ei05ODc2In0"
)

# Restore padding before decoding (JWT deliberately omits '=')
padded = jwt_payload_b64 + "=" * (-len(jwt_payload_b64) % 4)

payload_bytes = base64.urlsafe_b64decode(padded)
payload = json.loads(payload_bytes.decode("utf-8"))

print(payload["role"])    # admin
print(payload["iss"])     # auth.mycompany.com
print(payload["user_id"]) # 2893

base64.b64decode() – Parameterreferenz

Alle unten stehenden Parameter gelten für sowohl b64decode() als auch urlsafe_b64decode(), außer altchars, das nur bei b64decode() verfügbar ist.

Der Standard validate=False ist für PEM-formatierte Daten und mehrzeiliges Base64 (wo Zeilenumbrüche üblich sind) beabsichtigt. Für API-Nutzlasten, Benutzer-Uploads oder beliebige nicht vertrauenswürdige Eingaben, übergib validate=True, um beschädigte oder injizierte Daten frühzeitig zu erkennen und einen klaren Fehler auszugeben.

Python Base64 Decode Padding-Fehler – So behebst du ihn

Der häufigste Fehler beim Dekodieren von Base64 in Python ist:

import base64

base64.b64decode("eyJ0eXBlIjogImFjY2VzcyJ9")
# binascii.Error: Incorrect padding

Base64 erfordert Zeichenkettenlängen, die Vielfache von 4 sind. Wenn Daten durch URLs, HTTP-Header oder JWT-Bibliotheken übertragen werden, wird das abschließende =Padding entfernt, um Bytes zu sparen. Es gibt zwei zuverlässige Wege, dies zu beheben.

Option 1: Padding inline wiederherstellen (empfohlen)

import base64
import json

def b64decode_unpadded(data: str | bytes) -> bytes:
    """Decode Base64 with automatic padding correction."""
    if isinstance(data, str):
        data = data.encode("ascii")
    data += b"=" * (-len(data) % 4)
    return base64.b64decode(data)

# Works regardless of how many '=' were stripped
token_a = "eyJ0eXBlIjogImFjY2VzcyJ9"       # 0 chars of padding stripped
token_b = "eyJ0eXBlIjogInJlZnJlc2gifQ"      # 1 char stripped
token_c = "eyJ0eXBlIjogImFwaV9rZXkifQ=="    # already padded

for token in (token_a, token_b, token_c):
    result = json.loads(b64decode_unpadded(token).decode("utf-8"))
    print(result["type"])
# access
# refresh
# api_key

Option 2: URL-sichere Dekodierung mit Padding für OAuth / JWT

import base64
import json

def decode_jwt_segment(segment: str) -> dict:
    """Decode a single JWT segment (header or payload)."""
    # Add padding, use URL-safe alphabet
    padded = segment + "=" * (-len(segment) % 4)
    raw = base64.urlsafe_b64decode(padded)
    return json.loads(raw.decode("utf-8"))

# Google OAuth ID token payload (simplified)
id_token_payload = (
    "eyJzdWIiOiAiMTEwNTY5NDkxMjM0NTY3ODkwMTIiLCAiZW1haWwiOiAic2FyYS5jaGVuQGV4"
    "YW1wbGUuY29tIiwgImhkIjogImV4YW1wbGUuY29tIiwgImlhdCI6IDE3NDA5MDAwMDB9"
)

claims = decode_jwt_segment(id_token_payload)
print(claims["email"])   # sara.chen@example.com
print(claims["hd"])      # example.com

Base64 aus einer Datei und API-Antwort dekodieren

Base64 von der Festplatte lesen und API-Nutzlasten dekodieren sind die zwei häufigsten Produktionsszenarien. Beide erfordern ordentliche Fehlerbehandlung – beschädigtes Padding und unerwartete Binärtypen sind reale Vorkommnisse, keine theoretischen Randfälle.

Eine Base64-Datei lesen und dekodieren

import base64
import json
from pathlib import Path

def decode_attachment(envelope_path: str, output_path: str) -> None:
    """
    Read a JSON envelope with a Base64-encoded attachment,
    decode it, and write the binary output to disk.
    """
    try:
        envelope = json.loads(Path(envelope_path).read_text(encoding="utf-8"))
        encoded_data = envelope["attachment"]["data"]
        file_bytes = base64.b64decode(encoded_data, validate=True)
        Path(output_path).write_bytes(file_bytes)
        print(f"Saved {len(file_bytes):,} bytes → {output_path}")
    except FileNotFoundError:
        print(f"Envelope file not found: {envelope_path}")
    except (KeyError, TypeError):
        print("Unexpected envelope structure — 'attachment.data' missing")
    except base64.binascii.Error as exc:
        print(f"Invalid Base64 content: {exc}")

# Example envelope:
# {"attachment": {"filename": "invoice_2026_03.pdf", "data": "JVBERi0xLjQK..."}}
decode_attachment("order_ORD-88472.json", "invoice_2026_03.pdf")

Base64 aus einer HTTP-API-Antwort dekodieren

import base64
import json
import urllib.request

def fetch_and_decode_secret(vault_url: str, secret_name: str) -> str:
    """
    Retrieve a Base64-encoded secret from an internal vault API
    and return the decoded plaintext value.
    """
    url = f"{vault_url}/v1/secrets/{secret_name}"
    req = urllib.request.Request(url, headers={"X-Vault-Token": "s.internal"})

    try:
        with urllib.request.urlopen(req, timeout=5) as resp:
            body = json.loads(resp.read().decode("utf-8"))
            # Vault returns: {"data": {"value": "<base64>", "encoding": "base64"}}
            encoded = body["data"]["value"]
            return base64.b64decode(encoded).decode("utf-8")

    except urllib.error.URLError as exc:
        raise RuntimeError(f"Vault unreachable: {exc}") from exc
    except (KeyError, UnicodeDecodeError, base64.binascii.Error) as exc:
        raise ValueError(f"Unexpected secret format: {exc}") from exc

# db_pass = fetch_and_decode_secret("https://vault.internal", "db-prod-password")
# print(db_pass)  # s4feP@ss!2026

Base64-Dekodierung über die Befehlszeile

Für schnelle Terminal-Prüfung – einen Token verifizieren, in einen kodierten Konfig-Blob hineinschauen oder API-Ausgaben durch einen Decoder leiten – ist der base64-Befehl unter Linux und macOS verfügbar. Pythons eingebautes -m base64-Modul funktioniert plattformübergreifend einschließlich Windows.

# Decode a Base64 string and print the result (Linux / macOS)
echo "eyJob3N0IjogImRiLXByb2QubXljb21wYW55LmludGVybmFsIn0=" | base64 --decode
# {"host": "db-prod.mycompany.internal"}

# Decode a file, save decoded output
base64 --decode encoded_payload.txt > decoded_output.json

# Python's cross-platform CLI decoder (works on Windows too)
python3 -m base64 -d encoded_payload.txt

# Decode a JWT payload segment inline — strip header/signature first
echo "eyJ1c2VyX2lkIjogMjg5MywgInJvbGUiOiAiYWRtaW4ifQ" | python3 -c "
import sys, base64, json
s = sys.stdin.read().strip()
padded = s + '=' * (-len(s) % 4)
print(json.dumps(json.loads(base64.urlsafe_b64decode(padded)), indent=2))
"

Für explorative Arbeit, bei der das Schreiben einer Shell-Pipeline übertrieben erscheint, füge den String in den Online-Base64-Decoder ein – er erkennt automatisch URL-sichere Eingaben und korrigiert das Padding sofort.

Base64-Eingaben vor dem Dekodieren validieren

Wenn Base64-Daten von Benutzereingaben, einem Webhook oder einer nicht vertrauenswürdigen Drittanbieter-API ankommen, validiere sie vor dem Dekodieren, um klare, verwertbare Fehler zu erhalten statt verwirrender binascii.Error-Tracebacks tief in der Geschäftslogik. Python bietet zwei Ansätze: Ausnahmen abfangen oder vorab mit einem Regex validieren.

import base64
import binascii
import re

# ── Option A: try/except (recommended for most code paths) ──────────────────

def safe_b64decode(data: str) -> bytes | None:
    """Return decoded bytes, or None if the input is not valid Base64."""
    try:
        padded = data + "=" * (-len(data) % 4)
        return base64.b64decode(padded, validate=True)
    except (binascii.Error, ValueError):
        return None

print(safe_b64decode("not-base64!!"))                     # None
print(safe_b64decode("eyJ0eXBlIjogInJlZnJlc2gifQ"))      # b'{"type": "refresh"}'


# ── Option B: regex pre-validation ──────────────────────────────────────────

# Standard Base64 (alphabet: A-Z a-z 0-9 + /)
_STANDARD_RE = re.compile(r"^[A-Za-z0-9+/]*={0,2}$")

# URL-safe Base64 (alphabet: A-Z a-z 0-9 - _)
_URLSAFE_RE = re.compile(r"^[A-Za-z0-9-_]*={0,2}$")

def is_valid_base64(s: str) -> bool:
    """True if s is a syntactically valid standard Base64 string."""
    # Length must be a multiple of 4 for fully padded strings
    stripped = s.rstrip("=")
    padded = stripped + "=" * (-len(stripped) % 4)
    return bool(_STANDARD_RE.match(padded))

print(is_valid_base64("SGVsbG8gV29ybGQ="))   # True
print(is_valid_base64("SGVsbG8gV29ybGQ!"))   # False  (! is not Base64)

Hochperformante Alternative: pybase64

Für die überwiegende Mehrheit der Anwendungsfälle ist Pythons stdlib-base64-Modul vollständig ausreichend. Wenn du Tausende von API-Nutzlasten pro Sekunde verarbeitest, Multi-Megabyte-Binäranlagen in einer engen Schleife dekodierst oder dein Profiler Base64-Operationen als Engpass zeigt – erwäge pybase64. Es ist ein C-Erweiterungs-Wrapper um libbase64 und ist typischerweise 2–5× schneller als die stdlib-Implementierung bei großen Eingaben.

pip install pybase64

import pybase64

# Drop-in replacement — identical API to the stdlib base64 module
encoded_image = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQI12NgAAIABQ..."

image_bytes = pybase64.b64decode(encoded_image, validate=False)
print(f"Decoded {len(image_bytes):,} bytes")

# URL-safe variant — same as base64.urlsafe_b64decode()
token_bytes = pybase64.urlsafe_b64decode("eyJpZCI6IDQ3MX0=")
print(token_bytes)  # b'{"id": 471}'

# Benchmark note: on strings under ~10 KB the function-call overhead dominates
# and the speedup is negligible. Profile before switching.

Die API ist absichtlich identisch zu base64 – tausche den Import aus und nichts anderes ändert sich. Verwende es nur, wenn das Profiling bestätigt, dass Base64 tatsächlich ein Engpass ist, was außerhalb von Hochdurchsatz-Datenpipelines selten vorkommt.

Häufige Fehler

Ich habe diese vier Fehler in Code-Reviews immer wieder gesehen – sie sind besonders häufig bei Entwicklern, die aus Sprachen wie JavaScript oder PHP kommen, wo Base64 Decode direkt einen String zurückgibt, oder aus Tutorials, die die Fehlerbehandlung gänzlich überspringen.

Fehler 1: Vergessen, .decode() auf das Ergebnis aufzurufen

# ❌ b64decode() returns bytes — this crashes downstream
import base64

raw = base64.b64decode("eyJ1c2VyX2lkIjogNDcxLCAicm9sZSI6ICJhZG1pbiJ9")

# TypeError: byte indices must be integers or slices, not str
user_id = raw["user_id"]

# ✅ decode bytes → str, then parse
import base64, json

raw = base64.b64decode("eyJ1c2VyX2lkIjogNDcxLCAicm9sZSI6ICJhZG1pbiJ9")
payload = json.loads(raw.decode("utf-8"))
print(payload["user_id"])  # 471
print(payload["role"])     # admin

Fehler 2: b64decode() auf URL-sicherer Base64-Eingabe verwenden

# ❌ JWT and OAuth tokens use '-' and '_' — not in standard alphabet
import base64

jwt_segment = "eyJ1c2VyX2lkIjogMjg5M30"
# binascii.Error or silently wrong bytes — unpredictable behaviour
base64.b64decode(jwt_segment)

# ✅ use urlsafe_b64decode() for any token with '-' or '_'
import base64, json

jwt_segment = "eyJ1c2VyX2lkIjogMjg5M30"
padded = jwt_segment + "=" * (-len(jwt_segment) % 4)
data = base64.urlsafe_b64decode(padded)
print(json.loads(data.decode("utf-8")))
# {'user_id': 2893}

Fehler 3: Padding bei gekürzten Tokens nicht korrigieren

# ❌ JWTs and most URL-transmitted tokens strip '=' — this crashes
import base64

# Valid JWT payload segment — no padding, as per spec
segment = "eyJ0eXBlIjogImFjY2VzcyIsICJqdGkiOiAiMzgxIn0"
base64.urlsafe_b64decode(segment)
# binascii.Error: Incorrect padding

# ✅ add padding before every urlsafe_b64decode() call
import base64, json

segment = "eyJ0eXBlIjogImFjY2VzcyIsICJqdGkiOiAiMzgxIn0"
padded = segment + "=" * (-len(segment) % 4)
result = json.loads(base64.urlsafe_b64decode(padded).decode("utf-8"))
print(result["type"])  # access
print(result["jti"])   # 381

Fehler 4: .decode("utf-8") auf Binärdaten aufrufen

# ❌ Binary files (PDF, PNG, ZIP) are not UTF-8 text — this crashes
import base64

# Base64-encoded PDF starts with JVBERi... (%PDF-)
pdf_b64 = "JVBERi0xLjQKJeLjz9MKNyAwIG9iago8PC9U..."
pdf_text = base64.b64decode(pdf_b64).decode("utf-8")
# UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe2

# ✅ write binary directly to a file — no .decode() needed
import base64
from pathlib import Path

pdf_b64 = "JVBERi0xLjQKJeLjz9MKNyAwIG9iago8PC9U..."
pdf_bytes = base64.b64decode(pdf_b64)
Path("report_q1_2026.pdf").write_bytes(pdf_bytes)
print(f"Saved {len(pdf_bytes):,} bytes")

Große Base64-Dateien in Python dekodieren

Eine 200-MB-Base64-Datei mit Path.read_text() zu laden und sie in einem Aufruf zu dekodieren, wird den kodierten String, die dekodierten Bytes und alle intermediären Darstellungen gleichzeitig allozieren – was den Speicher auf eingeschränkten Servern oder Lambda-Funktionen leicht erschöpft. Für Dateien größer als ~50–100 MB verwende stattdessen einen chunk-weisen Ansatz.

Chunk-weises Dekodieren auf die Festplatte (kein vollständiges RAM-Laden)

import base64

def decode_large_b64_file(input_path: str, output_path: str, chunk_size: int = 65536) -> None:
    """
    Decode a large Base64 file in chunks to avoid loading the entire encoded
    string into memory. chunk_size must be a multiple of 4 to keep Base64
    block boundaries aligned across reads.
    """
    assert chunk_size % 4 == 0, "chunk_size must be a multiple of 4"

    bytes_written = 0
    with open(input_path, "rb") as src, open(output_path, "wb") as dst:
        while True:
            chunk = src.read(chunk_size)
            if not chunk:
                break
            # Strip whitespace that may appear in wrapped/multiline Base64
            chunk = chunk.strip()
            if chunk:
                dst.write(base64.b64decode(chunk))
                bytes_written += len(chunk)

    print(f"Decoded {bytes_written:,} Base64 bytes → {output_path}")

# Example: decode a 300 MB database snapshot stored as Base64
decode_large_b64_file("snapshot_2026_03_13.b64", "snapshot_2026_03_13.sql.gz")

Base64 mit base64.decodebytes() für PEM / mehrzeilige Daten dekodieren

import base64

# base64.decodebytes() is designed for MIME / PEM Base64 that wraps at 76 chars.
# It silently ignores whitespace and newlines — perfect for certificate files.

with open("server_cert.pem", "rb") as f:
    pem_data = f.read()

# Strip PEM headers if present, then decode
lines = [
    line for line in pem_data.splitlines()
    if not line.startswith(b"-----")
]
raw_cert = base64.decodebytes(b"
".join(lines))
print(f"Certificate DER payload: {len(raw_cert):,} bytes")

Python Base64-Dekodierungsmethoden — Schnellvergleich

Verwende b64decode() als Standard. Wechsle zu urlsafe_b64decode(), sobald du - oder _ in der Eingabe siehst – diese Zeichen sind das unverkennbare Zeichen von URL-sicherem Base64. Greife auf pybase64 nur zurück, nachdem das Profiling einen Engpass bestätigt. Für einmalige Überprüfungen während der Entwicklung verarbeitet ToolDecks Base64 Decoder beide Alphabete und korrigiert das Padding automatisch – ohne Python-Umgebung erforderlich.

Häufig gestellte Fragen

Wie dekodiere ich einen Base64-String in Python in einen normalen String?

Rufe base64.b64decode(encoded) auf, um bytes zu erhalten, dann rufe .decode("utf-8")auf dem Ergebnis auf, um einen Python-str zu erhalten. Die zwei Schritte sind immer getrennt, weil b64decode() nur das Base64-Alphabet umkehrt – es weiß nicht, ob der ursprüngliche Inhalt UTF-8, Latin-1 oder Binär war. Wenn die Daten eine Nicht-UTF-8-Kodierung verwenden, übergib den korrekten Codec-Namen an .decode(), beispielsweise .decode("latin-1").

Warum erhalte ich „Incorrect padding" beim Dekodieren von Base64 in Python?

Base64-Strings müssen ein Vielfaches von 4 Zeichen lang sein. JWTs, OAuth-Tokens und in URLs übertragene Daten entfernen oft das abschließende = Padding. Behebe es, indem du "=" * (-len(s) % 4) vor dem Dekodieren anhängst. Diese Formel fügt genau 0, 1 oder 2 Zeichen nach Bedarf hinzu und ist eine sichere No-op-Operation, wenn der String bereits korrekt aufgefüllt ist.

Was ist der Unterschied zwischen b64decode() und urlsafe_b64decode() in Python?

Beide dekodieren denselben Base64-Algorithmus, aber mit unterschiedlichen Alphabeten für das 62. und 63. Zeichen.b64decode() verwendet + und /; urlsafe_b64decode() verwendet - und _. Die URL-sichere Variante ist in RFC 4648 §5 definiert und wird verwendet, wo Base64 in URLs, HTTP-Headern oder Cookie-Werten ohne Prozent-Kodierung überleben muss. Sie zu vermischen verursacht entweder einen binascii.Error oder still beschädigte Ausgaben.

Wie dekodiere ich ein Base64-kodiertes Bild in Python?

Dekodiere mit base64.b64decode(encoded) zu bytes, dann schreibe diese bytes direkt in eine Datei – rufe nicht .decode("utf-8") auf Bilddaten auf. Wenn die Eingabe eine Daten-URL ist (z.B. data:image/png;base64,iVBORw0KGgo…), entferne zuerst das Präfix:

import base64
from pathlib import Path

# Data URL from an <img src="..."> or an API response
data_url = (
    "data:image/png;base64,"
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQI12NgAAIABQ=="
)

# Split off the "data:image/png;base64," prefix
_, encoded = data_url.split(",", 1)
image_bytes = base64.b64decode(encoded)
Path("avatar_lbauer.png").write_bytes(image_bytes)
print(f"Saved {len(image_bytes)} bytes")

Kann ich Base64 in Python ohne Import eines Moduls dekodieren?

Technisch ja, aber es gibt keinen Grund dafür. Das base64-Modul ist Teil von Pythons Standardbibliothek, immer verfügbar, immer installiert – es hat keine Abhängigkeiten und seine Funktionen sind in C implementiert. Base64 von Grund auf neu zu implementieren wäre langsamer, fehleranfälliger und schwieriger zu warten. Verwende immer import base64.

Wie dekodiere ich Base64 in Python, wenn die Eingabe bytes und kein String ist?

base64.b64decode() akzeptiert str, bytes und bytearray austauschbar – keine Konvertierung erforderlich. Wenn du b"SGVsbG8=" von einem Socket oder Datei-Lesvorgang erhältst, übergib es direkt. Die Padding-Korrektur funktioniert genauso mit bytes: data + b"=" * (-len(data) % 4) im bytes-Modus.

Verwandte Tools

• Base64 Encode — kodiere Text oder Binärdateien sofort zu Base64; nützlich zum Erstellen von Test-Fixtures für deinen Python-Dekodierungscode ohne ein Skript auszuführen.
• JWT Decoder — JWT-Header und -Nutzlast ohne Code-Schreiben inspizieren; die Nutzlast wird mit URL-sicherem Base64 unter der Haube dekodiert, genau wie in den obigen Beispielen gezeigt.
• URL Decode — Query-Strings und Pfadsegmente prozent-dekodieren; oft neben der Base64-Dekodierung beim Parsen von OAuth-Callback-URLs oder Webhook-Nutzlasten benötigt.
• URL Encode — Sonderzeichen prozent-kodieren; praktisch, wenn du einen Base64-kodierten Wert sicher in einem URL-Query-Parameter einbetten musst.