Decodifica Base64

Raccomandazioni correlate

Cos'è la Decodifica Base64?

Casi d'uso

• Decodifica campi Base64 restituiti dalle API per visualizzare il contenuto originale
• Ripristina dati codificati in Base64 presenti nei log applicativi
• Recupera valori codificati in Base64 dai file di configurazione
• Indaga le cause degli errori di decodifica Base64 (padding mancante, caratteri non validi, ecc.)
• Decodifica header e payload di un JWT per leggere claim e metadati del token
• Ripristina testo originale da parametri URL o nomi file che usano Base64 URL-Safe
• Verifica il contenuto di un allegato email ricevuto in formato MIME Base64

Come utilizzare

1. Incolla la stringa Base64 da decodificare nell'editor di sinistra
2. Scegli il charset più adatto al testo originale (UTF-8, ASCII o ISO-8859-1)
3. Lo strumento decodifica automaticamente e mostra il testo originale nell'editor di destra
4. Copia il risultato o scaricalo come file .txt per uso successivo

Funzionalità

• Conversione bidirezionale in tempo reale: decodifica mentre digiti, con debounce di 300 ms, nessun pulsante da premere
• Supporto multi-charset: UTF-8, ASCII e ISO-8859-1 per coprire testi italiani, inglesi e multilingue
• Compatibilità URL-Safe Base64: gestisce automaticamente i caratteri - e _ e supporta input senza padding
• Rilevamento caratteri non validi: in caso di errore di decodifica indica la posizione esatta per identificare subito il problema di formato
• Copia e download con un clic: copia il risultato decodificato negli appunti o scaricalo come file .txt
• Elaborazione locale nel browser: nessun dato lascia il dispositivo, ideale per decodificare contenuti sensibili
• Supporta varianti Standard, URL-Safe e MIME Base64 per coprire scenari JWT, OAuth e allegati email

Esempi di codice

// Decodifica Base64 con supporto UTF-8 (italiano, emoji, ecc.)
function b64Decode(str) {
  const padded = str + '='.repeat((4 - str.length % 4) % 4);
  const standard = padded.replace(/-/g, '+').replace(/_/g, '/');
  const bytes = atob(standard);
  const bytesArr = new Uint8Array(bytes.length);
  for (let i = 0; i < bytes.length; i++) {
    bytesArr[i] = bytes.charCodeAt(i);
  }
  return new TextDecoder('utf-8').decode(bytesArr);
}

// Codifica Base64 con supporto UTF-8
function b64Encode(str) {
  const bytes = new TextEncoder().encode(str);
  let bin = '';
  for (const b of bytes) bin += String.fromCharCode(b);
  return btoa(bin);
}

console.log(b64Decode('SGVsbG8g0LjRgtC1INC60LLQsA==')); // Ciao, è bello!
console.log(b64Encode('Ciao, è bello!')); // SGVsbG8g0LjRgtC1INC60LLQsA==

import base64

# Decodifica Base64 Standard (UTF-8)
encoded = base64.b64encode('Ciao, è bello!'.encode('utf-8'))
decoded = base64.b64decode(encoded).decode('utf-8')
print(decoded)  # Ciao, è bello!

# Decodifica URL-Safe (con gestione padding omesso)
url_safe = 'SGVsbG8g0LjRgtC1INC60LLQsA'
padded = url_safe + '=' * (4 - len(url_safe) % 4)
decoded_url = base64.urlsafe_b64decode(padded).decode('utf-8')
print(decoded_url)  # Ciao, è bello!

# Decodifica con rimozione automatica del padding
def b64url_decode(s: str) -> str:
    s = s.replace('-', '+').replace('_', '/')
    s += '=' * ((4 - len(s) % 4) % 4)
    return base64.b64decode(s).decode('utf-8')

print(b64url_decode('SGVsbG8g0LjRgtC1INC60LLQsA'))  # Ciao, è bello!

