Base64 Decode Python — b64decode() Guide

Wanneer een API een content-veld teruggeeft dat eruitziet als eyJob3N0IjogImRiLXByb2Qi…, of je secrets manager je een gecodeerde credential overhandigt, of je een JWT-payload moet extraheren — is Python base64 decode je eerste stap. De ingebouwde base64-module verwerkt dit alles, maar de kleine details rondom bytes vs. strings, URL-veilige alfabetten en ontbrekende padding treffen bijna elke ontwikkelaar minstens één keer — ik heb deze specifieke categorie fouten in code reviews meer keren gedebugd dan ik zou willen toegeven. Deze gids behandelt base64.b64decode(), urlsafe_b64decode(), automatische padding-reparatie, decoderen vanuit bestanden en HTTP-reacties, CLI-tools, invoervalidatie en vier veelgemaakte fouten met voor/na-fixes — allemaal uitvoerbare Python 3.8+-voorbeelden. Als je alleen een snelle eenmalige decode nodig hebt zonder code te schrijven, ToolDeck's Base64 Decoder verwerkt zowel standaard als URL-veilige Base64 direct in je browser.

Wat is Base64-decodering?

Base64 is een coderingsschema dat willekeurige binaire gegevens weergeeft als een reeks van 64 afdrukbare ASCII-tekens: A–Z, a–z, 0–9, + en /, met = als opvulling. Elke 4 Base64-tekens coderen precies 3 originele bytes, dus de gecodeerde vorm is ongeveer 33% groter dan de bron. Decoderen keert het proces om — de ASCII-representatie wordt teruggetransformeerd naar de originele bytes.

Base64 versleutelt geen gegevens. Het is puur een binair-naar-tekst-codering — de gecodeerde string is volledig leesbaar voor iedereen die het door een decoder haalt:

base64.b64decode() — Decodering met de standaardbibliotheek

Python's base64-module wordt meegeleverd met de standaardbibliotheek — geen installatie, altijd beschikbaar. De primaire functie is base64.b64decode(s, altchars=None, validate=False). Het accepteert een str, bytes of bytearray, en geeft altijd bytes terug.

Minimaal werkend voorbeeld

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

Uitgebreid voorbeeld: sort_keys, ensure_ascii en strikte validatie

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-veilige Base64 decoderen (base64url)

Standaard Base64 gebruikt + en /, wat gereserveerde tekens zijn in URL's. De URL-veilige variant (RFC 4648 §5, ook wel “base64url” genoemd) vervangt ze door - en _. Dit is de codering die wordt gebruikt in JWT-tokens, OAuth 2.0 PKCE-uitdagingen, Google Cloud-credentials en de meeste moderne webauthenticatiestromen.

URL-veilige Base64 doorgeven aan b64decode() zonder het alfabet aan te passen zal gegevens stilzwijgend beschadigen of binascii.Error genereren. Gebruik in plaats daarvan base64.urlsafe_b64decode() — het verwerkt de substitutie - → + en _ → / 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() — Parameterreferentie

Alle onderstaande parameters gelden voor zowel b64decode() als urlsafe_b64decode(), behalve altchars dat alleen beschikbaar is bij b64decode().

De standaardwaarde validate=False is opzettelijk voor PEM-geformatteerde gegevens en meerdere-regelige Base64 (waar nieuwe regels gebruikelijk zijn). Voor API-payloads, gebruikersupload of onbetrouwbare invoer, geef validate=True door om beschadigde of geïnjecteerde gegevens vroeg op te vangen en een duidelijke fout te tonen.

Python Base64 Decode Padding-fout — Hoe op te lossen

De meest voorkomende fout bij het decoderen van Base64 in Python is:

import base64

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

Base64 vereist stringlEngels die veelvouden van 4 zijn. Wanneer gegevens door URL's, HTTP-headers of JWT-bibliotheken gaan, wordt de afsluitende =opvulling verwijderd om bytes te besparen. Er zijn twee betrouwbare manieren om dit op te lossen.

