Base64 Decode Python — Guide b64decode()

Lorsqu'une API renvoie un champ content qui ressemble à eyJob3N0IjogImRiLXByb2Qi…, ou que votre gestionnaire de secrets vous remet une accréditation encodée, ou que vous devez extraire un payload JWT — le décodage Base64 en Python est votre premier réflexe. Le module intégré base64 gère tout cela, mais les petits détails sur les bytes vs les chaînes, les alphabets sécurisés pour les URLs et le padding manquant piègent presque tous les développeurs au moins une fois — j'ai débogué cette catégorie spécifique d'erreurs lors de revues de code plus de fois que je ne voudrais l'admettre. Ce guide couvre base64.b64decode(), urlsafe_b64decode(), la réparation automatique du padding, le décodage depuis des fichiers et des réponses HTTP, les outils CLI, la validation des entrées et quatre erreurs courantes avec des corrections avant/après — tous des exemples exécutables en Python 3.8+. Si vous avez juste besoin d'un décodage rapide sans écrire du code, le Décodeur Base64 de ToolDeck gère à la fois le Base64 standard et sécurisé pour les URLs instantanément dans votre navigateur.

Qu'est-ce que le décodage Base64 ?

Base64 est un schéma d'encodage qui représente des données binaires arbitraires sous forme d'une chaîne de 64 caractères ASCII imprimables : A–Z, a–z, 0–9, + et /, avec = utilisé comme padding. Chaque 4 caractères Base64 encodent exactement 3 octets originaux, de sorte que la forme encodée est environ 33 % plus grande que la source. Le décodage inverse le processus — transformant la représentation ASCII en les octets originaux.

Base64 ne chiffre pas les données. C'est purement un encodage binaire-vers-texte — la chaîne encodée est entièrement lisible par quiconque la passe dans un décodeur :

base64.b64decode() — Décodage avec la bibliothèque standard

Le module base64 de Python est livré avec la bibliothèque standard — zéro installation, toujours disponible. La fonction principale est base64.b64decode(s, altchars=None, validate=False). Elle accepte str, bytes ou bytearray, et retourne toujours bytes.

Exemple minimal fonctionnel

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

Exemple étendu : sort_keys, ensure_ascii et validation stricte

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}")

Décodage du Base64 sécurisé pour les URLs (base64url)

Le Base64 standard utilise + et /, qui sont des caractères réservés dans les URLs. La variante sécurisée pour les URLs (RFC 4648 §5, également appelée “base64url”) les remplace par - et _. C'est l'encodage utilisé dans les tokens JWT, les défis PKCE OAuth 2.0, les identifiants Google Cloud et la plupart des flux d'authentification web modernes.

Passer du Base64 sécurisé pour les URLs à b64decode() sans ajuster l'alphabet corrompra les données silencieusement ou lèvera binascii.Error. Utilisez base64.urlsafe_b64decode() à la place — il gère la substitution - → +et _ → / automatiquement.

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

Référence des paramètres de base64.b64decode()

Tous les paramètres ci-dessous s'appliquent à la fois à b64decode() et à urlsafe_b64decode(), sauf altchars qui n'est disponible que sur b64decode().

La valeur par défaut validate=False est intentionnelle pour les données au format PEM et le Base64 multiligne (où les sauts de ligne sont courants). Pour les payloads d'API, les uploads d'utilisateurs ou toute entrée non fiable, passez validate=True pour détecter les données corrompues ou injectées tôt et afficher une erreur claire.

Erreur de padding lors du décodage Base64 en Python — Comment la corriger

L'erreur la plus fréquente lors du décodage Base64 en Python est :

import base64

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

Base64 exige des longueurs de chaîne qui soient des multiples de 4. Lorsque les données transitent par des URLs, des en-têtes HTTP ou des bibliothèques JWT, le padding =final est supprimé pour économiser des octets. Il existe deux méthodes fiables pour corriger cela.

