Decodificador JWT

Cómo decodificar un JWT

1. Pega el token en Token. Funciona una línea completa Authorization: Bearer eyJ…, y también las comillas alrededor o un token partido en varias líneas.
2. Lee el resultado. Las tres partes se muestran en colores distintos, el encabezado y el payload aparecen formateados, y Claims lista cada claim con su significado. Las fechas como exp e iat aparecen en hora local, en UTC y como tiempo relativo del tipo “caduca en 1 hora”.
3. Para comprobar la firma, pega el secreto compartido o la clave pública en Verificar firma. La etiqueta del campo sigue el alg del token: Secreto para HS256/384/512, Clave pública para todo lo demás.
4. Lee los avisos. La herramienta señala alg: none, tokens caducados, un nbf en el futuro, la falta de exp, fechas escritas en milisegundos y encabezados que apuntan a claves remotas (jku, x5u) o que incrustan su propia clave (jwk).

También puedes abrir un token directamente con un enlace como /jwt-decoder/#token=eyJ…. La parte que va tras # es un fragmento de URL, y los navegadores nunca envían los fragmentos al servidor.

Qué hay dentro de un token

Un JWT firmado (un JWS en forma compacta) son tres cadenas Base64URL unidas por puntos: header.payload.signature. Este es un token HS256 real, emitido el 1 de enero de 2026 y válido durante una hora:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJzdWIiOiJ1c2VyLTQyIiwiYXVkIjoiYXBpLmV4YW1wbGUuY29tIiwiaWF0IjoxNzY3MjI1NjAwLCJleHAiOjE3NjcyMjkyMDB9.U3Gb12hN5Fnpi1rJ7nrkUzIEidkg-hPnbgiIpTah3R4

La primera parte se decodifica en el encabezado {"alg":"HS256","typ":"JWT"}. La segunda es el payload:

{"iss":"https://auth.example.com","sub":"user-42","aud":"api.example.com","iat":1767225600,"exp":1767229200}

La tercera parte son 32 bytes de HMAC-SHA256 calculados sobre las dos primeras, así que cambiar un solo carácter del encabezado o del payload la invalida. Casi todos los JWT empiezan por eyJ, el Base64 de {". Las partes usan el alfabeto URL-safe (- y _) sin relleno =; cómo usa JWT Base64URL explica paso a paso cómo decodificar uno a mano.

JWS o JWE: tokens firmados frente a cifrados

La mayoría de los JWT son JWS: firmados y legibles por cualquiera. Un JWE está cifrado y tiene cinco partes en lugar de tres: header.encrypted_key.iv.ciphertext.tag. Su encabezado sigue siendo legible e indica el algoritmo de gestión de claves (alg, por ejemplo RSA-OAEP-256 o dir) y el cifrado del contenido (enc, por ejemplo A256GCM).

Si pegas aquí un JWE, la herramienta decodifica ese encabezado, muestra alg, enc y kid y marca el payload como cifrado. Descifrarlo requiere la clave privada del destinatario o la clave compartida, y esta herramienta no descifra JWE. Si necesitas un token cuyo payload no puedan leer los usuarios, JWE es el formato adecuado; meter secretos en el payload de un JWS equivale a ponerlos en texto plano, como se explica en Base64 no es cifrado.

Referencia de claims JWT

Las siete primeras filas son los claims registrados del RFC 7519; el resto son habituales en tokens de OpenID Connect y OAuth. Todos los valores de tiempo son NumericDate: segundos enteros desde el 1970-01-01 UTC, nunca milisegundos.

El encabezado tiene sus propios parámetros: alg (el algoritmo de firma), typ (normalmente JWT, o at+jwt en los access tokens de OAuth), kid (qué clave lo firmó) y cty (vale JWT cuando un token va anidado dentro de otro).

Verificar la firma: qué clave pegar

Solo la comprobación de la firma demuestra de dónde viene un token, y la clave que necesita depende de la familia de algoritmos del encabezado.

En los tokens de un proveedor de identidad, las claves públicas están en el jwks_uri que figura en https://<issuer>/.well-known/openid-configuration. Esta página no puede descargar esa URL porque no puede conectarse a otros servidores, así que ábrela en otra pestaña y pega el JSON. Con un JWKS, la clave se elige por kid; si el token no tiene kid, se prueban todas las claves compatibles.

Las firmas ECDSA en formato DER (normalmente de 70 a 72 bytes en ES256, en lugar de 64) se detectan, se convierten y se señalan, porque JWS exige r‖s en bruto y muchas bibliotecas rechazan DER. Pegar una clave privada también funciona (se deriva la mitad pública), aunque para verificar nunca hace falta. ES256K y Ed448 no están soportados, porque WebCrypto no los incluye.

Si un token HS256 falla con un secreto del que estás seguro, a menudo el secreto está codificado en Base64 en algún punto de tu configuración y el servidor lo decodifica antes de usarlo. Cambia El secreto es a Base64 y vuelve a probar.

Por qué decodificar un token aquí es seguro

Un JWT en una cabecera Authorization es una credencial válida hasta que caduca. Si pegas un token de producción activo en una página web que lo envía a un servidor, quien controle ese servidor puede reutilizarlo contra tu API, y desde fuera normalmente no puedes saber si una página hace eso.

En esta página, la decodificación y la comprobación de firma con WebCrypto se ejecutan en tu navegador. Además, la página lleva una Content Security Policy cuya directiva connect-src solo permite /cdn-cgi/rum, donde Cloudflare Web Analytics cuenta las visitas, así que el navegador bloquea cualquier otra petición fetch, XHR, WebSocket o beacon que la página pudiera intentar. Puedes comprobarlo tú mismo: abre las herramientas para desarrolladores en la pestaña Red y pega un token, o desactiva el Wi-Fi después de cargar la página y sigue decodificando.

Aun así, usa preferiblemente tokens de prueba o a punto de caducar y, si pegaste un token de producción en algún sitio que no controlas, revoca la sesión.

Tokens caducados, nbf y desfase de reloj

exp y nbf se comparan con el reloj del verificador, y los relojes se desvían. Un token emitido por un servidor cuyo reloj va 30 segundos adelantado puede llegar con iat y nbf en el futuro y rechazarse por “todavía no válido”. Por eso las bibliotecas JWT aceptan un pequeño margen: leeway en PyJWT, clockTolerance en jsonwebtoken y jose.

Este decodificador compara los tiempos con el reloj de tu dispositivo y describe el resultado con palabras: “caducó hace 2 días” para exp, “aún no es válido” con el tiempo que falta para nbf, o un aviso de que iat está en el futuro, lo que apunta al reloj del emisor. Un valor como 1767229200000 se señala como milisegundos; leído como segundos cae decenas de miles de años en el futuro, un error habitual cuando el código usa Date.now() en lugar de Math.floor(Date.now() / 1000).

Para leer los claims en código sin verificar, basta con la biblioteca estándar de Python:

import base64, json

def b64url_decode(part):
    return base64.urlsafe_b64decode(part + "=" * (-len(part) % 4))

header_b64, payload_b64, signature_b64 = token.split(".")
print(json.loads(b64url_decode(payload_b64)))

En Node.js, JSON.parse(Buffer.from(payload_b64, "base64url").toString("utf8")) hace lo mismo. Para decisiones de autorización, usa una biblioteca que verifique la firma y fije los algoritmos aceptados. Hay más fragmentos en las páginas de Python y Node.js.

Para crear o volver a firmar un token de prueba, usa el codificador JWT. Un solo segmento se puede decodificar por separado con el decodificador Base64URL.

Preguntas frecuentes