Optie 1: Padding inline herstellen (aanbevolen)

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

Optie 2: URL-veilige decode met padding voor 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 decoderen vanuit een bestand en API-reactie

Base64 lezen van schijf en API-payloads decoderen zijn de twee meest voorkomende productiescenario's. Beide vereisen goede foutafhandeling — beschadigde padding en onverwachte binaire typen zijn reële gevallen, geen theoretische randgevallen.

Een Base64-bestand lezen en decoderen

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 decoderen vanuit een HTTP API-reactie

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-decodering via de opdrachtregel

Voor snelle terminalinspectie — een token verifiëren, in een gecodeerde config-blob kijken, of API-uitvoer door een decoder leiden — is de base64-opdracht beschikbaar op Linux en macOS. Python's ingebouwde -m base64-module werkt platformoverschrijdend inclusief 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))
"

Voor verkennend werk waarbij het schrijven van een shell-pipeline overdreven voelt, plak de string in de online Base64 Decoder — die detecteert automatisch URL-veilige invoer en repareert padding direct.

Base64-invoer valideren voor decodering

Wanneer Base64-gegevens aankomen van gebruikersinvoer, een webhook of een onbetrouwbare derde partij API, valideer het voor decodering om duidelijke, bruikbare fouten te tonen in plaats van verwarrende binascii.Error-tracebacks diep in bedrijfslogica. Python biedt twee benaderingen: uitzonderingen opvangen of vooraf valideren met een regex.

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)

Krachtig alternatief: pybase64

Voor de overgrote meerderheid van gebruikssituaties is Python's stdlib base64-module volledig toereikend. Als je duizenden API-payloads per seconde verwerkt, multi-megabyte binaire bijlagen in een strakke lus decodeert, of je profiler Base64-bewerkingen als knelpunt aanwijst — overweeg dan pybase64. Het is een C-extensiewrapper rond libbase64 en is typisch 2–5× sneller dan de stdlib-implementatie bij grote invoer.

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.

De API is bewust identiek aan base64 — wissel de import uit en niets anders verandert. Gebruik het alleen wanneer profilering bevestigt dat Base64 daadwerkelijk een knelpunt is, wat ongebruikelijk is buiten doorvoerpijplijnen met hoge belasting.

Veelgemaakte fouten

Ik heb deze vier fouten herhaaldelijk gezien in code reviews — ze komen bijzonder vaak voor bij ontwikkelaars die komen van talen zoals JavaScript of PHP waar Base64 decode direct een string teruggeeft, of van tutorials die foutafhandeling volledig overslaan.

Fout 1: Vergeten .decode() aan te roepen op het resultaat

# ❌ 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

Fout 2: b64decode() gebruiken op URL-veilige Base64-invoer

# ❌ 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}

Fout 3: Padding niet herstellen bij afgekapte tokens

# ❌ 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

Fout 4: .decode("utf-8") aanroepen op binaire gegevens

# ❌ 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")

Grote Base64-bestanden decoderen in Python

Een 200 MB Base64-bestand laden met Path.read_text() en het in één aanroep decoderen zal de gecodeerde string, de gedecodeerde bytes en tussenliggende representaties tegelijkertijd alloceren — wat geheugen gemakkelijk uitput op beperkte servers of Lambda-functies. Gebruik voor bestanden groter dan ~50–100 MB in plaats daarvan een chunk-gebaseerde aanpak.