import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64DecodeExample {
    public static void main(String[] args) {
        String text = "Ciao, è bello!";
        String encoded = Base64.getEncoder()
            .encodeToString(text.getBytes(StandardCharsets.UTF_8));

        String decoded = new String(
            Base64.getDecoder().decode(encoded), StandardCharsets.UTF_8);
        System.out.println(decoded); // Ciao, è bello!

        String urlSafeNoPad = Base64.getUrlEncoder().withoutPadding()
            .encodeToString(text.getBytes(StandardCharsets.UTF_8));
        String decodedUrl = new String(
            Base64.getUrlDecoder().decode(urlSafeNoPad), StandardCharsets.UTF_8);
        System.out.println(decodedUrl);

        String mime = Base64.getMimeEncoder()
            .encodeToString(text.getBytes(StandardCharsets.UTF_8));
        String decodedMime = new String(
            Base64.getMimeDecoder().decode(mime), StandardCharsets.UTF_8);
        System.out.println(decodedMime);
    }
}

Domande frequenti

Risoluzione dei problemi

Glossario

RFC 4648

Standard ufficiale IETF per le codifiche Base16, Base32 e Base64. Definisce gli alfabeti Base64 standard e URL-Safe, oltre alle regole su padding, a capo e gestione dei caratteri fuori alfabeto. È il riferimento attuale della decodifica Base64 e sostituisce la precedente RFC 3548.

RFC 2045 (MIME)

Standard Multipurpose Internet Mail Extensions, il primo a definire Base64 come codifica di trasferimento per le email. Stabilisce righe non più lunghe di 76 caratteri con CRLF come a capo: è la variante MIME Base64, molto presente negli allegati email.

Base64URL (URL-Safe Base64)

Variante sicura per URL definita in RFC 4648 §5. Sostituisce + e / con - e _ e spesso omette il padding =. È usata in JWT, OAuth PKCE, parametri URL e nomi file. In fase di decodifica i caratteri - e _ vanno riconvertiti in + e / e il padding va ripristinato.

InvalidCharacterError

Errore generato da atob e da altre API di decodifica quando la stringa contiene caratteri fuori dall'alfabeto Base64 (spazi, a capo, virgolette, caratteri non stampabili, ecc.). Per risolverlo basta ripulire l'input o convertire la variante URL-Safe nella forma standard.

Padding (riempimento)

Carattere = aggiunto alla fine di una stringa Base64 per rendere la lunghezza un multiplo di 4. Indica quanti byte fittizi sono stati aggiunti e devono essere rimossi in fase di decodifica. La variante URL-Safe spesso omette il padding: in decodifica va ripristinato.

atob / btoa

API native del browser: btoa (binary to ASCII) codifica in Base64, atob (ASCII to binary) decodifica da Base64. Supportano solo Latin-1 (ISO-8859-1), quindi per testo italiano, cinese ed emoji serve una conversione UTF-8 aggiuntiva.

MIME Base64

Variante Base64 conforme a RFC 2045 che inserisce un a capo (CRLF) ogni 76 caratteri. In decodifica questi caratteri di a capo vanno rimossi prima di passare la stringa al decodificatore per ottenere il dato originale.

Charset (set di caratteri)

Mappatura tra byte e caratteri usata per interpretare il risultato della decodifica Base64. UTF-8 è lo standard moderno e supporta tutte le lingue; ISO-8859-1 copre solo il latino base; ASCII copre i primi 128 caratteri. Scegliere il charset sbagliato produce testo incomprensibile.

Tabella di compatibilità tra varianti Base64 in decodifica

Tabella di confronto charset per la decodifica Base64

Authoritative References

• ReferenceRFC 4648 - Codifiche di dati Base16, Base32 e Base64
• ReferenceRFC 2045 - MIME Parte 1: formato dei corpi dei messaggi Internet
• ReferenceRFC 7519 - JSON Web Token (JWT)
• ReferenceMDN Web Docs - atob()
• ReferenceMDN Web Docs - btoa()
• ReferenceWikipedia - Base64