Skip to content

Decodificatore JWT

Decodifica token JWT online con il nostro decodificatore JWT gratis. Ispeziona intestazione, payload, firma, scadenza e attestazioni. 100% browser — token mai fuori dal dispositivo. Nessuna registrazione, nessun tracciamento.

Niente tracciamento Funziona nel browser Gratuito
Token JWT
Verificato per conformità a RFC 7519 e garanzie di privacy — Team Sicurezza di Go Tools · Apr 22, 2026

Cos'è un JWT?

Un JSON Web Token, o JWT (pronunciato 'jot'), è un formato di token compatto e URL-safe per trasportare attestazioni tra due parti. È definito nella RFC 7519 ed è il formato di credenziale dominante usato dagli access token OAuth 2.0, dagli ID token OpenID Connect, dalle chiavi API nei moderni auth provider (Auth0, Okta, Clerk, Supabase, Firebase) e dai token inter-servizio nelle architetture a microservizi.

"Il JSON Web Token (JWT) è un formato compatto di rappresentazione delle attestazioni, pensato per ambienti con vincoli di spazio come gli header Authorization HTTP e i parametri di query URI." — RFC 7519, Sezione 1

Un JWT è composto da tre oggetti JSON codificati in Base64URL uniti da punti: header.payload.signature. L'intestazione descrive come è firmato il token (l'attestazione alg — per esempio, HS256 o RS256 — e l'attestazione typ, di solito 'JWT'). Il payload trasporta le attestazioni: attestazioni registrate come iss, sub, aud, exp, iat, oltre a qualsiasi attestazione personalizzata di cui l'emittente ha bisogno (role, scope, email, tenant ID). La firma è una prova crittografica, calcolata sull'intestazione e sul payload con il segreto o la chiave privata dell'emittente, che permette al destinatario di rilevare manomissioni.

Fondamentalmente, un JWT è codificato, non cifrato. Chiunque abbia il token può leggerne il payload — decodificare è solo Base64URL e parsing JSON. La garanzia di sicurezza viene dalla firma: un attaccante può leggere un JWT, ma non può produrre un JWT diverso che passi la verifica della firma senza la chiave di firma. Per questo i JWT sono sicuri da passare in rete, ma non sicuri da riempire di segreti.

Un decodificatore JWT ti mostra esattamente cosa contiene un token — algoritmo, attestazioni, scadenza — senza toccare la firma. È il modo più veloce per rispondere a 'questo token è scaduto?', 'quale ruolo ha questo utente?', 'quale emittente ha coniato questo token?' o 'è un token alg:none che dovrei rifiutare?'. Tutta la decodifica in questo strumento gira localmente nel tuo browser, quindi incollare un token di produzione attivo è sicuro.

Il lavoro con i JWT si combina spesso con altri strumenti per sviluppatori. Potresti dover decodificare un segmento avvolto in Base64URL durante il debug di un token malformato, decodificare URL un header Authorization dopo averlo catturato da un proxy, o convertire l'attestazione exp in una data leggibile manualmente. Per un approfondimento su come i JWT vengono firmati, verificati e ruotati in produzione, consulta la nostra guida ai fondamenti di Base64 — Base64URL è la base su cui ogni JWT è costruito.

// Decode a JWT in the browser — header & payload only
function decodeJwt(token) {
  const [h, p, s] = token.split('.');
  const pad = (seg) => seg + '==='.slice((seg.length + 3) % 4);
  const decode = (seg) => JSON.parse(
    atob(pad(seg).replace(/-/g, '+').replace(/_/g, '/'))
  );
  return { header: decode(h), payload: decode(p), signature: s };
}

const { header, payload } = decodeJwt(token);
console.log(header);   // → { alg: 'HS256', typ: 'JWT' }
console.log(payload);  // → { sub: 'user_123', exp: 1999999999, ... }

// Expiration check
const expired = payload.exp * 1000 < Date.now();

Caratteristiche principali

Decodifica JWT istantaneamente

Incolla e vedi il JWT decodificato in tempo reale — intestazione, payload e firma analizzati al volo. Nessun pulsante Decodifica, nessun round-trip verso un server.

Rilevamento della scadenza

Legge automaticamente l'attestazione exp e mostra un badge rosso quando il token è scaduto, con la data di scadenza esatta nel tuo fuso orario locale.

Indipendente dall'algoritmo

Decodifica ogni algoritmo JWS — HS256/384/512, RS256/384/512, PS256/384/512, ES256/384/512, EdDSA e alg:none.

100% locale

La decodifica gira nel tuo browser tramite atob e JSON.parse nativi. Il tuo token non viene mai caricato — sicuro per credenziali di produzione.

