Base64 Decode Python — Guida b64decode()

Quando un'API restituisce un campo content che assomiglia a eyJob3N0IjogImRiLXByb2Qi…, o il tuo gestore di segreti ti consegna una credenziale codificata, o hai bisogno di estrarre un payload JWT — la decodifica Base64 in Python è il tuo primo strumento. Il modulo integrato base64 gestisce tutto, ma i piccoli dettagli su bytes vs stringhe, alfabeti sicuri per gli URL e il padding mancante colgono quasi tutti gli sviluppatori almeno una volta — ho eseguito il debug di questa specifica categoria di errori nelle revisioni del codice più volte di quanto vorrei ammettere. Questa guida tratta base64.b64decode(), urlsafe_b64decode(), la riparazione automatica del padding, la decodifica da file e risposte HTTP, strumenti CLI, la validazione degli input e quattro errori comuni con correzioni prima/dopo — tutti esempi eseguibili in Python 3.8+. Se hai solo bisogno di una decodifica rapida senza scrivere codice, il Decodificatore Base64 di ToolDeck gestisce sia il Base64 standard che quello sicuro per gli URL istantaneamente nel tuo browser.

Cos'è la decodifica Base64?

Base64 è uno schema di codifica che rappresenta dati binari arbitrari come una stringa di 64 caratteri ASCII stampabili: A–Z, a–z, 0–9, + e /, con = usato come padding. Ogni 4 caratteri Base64 codificano esattamente 3 byte originali, quindi la forma codificata è circa il 33% più grande della sorgente. La decodifica inverte il processo — trasformando la rappresentazione ASCII nei byte originali.

Base64 non cifra i dati. È puramente una codifica da binario a testo — la stringa codificata è completamente leggibile da chiunque la passi attraverso un decodificatore:

base64.b64decode() — Decodifica con la libreria standard

Il modulo base64 di Python è incluso nella libreria standard — zero installazione, sempre disponibile. La funzione principale è base64.b64decode(s, altchars=None, validate=False). Accetta str, bytes o bytearray, e restituisce sempre bytes.

Esempio minimo funzionante

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

Esempio esteso: sort_keys, ensure_ascii e validazione rigorosa

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

Decodifica del Base64 sicuro per gli URL (base64url)

Il Base64 standard usa + e /, che sono caratteri riservati negli URL. La variante sicura per gli URL (RFC 4648 §5, chiamata anche “base64url”) li sostituisce con - e _. Questa è la codifica usata nei token JWT, nelle sfide PKCE di OAuth 2.0, nelle credenziali di Google Cloud e nella maggior parte dei moderni flussi di autenticazione web.

Passare Base64 sicuro per gli URL a b64decode() senza regolare l'alfabeto corromperà i dati silenziosamente o solleverà binascii.Error. Usa invece base64.urlsafe_b64decode() — gestisce automaticamente la sostituzione - → +e _ → /.

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

Riferimento ai parametri di base64.b64decode()

Tutti i parametri sottostanti si applicano sia a b64decode() che a urlsafe_b64decode(), eccetto altchars che è disponibile solo su b64decode().

Il valore predefinito validate=False è intenzionale per i dati in formato PEM e il Base64 multiriga (dove i newline sono comuni). Per i payload API, i caricamenti degli utenti o qualsiasi input non attendibile, passa validate=True per rilevare dati corrotti o iniettati tempestivamente e mostrare un errore chiaro.

Errore di padding nella decodifica Base64 in Python — Come risolverlo

L'errore più frequente nella decodifica Base64 in Python è:

import base64

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

Base64 richiede lunghezze di stringa che siano multipli di 4. Quando i dati transitano attraverso URL, intestazioni HTTP o librerie JWT, il padding =finale viene rimosso per risparmiare byte. Esistono due modi affidabili per correggere questo problema.

Opzione 1: Ripristinare il padding inline (consigliato)

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

Opzione 2: Decodifica sicura per gli URL con padding per 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

Decodificare Base64 da un file e da una risposta API

Leggere Base64 dal disco e decodificare payload API sono i due scenari di produzione più comuni. Entrambi richiedono una corretta gestione degli errori — padding corrotto e tipi binari inattesi sono occorrenze reali, non casi limite teorici.

Lettura e decodifica di un file 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")

Decodifica di Base64 da una risposta HTTP di un'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

Decodifica Base64 dalla riga di comando

Per un'ispezione rapida nel terminale — verificare un token, esaminare un blob di configurazione codificato o reindirizzare l'output di un'API attraverso un decodificatore — il comando base64 è disponibile su Linux e macOS. Il modulo integrato -m base64 di Python funziona su tutte le piattaforme incluso 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))
"

Per lavoro esplorativo dove scrivere una pipeline di shell sembra eccessivo, incolla la stringa nel Decodificatore Base64 online — rileva automaticamente l'input sicuro per gli URL e corregge il padding al volo.

Validare l'input Base64 prima di decodificare

Quando i dati Base64 arrivano dall'input dell'utente, da un webhook o da un'API di terze parti non attendibile, validali prima di decodificare per ottenere errori chiari e utilizzabili invece di confusi traceback di binascii.Error in profondità nella logica di business. Python offre due approcci: catturare le eccezioni o pre-validare con una 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)

Alternativa ad alte prestazioni: pybase64