Option 1 : Restaurer le padding inline (recommandé)

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 : Décodage sécurisé pour les URLs avec padding pour 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

Décoder du Base64 depuis un fichier et une réponse d'API

Lire du Base64 depuis le disque et décoder des payloads d'API sont les deux scénarios de production les plus courants. Les deux nécessitent une gestion appropriée des erreurs — un padding corrompu et des types binaires inattendus sont des occurrences réelles, pas des cas limites théoriques.

Lecture et décodage d'un fichier Base64

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

Décodage du Base64 depuis une réponse HTTP d'API

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

Décodage Base64 en ligne de commande

Pour une inspection rapide dans le terminal — vérifier un token, examiner un blob de configuration encodé, ou canaliser la sortie d'une API dans un décodeur — la commande base64 est disponible sur Linux et macOS. Le module intégré -m base64 de Python fonctionne sur toutes les plateformes, y compris 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))
"

Pour un travail exploratoire où écrire un pipeline shell semble excessif, collez la chaîne dans le Décodeur Base64 en ligne — il détecte automatiquement les entrées sécurisées pour les URLs et corrige le padding à la volée.

Valider l'entrée Base64 avant de décoder

Lorsque des données Base64 arrivent depuis la saisie utilisateur, un webhook ou une API tierce non fiable, validez-les avant de décoder pour obtenir des erreurs claires et exploitables plutôt que des traces binascii.Error confuses au cœur de la logique métier. Python vous offre deux approches : capturer les exceptions ou pré-valider avec une expression régulière.

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)

Alternative haute performance : pybase64

Pour la grande majorité des cas d'usage, le module base64 de la bibliothèque standard Python est tout à fait adéquat. Si vous traitez des milliers de payloads d'API par seconde, décodez des pièces jointes binaires de plusieurs mégaoctets dans une boucle serrée, ou si votre profileur montre les opérations Base64 comme un goulot d'étranglement — envisagez pybase64. C'est un wrapper d'extension C autour de libbase64 et il est généralement 2 à 5 fois plus rapide que l'implémentation de la bibliothèque standard sur de grandes entrées.

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.

L'API est intentionnellement identique à base64 — changez l'import et rien d'autre ne change. Utilisez-la uniquement lorsque le profilage confirme que Base64 est réellement un goulot d'étranglement, ce qui est rare en dehors des pipelines de données à haut débit.

Erreurs courantes

J'ai vu ces quatre erreurs lors de revues de code à plusieurs reprises — elles sont particulièrement courantes chez les développeurs venant de langages comme JavaScript ou PHP où le décodage Base64 renvoie directement une chaîne, ou de tutoriels qui ignorent entièrement la gestion des erreurs.

Erreur 1 : Oublier d'appeler .decode() sur le résultat

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

Erreur 2 : Utiliser b64decode() avec une entrée Base64 sécurisée pour les URLs

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

Erreur 3 : Ne pas corriger le padding sur les tokens tronqués

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

Erreur 4 : Appeler .decode("utf-8") sur des données binaires

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

Décodage de grands fichiers Base64 en Python

Charger un fichier Base64 de 200 Mo avec Path.read_text() et le décoder en un seul appel allouera la chaîne encodée, les bytes décodés et toutes les représentations intermédiaires simultanément — épuisant facilement la mémoire sur des serveurs contraints ou des fonctions Lambda. Pour des fichiers plus grands que ~50–100 Mo, utilisez plutôt une approche par blocs.

Décodage par blocs vers le disque (sans charger le fichier entier en RAM)

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

Décodage Base64 avec base64.decodebytes() pour les données PEM / multiligne

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

Méthodes de décodage Base64 en Python — Comparaison rapide

Utilisez b64decode() par défaut. Passez à urlsafe_b64decode()dès que vous voyez - ou _ dans l'entrée — ces caractères sont le signe indéniable du Base64 sécurisé pour les URLs. Recourez à pybase64 uniquement après que le profilage confirme un goulot d'étranglement. Pour des vérifications ponctuelles pendant le développement, le Décodeur Base64 de ToolDeck gère les deux alphabets et répare le padding automatiquement — sans environnement Python.