Visualizzazione consapevole delle attestazioni

Evidenzia le attestazioni registrate RFC 7519 (iat, exp, nbf, iss, aud, sub, jti) così puoi individuare problemi di autenticazione a colpo d'occhio.

Copia con un clic

Copia il JSON dell'intestazione, il JSON del payload o la firma grezza negli appunti con un solo clic — perfetto per bug report e test.

Esempi

Token HS256 (valido)

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMyIsIm5hbWUiOiJBbGljZSIsInJvbGUiOiJhZG1pbiIsImlhdCI6MTcxNTAwMDAwMCwiZXhwIjoxOTk5OTk5OTk5fQ.4NhxPjwoZxPNuxG-2C5ugGxaUsUJ0QyskAz7Ymz5Sg0
{
  "alg": "HS256",
  "typ": "JWT"
}

{
  "sub": "user_123",
  "name": "Alice",
  "role": "admin",
  "iat": 1715000000,
  "exp": 1999999999
}

Token firmato con HMAC-SHA256 con un soggetto, un ruolo e una scadenza futura — la configurazione JWT più comune usata per l'autenticazione di sessione.

Token RS256 (scaduto)

eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImtleS0yMDI1LTAxIn0.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJhdWQiOiJhcGkuZXhhbXBsZS5jb20iLCJzdWIiOiI5MDA4NzE2NSIsImlhdCI6MTYwMDAwMDAwMCwiZXhwIjoxNjAwMDAzNjAwLCJzY29wZSI6InJlYWQ6dXNlciB3cml0ZTpwb3N0In0.signature_placeholder
{
  "alg": "RS256",
  "typ": "JWT",
  "kid": "key-2025-01"
}

{
  "iss": "https://auth.example.com",
  "aud": "api.example.com",
  "sub": "90087165",
  "iat": 1600000000,
  "exp": 1600003600,
  "scope": "read:user write:post"
}

Access token in stile OAuth firmato con RSA — nota il kid (key ID) nell'intestazione e l'attestazione exp che mostra che il token è già scaduto.

ID Token OIDC

eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20iLCJzdWIiOiIxMTA1MDIyNTExNTU4OTkwNzY2Mzk1IiwiYXpwIjoiY2xpZW50LWlkIiwiYXVkIjoiY2xpZW50LWlkIiwiZW1haWwiOiJhbGljZUBleGFtcGxlLmNvbSIsImVtYWlsX3ZlcmlmaWVkIjp0cnVlLCJpYXQiOjE3MTUwMDAwMDAsImV4cCI6MTk5OTk5OTk5OSwibm9uY2UiOiJhYmMxMjMifQ.signature
{
  "alg": "ES256",
  "typ": "JWT"
}

{
  "iss": "https://accounts.google.com",
  "sub": "110502251155899076639",
  "azp": "client-id",
  "aud": "client-id",
  "email": "alice@example.com",
  "email_verified": true,
  "iat": 1715000000,
  "exp": 1999999999,
  "nonce": "abc123"
}

ID token OpenID Connect con firma ECDSA, attestazioni email e un nonce per la protezione contro il replay.

Token con alg:none (non firmato)

eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiJkZWJ1Zy11c2VyIiwiaWF0IjoxNzE1MDAwMDAwfQ.
{
  "alg": "none",
  "typ": "JWT"
}

{
  "sub": "debug-user",
  "iat": 1715000000
}

Token non firmato con alg:none. Accettarlo in produzione è una vulnerabilità JWT classica — rifiuta sempre alg:none lato server.

Come si usa

  1. 1

    Incolla il tuo JWT da decodificare

    Incolla il token completo da decodificare — inclusi i tre segmenti separati da punti — nella casella di input. Il decodificatore gira istantaneamente nel tuo browser; non serve cliccare alcun pulsante.

  2. 2

    Leggi intestazione, payload e stato decodificati

    Leggi l'algoritmo e il tipo di token nell'intestazione decodificata, le attestazioni nel payload decodificato e i chip di scadenza / ora di emissione in alto. Un token scaduto viene segnalato in rosso.

  3. 3

    Copia l'output decodificato

    Usa il pulsante Copia su ciascun pannello per copiare il JSON dell'intestazione decodificata, il JSON del payload decodificato o la firma grezza. Il tuo token non è mai stato inviato da nessuna parte — la decodifica è avvenuta localmente nel tuo browser.

Common Errors

Accettare alg:none

Un JWT non firmato può essere falsificato da chiunque. Non consentire mai alg:none in produzione — passa sempre una lista esplicita di algoritmi alla tua chiamata di verifica.