Per la grande maggioranza dei casi d'uso, il modulo base64 della libreria standard di Python è del tutto adeguato. Se stai elaborando migliaia di payload API al secondo, decodificando allegati binari di diversi megabyte in un ciclo stretto, o il tuo profiler mostra le operazioni Base64 come un collo di bottiglia — considera pybase64. È un wrapper di estensione C attorno a libbase64 ed è tipicamente 2–5× più veloce dell'implementazione della libreria standard su input di grandi dimensioni.

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 è intenzionalmente identica a base64 — cambia l'import e nient'altro cambia. Usala solo quando il profiling conferma che Base64 è effettivamente un collo di bottiglia, cosa rara al di fuori delle pipeline di dati ad alto throughput.

Errori comuni

Ho visto questi quattro errori nelle revisioni del codice ripetutamente — sono particolarmente comuni tra gli sviluppatori provenienti da linguaggi come JavaScript o PHP dove la decodifica Base64 restituisce direttamente una stringa, o da tutorial che saltano completamente la gestione degli errori.

Errore 1: Dimenticare di chiamare .decode() sul risultato

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

Errore 2: Usare b64decode() con input Base64 sicuro per gli URL

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

Errore 3: Non correggere il padding nei token senza riempimento

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

Errore 4: Chiamare .decode("utf-8") su dati binari

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

Decodifica di file Base64 di grandi dimensioni in Python

Caricare un file Base64 da 200 MB con Path.read_text() e decodificarlo in una singola chiamata allocherà la stringa codificata, i bytes decodificati e qualsiasi rappresentazione intermedia simultaneamente — esaurendo facilmente la memoria su server con limitazioni o funzioni Lambda. Per file più grandi di ~50–100 MB, usa invece un approccio a chunk.

Decodifica a chunk su disco (senza caricare l'intero file in 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")

Decodifica Base64 con base64.decodebytes() per dati PEM / multiriga

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

Metodi di decodifica Base64 in Python — Confronto rapido

Usa b64decode() come impostazione predefinita. Passa a urlsafe_b64decode()non appena vedi - o _ nell'input — questi caratteri sono il segnale inequivocabile del Base64 sicuro per gli URL. Ricorri a pybase64 solo dopo che il profiling conferma un collo di bottiglia. Per controlli rapidi durante lo sviluppo, il Decodificatore Base64 di ToolDeck gestisce entrambi gli alfabeti e ripara automaticamente il padding — senza bisogno di un ambiente Python.

Domande frequenti

Come decodifico una stringa Base64 in una stringa normale in Python?

Chiama base64.b64decode(encoded) per ottenere bytes, poi chiama .decode("utf-8")sul risultato per ottenere un str Python. I due passaggi sono sempre separati perché b64decode() inverte solo l'alfabeto Base64 — non sa se il contenuto originale era UTF-8, Latin-1 o binario. Se i dati usano una codifica diversa da UTF-8, passa il nome corretto del codec a .decode(), ad esempio .decode("latin-1").

Perché ottengo "Incorrect padding" quando decodifico Base64 in Python?

Le stringhe Base64 devono avere una lunghezza multipla di 4 caratteri. I JWT, i token OAuth e i dati trasmessi negli URL spesso rimuovono il padding = finale. Correggilo aggiungendo "=" * (-len(s) % 4) prima di decodificare. Questa formula aggiunge esattamente 0, 1 o 2 caratteri secondo necessità, ed è un'operazione nulla sicura quando la stringa è già correttamente riempita.

Qual è la differenza tra b64decode() e urlsafe_b64decode() in Python?

Entrambe decodificano lo stesso algoritmo Base64 ma con alfabeti diversi per il 62° e 63° carattere.b64decode() usa + e /; urlsafe_b64decode() usa - e _. La variante sicura per gli URL è definita in RFC 4648 §5 e viene utilizzata dove Base64 deve sopravvivere in URL, intestazioni HTTP o valori dei cookie senza codifica percentuale. Mescolarle causa un binascii.Error o un output silenziosamente corrotto.

Come decodifico un'immagine codificata in Base64 in Python?

Decodifica in bytes con base64.b64decode(encoded), poi scrivi quei bytes direttamente su un file — non chiamare .decode("utf-8") su dati immagine. Se l'input è una data URL (es. data:image/png;base64,iVBORw0KGgo…), rimuovi prima il prefisso:

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

Posso decodificare Base64 in Python senza importare alcun modulo?

Tecnicamente sì, ma non c'è motivo di farlo. Il modulo base64 fa parte della libreria standard di Python, sempre disponibile, sempre installato — non ha dipendenze e le sue funzioni sono implementate in C. Reimplementare Base64 da zero sarebbe più lento, più soggetto a errori e più difficile da mantenere. Usa sempre import base64.

Come decodifico Base64 in Python quando l'input è bytes, non una stringa?

base64.b64decode() accetta str, bytes e bytearray in modo intercambiabile — nessuna conversione richiesta. Se ricevi b"SGVsbG8=" da un socket o dalla lettura di un file, passalo direttamente. La riparazione del padding funziona allo stesso modo con i bytes: data + b"=" * (-len(data) % 4) quando si opera in modalità bytes.

Strumenti correlati

• Base64 Encode — codifica testo o file binari in Base64 istantaneamente; utile per generare fixture di test per il tuo codice di decodifica Python senza eseguire uno script.
• JWT Decoder — ispeziona l'header e il payload di un JWT senza scrivere codice; il payload viene decodificato con Base64 sicuro per gli URL dietro le quinte, esattamente come mostrato negli esempi sopra.
• URL Decode — decodifica in percentuale query string e segmenti di percorso; spesso necessario insieme alla decodifica Base64 quando si analizzano URL di callback OAuth o payload di webhook.
• URL Encode — codifica in percentuale i caratteri speciali; utile quando devi incorporare un valore codificato in Base64 in modo sicuro all'interno di un parametro di query di un URL.