Chunk-gebaseerd decoderen naar schijf (geen volledig 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 decoderen met base64.decodebytes() voor PEM / meerdere-regelige gegevens

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-decodeermethoden — Snelle vergelijking

Gebruik b64decode() als standaard. Schakel over naar urlsafe_b64decode()zodra je - of _ in de invoer ziet — die tekens zijn het onmiskenbare teken van URL-veilige Base64. Grijp naar pybase64 alleen nadat profilering een knelpunt bevestigt. Voor eenmalige controles tijdens ontwikkeling verwerkt ToolDeck's Base64 Decoder beide alphabeten en repareert padding automatisch — geen Python-omgeving vereist.

Veelgestelde vragen

Hoe decodeer ik een Base64-string naar een gewone string in Python?

Roep base64.b64decode(encoded) aan om bytes te krijgen, roep vervolgens .decode("utf-8")aan op het resultaat om een Python-str te krijgen. De twee stappen zijn altijd gescheiden omdat b64decode() alleen het Base64-alfabet omkeert — het weet niet of de originele inhoud UTF-8, Latin-1 of binair was. Als de gegevens een niet-UTF-8-codering gebruiken, geef de juiste codec-naam door aan .decode(), bijvoorbeeld .decode("latin-1").

Waarom krijg ik “Incorrect padding” bij het decoderen van Base64 in Python?

Base64-strings moeten een veelvoud van 4 tekens lang zijn. JWT's, OAuth-tokens en gegevens verzonden in URL's verwijderen vaak de afsluitende = opvulling. Los dit op door "=" * (-len(s) % 4) toe te voegen voor decodering. Deze formule voegt precies 0, 1 of 2 tekens toe zoals nodig, en is een veilige no-op wanneer de string al correct is gevuld.

Wat is het verschil tussen b64decode() en urlsafe_b64decode() in Python?

Beide decoderen hetzelfde Base64-algoritme maar met verschillende alfabetten voor het 62e en 63e teken.b64decode() gebruikt + en /; urlsafe_b64decode() gebruikt - en _. De URL-veilige variant is gedefinieerd in RFC 4648 §5 en wordt gebruikt waar Base64 moet overleven in URL's, HTTP-headers of cookie-waarden zonder procentcodering. Ze door elkaar halen veroorzaakt ofwel een binascii.Error of stilzwijgend beschadigde uitvoer.

Hoe decodeer ik een Base64-gecodeerde afbeelding in Python?

Decodeer naar bytes met base64.b64decode(encoded), schrijf die bytes dan direct naar een bestand — roep niet .decode("utf-8") aan op afbeeldingsgegevens. Als de invoer een data-URL is (bijv. data:image/png;base64,iVBORw0KGgo…), verwijder het voorvoegsel eerst:

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_tdevries.png").write_bytes(image_bytes)
print(f"Saved {len(image_bytes)} bytes")

Kan ik Base64 in Python decoderen zonder een module te importeren?

Technisch gezien ja, maar er is geen reden voor. De base64-module maakt deel uit van Python's standaardbibliotheek, altijd beschikbaar, altijd geïnstalleerd — het heeft geen afhankelijkheden en zijn functies zijn geïmplementeerd in C. Base64 helemaal opnieuw implementeren zou langzamer, foutgevoeliger en moeilijker te onderhouden zijn. Gebruik altijd import base64.

Hoe decodeer ik Base64 in Python als de invoer bytes is, geen string?

base64.b64decode() accepteert str, bytes en bytearray uitwisselbaar — geen conversie vereist. Als je b"SGVsbG8=" ontvangt van een socket of bestandslees, geef het dan direct door. Padding-reparatie werkt op dezelfde manier met bytes: data + b"=" * (-len(data) % 4) in bytes-modus.

Gerelateerde tools

• Base64 Encode — codeer tekst of binaire bestanden direct naar Base64; handig voor het genereren van testfixtures voor je Python-decoderingscode zonder een script uit te voeren.
• JWT Decoder — inspecteer JWT-header en -payload zonder code te schrijven; de payload wordt gedecodeerd met URL-veilige Base64 onder de motorkap, precies zoals getoond in de voorbeelden hierboven.
• URL Decode — procentdecodeer query-strings en padsegmenten; vaak naast Base64-decodering nodig bij het verwerken van OAuth-callback-URL's of webhook-payloads.
• URL Encode — procentcodeer speciale tekens; handig wanneer je een Base64-gecodeerde waarde veilig moet insluiten in een URL-queryparameter.