✗ Errato
jwt.verify(token, secret)  // library default may allow 'none'
✓ Corretto
jwt.verify(token, secret, { algorithms: ['RS256'] })

Attestazione exp mancante

Un JWT senza exp vive per sempre. Se un token viene mai esposto, non c'è un punto di revoca naturale. Imposta sempre una scadenza adeguata al tipo di token.

✗ Errato
{ "sub": "user_123", "role": "admin" }  // no exp
✓ Corretto
{ "sub": "user_123", "role": "admin", "exp": 1715003600 }

Memorizzare segreti nel payload

I payload JWT non sono cifrati — chiunque abbia il token può leggerli. Non mettere mai password, chiavi API o PII non troncate all'interno di un payload JWT.

✗ Errato
{ "sub": "user_123", "password": "hunter2" }
✓ Corretto
{ "sub": "user_123", "role": "admin" }  // payload stays minimal

Casi d'uso comuni

Decodifica i token Authorization Bearer
Decodifica i token JWT dagli header Authorization: Bearer per verificare le attestazioni, l'audience e la scadenza che il tuo backend sta ricevendo.
Decodifica i token OAuth 2.0 e OIDC
Decodifica gli access token e gli ID token restituiti dai server di autorizzazione (Auth0, Okta, Google, Keycloak) durante l'integrazione OAuth 2.0 e OpenID Connect.
Diagnosi di sessioni scadute
Conferma in un secondo se un token rifiutato è scaduto, usa l'audience sbagliata o ha un problema di sfasamento dell'orologio.
Controlli di rotazione delle chiavi
Leggi il kid (key ID) nell'intestazione per verificare che la tua rotazione JWKS stia distribuendo token firmati con la chiave attesa.
Revisioni di sicurezza
Individua token firmati con alg:none, privi di exp o che espongono PII nel payload durante code review e pentesting.
Ispezione di token tra microservizi
Decodifica i token service-to-service all'interno di una mesh per vedere quali scope e soggetto una chiamata a valle sta autorizzando.

Dettagli tecnici

Conforme a RFC 7519
Gestisce token JWS conformi a RFC 7519 (JWT), RFC 7515 (JWS) e RFC 7518 (JWA) — tutti gli algoritmi registrati sono supportati per la decodifica.
Decodifica Base64URL
Usa l'alfabeto Base64 URL-safe (- e _ al posto di + e /) definito in RFC 4648, con parsing tollerante al padding.
Nativo del browser, zero dipendenze
Costruito sui nativi atob, TextDecoder e JSON.parse del browser — nessuna libreria esterna, nessuna chiamata di rete, nessuna telemetria.

Buone pratiche

Non fidarti mai senza verificare
Un decodificatore mostra le attestazioni; non le dimostra. Verifica sempre la firma lato server contro la chiave dell'emittente prima di fidarti di qualsiasi attestazione.
Rifiuta alg:none in produzione
Configura la tua libreria JWT con una allowlist esplicita di algoritmi. Non accettare mai alg:none e diffida dei mismatch di alg sulla rotazione delle chiavi.
Mantieni i payload snelli
Metti identificatori e attestazioni a breve scadenza nel JWT; tieni i dati voluminosi dietro un ID di sessione opaco. I token grandi costano banda a ogni richiesta.

Domande frequenti