Foire aux questions

Comment décoder une chaîne Base64 en chaîne normale en Python ?

Appelez base64.b64decode(encoded) pour obtenir des bytes, puis appelez .decode("utf-8")sur le résultat pour obtenir un str Python. Les deux étapes sont toujours séparées car b64decode() inverse uniquement l'alphabet Base64 — il ne sait pas si le contenu original était UTF-8, Latin-1 ou binaire. Si les données utilisent un encodage autre que UTF-8, passez le nom correct du codec à .decode(), par exemple .decode("latin-1").

Pourquoi est-ce que j'obtiens « Incorrect padding » lors du décodage Base64 en Python ?

Les chaînes Base64 doivent avoir une longueur multiple de 4 caractères. Les JWT, les tokens OAuth et les données transmises dans les URLs suppriment souvent le padding = final. Corrigez cela en ajoutant "=" * (-len(s) % 4) avant de décoder. Cette formule ajoute exactement 0, 1 ou 2 caractères selon les besoins, et est une opération sans effet lorsque la chaîne est déjà correctement remplie.

Quelle est la différence entre b64decode() et urlsafe_b64decode() en Python ?

Les deux décodent le même algorithme Base64 mais avec des alphabets différents pour les 62e et 63e caractères.b64decode() utilise + et / ; urlsafe_b64decode() utilise - et _. La variante sécurisée pour les URLs est définie dans RFC 4648 §5 et est utilisée partout où Base64 doit survivre dans des URLs, des en-têtes HTTP ou des valeurs de cookies sans encodage par pourcentage. Les mélanger provoque soit un binascii.Error, soit une sortie silencieusement corrompue.

Comment décoder une image encodée en Base64 en Python ?

Décodez en bytes avec base64.b64decode(encoded), puis écrivez ces bytes directement dans un fichier — n'appelez pas .decode("utf-8") sur des données d'image. Si l'entrée est une data URL (ex. : data:image/png;base64,iVBORw0KGgo…), supprimez d'abord le préfixe :

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

Puis-je décoder du Base64 en Python sans importer de module ?

Techniquement oui, mais il n'y a aucune raison de le faire. Le module base64 fait partie de la bibliothèque standard de Python, toujours disponible, toujours installé — il n'a aucune dépendance et ses fonctions sont implémentées en C. Réimplémenter Base64 from scratch serait plus lent, plus sujet aux erreurs et plus difficile à maintenir. Utilisez toujours import base64.

Comment décoder du Base64 en Python lorsque l'entrée est des bytes, pas une chaîne ?

base64.b64decode() accepte str, bytes et bytearray de manière interchangeable — aucune conversion requise. Si vous recevez b"SGVsbG8=" depuis un socket ou une lecture de fichier, passez-le directement. La réparation du padding fonctionne de la même façon avec les bytes : data + b"=" * (-len(data) % 4) lorsqu'on opère en mode bytes.

Outils associés

• Base64 Encode — encodez du texte ou des fichiers binaires en Base64 instantanément ; utile pour générer des fixtures de test pour votre code de décodage Python sans exécuter un script.
• JWT Decoder — inspectez l'en-tête et le payload d'un JWT sans écrire de code ; le payload est décodé avec du Base64 sécurisé pour les URLs en coulisses, exactement comme illustré dans les exemples ci-dessus.
• URL Decode — décodez par pourcentage les query strings et les segments de chemin ; souvent nécessaire aux côtés du décodage Base64 lors de l'analyse des URLs de callback OAuth ou des payloads de webhooks.
• URL Encode — encodez par pourcentage les caractères spéciaux ; pratique lorsque vous devez intégrer une valeur encodée en Base64 en toute sécurité dans un paramètre de query d'URL.