Come si decodifica un token JWT online?
Incolla il JWT completo — tutti e tre i segmenti separati da punti (header.payload.signature) — nel decodificatore qui sopra. La decodifica avviene all'istante nel tuo browser: intestazione e payload vengono decodificati in Base64URL in JSON leggibile, e la firma viene mostrata come stringa grezza. Una riga di stato rivela l'algoritmo di firma, l'orario di emissione e la scadenza, così puoi individuare un token scaduto a colpo d'occhio. Per decodificare un JWT manualmente, dividi il token sui punti, decodifica in Base64URL i primi due segmenti e interpretali come JSON — chiunque abbia il token può leggerne le attestazioni perché il payload è codificato, non cifrato. Questo decodificatore è sicuro da usare con token di produzione perché nulla lascia mai il tuo dispositivo: nessuna richiesta di rete, nessun log, nessun tracciamento.
Cos'è un JWT (JSON Web Token)?
Un JSON Web Token (JWT) è una credenziale compatta e URL-safe che trasporta attestazioni tra due parti. Definito nella RFC 7519, è composto da tre sezioni codificate in Base64URL unite da punti: l'intestazione (algoritmo e tipo di token), il payload (attestazioni — dati sull'utente e sul token stesso) e la firma (una prova crittografica che il token è stato emesso da una parte fidata). I JWT sono il modo standard per rappresentare gli access token in OAuth 2.0 e gli ID token in OpenID Connect.
Il mio token è al sicuro con questo decodificatore JWT?
Sì. Tutta la decodifica avviene nel tuo browser tramite JavaScript nativo (atob e TextDecoder). Il tuo token non viene mai inviato a un server, mai registrato, mai memorizzato e mai usato per analisi. Non ci sono cookie né tracciamento. Questo è importante perché i JWT possono contenere access token attivi — incollarli in un debugger remoto equivarrebbe a consegnare una credenziale. Il nostro strumento è sicuro da usare con token di produzione.
Come funziona un decodificatore JWT?
Un decodificatore JWT divide il token per i punti in tre parti, decodifica in Base64URL l'intestazione e il payload, e li interpreta come JSON. La firma viene lasciata come stringa Base64URL opaca perché verificarla richiede il segreto o la chiave pubblica dell'emittente — qualcosa che un decodificatore lato client non può fare in modo sicuro. Questo significa che la decodifica è istantanea e rivela le attestazioni, ma devi verificare la firma lato server con la chiave corretta prima di fidarti di qualsiasi contenuto.
Questo strumento può verificare la firma di un JWT?
No, e intenzionalmente non lo fa. La verifica della firma richiede il segreto (per HMAC) o la chiave pubblica (per RSA/ECDSA/EdDSA) dell'emittente, che non dovrebbero mai essere incollati in uno strumento web pubblico. La verifica deve avvenire sul tuo server, nel tuo middleware di autenticazione o all'interno di un SDK che ha accesso al tuo endpoint JWKS. Questo decodificatore serve per ispezionare cosa dichiara un token — non implica che il token sia autentico o non manomesso.
Cosa sono iat, exp, nbf, iss, aud, sub e jti?
Sono le attestazioni registrate dalla RFC 7519. iat (issued at) è il timestamp Unix in cui il token è stato creato. exp (expiration) è il momento in cui il token smette di essere valido — questo strumento lo converte in una data leggibile e marca il token come scaduto se exp è nel passato. nbf (not before) è il primo momento in cui il token può essere usato. iss (issuer) identifica chi ha creato il token. aud (audience) nomina il destinatario previsto. sub (subject) identifica il principal — di solito un ID utente. jti è un ID token univoco usato per prevenire il replay. Attestazioni specifiche dell'applicazione (role, scope, email, name) convivono accanto a queste.
Il mio JWT è scaduto — perché il decodificatore lo decodifica lo stesso?
Decodificare non è la stessa cosa che validare. Un decodificatore JWT legge il contenuto indipendentemente dalla scadenza, così puoi ispezionare un token scaduto o altrimenti invalido per capire perché è stato rifiutato. Il badge 'Scaduto' in questo strumento confronta l'attestazione exp con il tuo orologio locale e contrassegna i token il cui exp è nel passato. Un vero server di autenticazione rifiuterebbe il token direttamente — ma un decodificatore che si rifiutasse di mostrare i token scaduti sarebbe inutile per il debug.
Qual è la differenza tra JWT, JWS e JWE?
JWT è il concetto generale — un oggetto JSON codificato come token compatto. JWS (RFC 7515) è un JWT firmato: il payload è leggibile da chiunque lo decodifichi, e una firma dimostra che non è stato manomesso. È di gran lunga il JWT più comune che incontrerai. JWE (RFC 7516) è un JWT cifrato: il payload stesso è testo cifrato e non può essere decodificato senza la chiave di decifratura. Questo strumento decodifica token JWS. Un token JWE decodificherà solo fino alla sua intestazione — il payload cifrato non è leggibile senza la chiave.
Perché alg:none è pericoloso?
Un JWT con alg:none non ha firma — chiunque può costruirne uno, dichiarando di essere qualsiasi utente. Le prime librerie JWT accettavano alg:none per impostazione predefinita, portando a una nota classe di bypass dell'autenticazione in cui un attaccante rimuoveva la firma, impostava alg su none e falsificava un token admin. Ogni libreria JWT matura ora rifiuta alg:none a meno che non sia esplicitamente consentito, e non dovresti mai accettarlo per richieste autenticate. Questo decodificatore ti mostrerà comunque un token alg:none, perché ispezionarne uno durante il debug è legittimo — ma tratta qualsiasi token del genere ricevuto in produzione come ostile.
Quali algoritmi supporta questo decodificatore JWT?
La decodifica dell'intestazione e del payload funziona per ogni algoritmo, perché la decodifica richiede solo Base64URL e parsing JSON — è indipendente dall'algoritmo. Lo strumento legge correttamente token firmati con HS256, HS384, HS512 (HMAC), RS256, RS384, RS512 (RSA + SHA), PS256, PS384, PS512 (RSA-PSS), ES256, ES384, ES512 (ECDSA), EdDSA (Ed25519/Ed448) e token non firmati (alg:none). Solo la verifica della firma è specifica dell'algoritmo, e questo strumento non esegue la verifica.
Dovrei memorizzare i JWT in localStorage o nei cookie?
Preferisci cookie HttpOnly, Secure, SameSite=Strict per i token di sessione. Un token in localStorage è leggibile da qualsiasi JavaScript che gira sulla pagina, quindi una singola vulnerabilità XSS espone ogni sessione attiva. I cookie HttpOnly sono invisibili a JavaScript, il che riduce il raggio d'azione dell'XSS a ciò che un attaccante può fare all'interno di una pagina attiva — non a un token rubato che può riutilizzare per giorni. Se devi usare localStorage (per esempio, per app cross-domain), mantieni brevi i tempi di vita degli access token (minuti, non ore) e usa un refresh token separato in un cookie HttpOnly.
Come decodifico un JWT in Node.js, Python o Go?
Node.js: jsonwebtoken.decode(token) per sola lettura, jsonwebtoken.verify(token, key) per la verifica. Python: PyJWT.decode(token, options={'verify_signature': False}) per leggere, passa una chiave per verificare. Go: jwt.ParseUnverified(token, claims) per sola lettura, jwt.Parse(token, keyFunc) per la verifica. In ogni linguaggio, non verificare mai con options={'verify_signature': False} in codice di produzione — è quello che questo strumento web fa deliberatamente per il debug, ed è sicuro solo quando stai ispezionando, non autenticando.
Qual è la dimensione massima di un JWT?
Lo standard JWT non impone un limite rigido, ma gli header nella maggior parte dei web server sono limitati per default a circa 8 KB. Mantieni i token sotto i 4 KB in modo che entrino comodamente negli header Authorization e nei cookie. Se il tuo token è più grande, probabilmente stai mettendo troppe attestazioni nel payload — sposta i dati voluminosi dietro un ID di sessione opaco e recuperali dal tuo backend quando servono. JWT gonfiati diventano costosi anche a ogni richiesta perché vengono inviati con ogni chiamata API.
Ho incollato il mio token e ho ottenuto 'Formato JWT non valido' — cosa c'è di sbagliato?
Un JWT valido ha esattamente tre parti separate da punti: header.payload.signature. Cause comuni: (1) hai copiato accidentalmente solo il segmento del payload, (2) sono stati incollati spazi o ritorni a capo nel mezzo, (3) il token è stato troncato in transito (comune con il wrapping del terminale), (4) il token è un JWE il cui formato è header.encryptedKey.iv.ciphertext.tag (cinque segmenti), oppure (5) il token era URL-encoded e devi prima decodificarlo URL. Controlla il valore grezzo restituito dalla tua API — la maggior parte degli editor mostra i caratteri invisibili al passaggio del mouse.
Posso decodificare un JWT senza la chiave segreta?
Sì — l'intestazione e il payload sono codificati in Base64URL, non cifrati. Chiunque abbia il token può leggere le sue attestazioni senza alcuna chiave. Questo è voluto per progettazione: il payload è pensato per essere leggibile così il destinatario può prendere decisioni di autorizzazione da esso. Il segreto o la chiave pubblica sono richiesti solo per verificare che il token non sia stato manomesso. Ecco perché non devi mai mettere dati sensibili (password, chiavi private, PII oltre ciò che il destinatario conosce già) all'interno del payload di un JWT.
Il mio JWT funziona in Postman ma il mio backend lo rifiuta — come faccio il debug?
Decodifica il token qui e controlla: (1) exp — è nel futuro rispetto all'orologio del server? Lo sfasamento dell'orologio del server è un colpevole frequente. (2) iss / aud — corrispondono esattamente a quello che il tuo backend si aspetta? Un mismatch su aud è il falso-negativo più comune. (3) alg — il tuo codice di verifica consente quell'algoritmo? Un token HS256 fallirà contro una libreria configurata solo per RS256. (4) kid — se usi la rotazione delle chiavi, il key ID nell'intestazione è presente nel tuo JWKS? (5) signature — hai incollato il segreto/la chiave pubblica corretti? Questo decodificatore fa emergere (1), (2), (3) e (4) nelle viste di intestazione e payload così puoi escluderli rapidamente.

Strumenti correlati

Vedi tutti gli strumenti →