Decodificador JWT Online Gratis 2025 | Guía Completa de JSON Web Tokens

Decodificador JWT Online: Guía Completa de JSON Web Tokens 2025

¿Trabajas con APIs y autenticación basada en tokens? Los JSON Web Tokens (JWT) se han convertido en el estándar de facto para la autenticación y autorización en aplicaciones modernas. En esta guía completa, aprenderás todo sobre JWT y cómo usar nuestra herramienta gratuita de decodificación y codificación.

¿Qué es un JWT (JSON Web Token)?

Definición y propósito

Un JSON Web Token (JWT) es un estándar abierto (RFC 7519) que define una forma compacta y autocontenida de transmitir información entre partes como un objeto JSON. Esta información puede ser verificada y confiada porque está firmada digitalmente.

Características principales

1. Compacto: Tamaño pequeño para transmisión rápida via URL, POST o header HTTP
2. Autocontenido: Contiene toda la información necesaria sobre el usuario
3. Verificable: La firma digital garantiza que no ha sido alterado
4. Stateless: No requiere almacenamiento en servidor

¿Cuándo usar JWT?

1. Autenticación

El caso de uso más común. Una vez que el usuario inicia sesión, cada solicitud subsecuente incluye el JWT, permitiendo al usuario acceder a rutas, servicios y recursos permitidos con ese token.

javascript
// Ejemplo de autenticación con JWT
POST /api/login
Content-Type: application/json

{
  "username": "usuario",
  "password": "contraseña"
}

// Respuesta
{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

// Uso en solicitudes posteriores
GET /api/datos-protegidos
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

2. Intercambio de información

JWT es una buena forma de transmitir información de forma segura entre partes, ya que pueden ser firmados para verificar la identidad del remitente y asegurar que el contenido no ha sido manipulado.

3. Single Sign-On (SSO)

Permite a los usuarios autenticarse una vez y acceder a múltiples aplicaciones sin volver a iniciar sesión.

Estructura de un JWT

Un JWT consta de tres partes separadas por puntos (.):

header.payload.signature

1. Header (Cabecera)

El header típicamente consiste en dos partes:

json
{
  "alg": "HS256",
  "typ": "JWT"
}

Campos comunes

Campo	Descripción	Valores comunes
alg	Algoritmo de firma	HS256, HS512, RS256, RS512, ES256
typ	Tipo de token	JWT
kid	Key ID	Identificador de la clave usada

Algoritmos de firma

Algoritmos simétricos (HMAC):

1. HS256 (HMAC con SHA-256): Más común, usa una clave secreta compartida
2. HS384 (HMAC con SHA-384): Más seguro, clave compartida
3. HS512 (HMAC con SHA-512): Máxima seguridad HMAC

Algoritmos asimétricos (RSA/ECDSA):

1. RS256 (RSA con SHA-256): Clave pública/privada
2. RS512 (RSA con SHA-512): Más seguro que RS256
3. ES256 (ECDSA con SHA-256): Eficiente, clave pública/privada

2. Payload (Carga útil)

El payload contiene las claims (afirmaciones). Hay tres tipos de claims:

Claims registrados (RFC 7519)

Son claims predefinidos pero opcionales:

json
{
  "iss": "https://mi-app.com",
  "sub": "1234567890",
  "aud": "https://api.mi-app.com",
  "exp": 1735689600,
  "nbf": 1735603200,
  "iat": 1735603200,
  "jti": "unique-token-id-123"
}

Descripción de claims estándar:

Claim	Nombre	Descripción	Tipo
iss	Issuer	Emisor del token	String
sub	Subject	Sujeto (normalmente user ID)	String
aud	Audience	Audiencia destinataria	String o Array
exp	Expiration Time	Tiempo de expiración	NumericDate
nbf	Not Before	No válido antes de	NumericDate
iat	Issued At	Tiempo de emisión	NumericDate
jti	JWT ID	Identificador único del token	String

Claims públicos

Pueden ser definidos libremente pero deberían estar registrados en IANA JWT Registry o usar nombres con colisión resistente.

json
{
  "name": "John Doe",
  "email": "john@example.com",
  "https://mi-app.com/roles": ["admin", "user"]
}

Claims privados

Claims personalizados acordados entre las partes que usan el JWT:

json
{
  "userId": "12345",
  "role": "admin",
  "permissions": ["read", "write", "delete"],
  "department": "IT",
  "isEmailVerified": true
}

3. Signature (Firma)

La firma se crea tomando:

1. El header codificado
2. El payload codificado
3. Un secreto (o clave privada)
4. El algoritmo especificado en el header

javascript
// Pseudocódigo de cómo se genera la firma
HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

Ejemplo completo de JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Desglosado:

Header: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
Payload: eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ
Signature: SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Cómo funcionan los JWT

Flujo de autenticación completo

Usuario → Login (username/password) → Servidor
Servidor valida credenciales
Servidor genera JWT firmado
Servidor → JWT → Usuario
Usuario almacena JWT (localStorage, cookie, etc.)
Usuario → Request + JWT en Authorization header → Servidor
Servidor valida firma del JWT
Si válido → Procesa solicitud y responde
   Si inválido → Retorna 401 Unauthorized

Proceso de validación

javascript
// El servidor NO decodifica el JWT ciegamente
// Siempre valida la firma primero

Recibir JWT del header Authorization
Extraer header y algoritmo
Verificar que el algoritmo es el esperado
Validar firma usando la clave secreta/pública
Si firma es válida:
   - Decodificar payload
   - Verificar exp (no expirado)
   - Verificar nbf (ya es válido)
   - Verificar iss, aud (si aplica)
   - Procesar solicitud
Si firma inválida o expirado:
   - Rechazar con 401 Unauthorized

Decodificación de JWT

Decodificación manual (Base64 URL)

Los JWT usan Base64 URL encoding (no Base64 estándar):

javascript
// Base64 URL decode
function base64UrlDecode(str) {
  // Reemplazar caracteres URL-safe
  let base64 = str.replace(/-/g, '+').replace(/_/g, '/');
  
  // Agregar padding si es necesario
  const pad = str.length % 4;
  if (pad) {
    base64 += '='.repeat(4 - pad);
  }
  
  return atob(base64);
}

// Decodificar JWT
function decodeJWT(token) {
  const [headerB64, payloadB64, signature] = token.split('.');
  
  const header = JSON.parse(base64UrlDecode(headerB64));
  const payload = JSON.parse(base64UrlDecode(payloadB64));
  
  return { header, payload, signature };
}

Usando nuestra herramienta

Nuestra herramienta de decodificación JWT simplifica el proceso:

1. Pega el JWT en el campo de entrada
2. Decodificación automática en tiempo real
3. Visualización estructurada de header, payload y firma
4. Información de expiración con alertas visuales
5. Copia fácil de cada sección

Codificación de JWT

Proceso de creación

javascript
// 1. Crear header
const header = {
  alg: 'HS256',
  typ: 'JWT'
};

// 2. Crear payload
const payload = {
  sub: '1234567890',
  name: 'John Doe',
  iat: Math.floor(Date.now() / 1000),
  exp: Math.floor(Date.now() / 1000) + (60 * 60) // 1 hora
};

// 3. Codificar header y payload
const headerB64 = base64UrlEncode(JSON.stringify(header));
const payloadB64 = base64UrlEncode(JSON.stringify(payload));

// 4. Crear firma
const signature = HMACSHA256(
  headerB64 + '.' + payloadB64,
  'tu-secreto-super-seguro'
);

// 5. Combinar todo
const jwt = headerB64 + '.' + payloadB64 + '.' + signature;

Usando Web Crypto API

javascript
async function createJWT(payload, secret) {
  const header = { alg: 'HS256', typ: 'JWT' };
  
  // Codificar header y payload
  const headerB64 = base64UrlEncode(JSON.stringify(header));
  const payloadB64 = base64UrlEncode(JSON.stringify(payload));
  
  const message = headerB64 + '.' + payloadB64;
  
  // Importar clave
  const encoder = new TextEncoder();
  const keyData = encoder.encode(secret);
  const key = await crypto.subtle.importKey(
    'raw',
    keyData,
    { name: 'HMAC', hash: 'SHA-256' },
    false,
    ['sign']
  );
  
  // Firmar
  const signature = await crypto.subtle.sign(
    'HMAC',
    key,
    encoder.encode(message)
  );
  
  // Convertir a base64url
  const signatureB64 = base64UrlEncode(
    String.fromCharCode(...new Uint8Array(signature))
  );
  
  return message + '.' + signatureB64;
}

Seguridad de JWT

Vulnerabilidades comunes

1. Ataque de algoritmo "none"

json
// Header malicioso
{
  "alg": "none",
  "typ": "JWT"
}

Prevención:

javascript
// Siempre validar el algoritmo
if (header.alg === 'none') {
  throw new Error('Algoritmo none no permitido');
}

2. Confusión de algoritmos

Atacante cambia RS256 a HS256 y firma con la clave pública (que el servidor conoce).

Prevención:

javascript
// Especificar explícitamente el algoritmo esperado
const expectedAlgorithm = 'RS256';
if (header.alg !== expectedAlgorithm) {
  throw new Error('Algoritmo no permitido');
}

3. Información sensible en payload

El payload es solo codificado (Base64), NO encriptado. Cualquiera puede decodificarlo.

Prevención:

javascript
// ❌ NUNCA hacer esto
const payload = {
  userId: 123,
  password: 'contraseña123',  // ¡NUNCA!
  ssn: '123-45-6789',         // ¡NUNCA!
  creditCard: '1234-5678-...' // ¡NUNCA!
};

// ✅ Solo información no sensible
const payload = {
  userId: 123,
  email: 'user@example.com',
  role: 'admin',
  iat: Date.now()
};

4. Falta de validación de expiración

Prevención:

javascript
function validateToken(token) {
  const { payload } = decodeAndVerify(token);
  
  // Verificar expiración
  if (payload.exp && payload.exp < Date.now() / 1000) {
    throw new Error('Token expirado');
  }
  
  // Verificar not-before
  if (payload.nbf && payload.nbf > Date.now() / 1000) {
    throw new Error('Token aún no válido');
  }
  
  return payload;
}

5. Claves secretas débiles

javascript
// ❌ Secretos débiles
const secret = 'secret';
const secret = '123456';
const secret = 'password';

// ✅ Secreto fuerte
const secret = process.env.JWT_SECRET; // Variable de entorno
// Ejemplo: 'aB3$kL9#mN2@pQ7*rS5!tU8&vW1^xY4%zC6+dE0-fG'

6. Almacenamiento inseguro

Opciones de almacenamiento:

Método	Seguridad	Accesibilidad	Vulnerabilidad
localStorage	❌ Baja	JavaScript	XSS
sessionStorage	⚠️ Media	JavaScript	XSS
Cookie (HttpOnly)	✅ Alta	Solo servidor	CSRF (mitigable)
Memory (variable)	✅ Alta	Solo sesión	Se pierde al recargar

Recomendación:

javascript
// Usar cookie HttpOnly con SameSite
res.cookie('token', jwt, {
  httpOnly: true,  // No accesible desde JavaScript
  secure: true,    // Solo HTTPS
  sameSite: 'strict', // Protección CSRF
  maxAge: 3600000  // 1 hora
});

Mejores prácticas de seguridad

1. Usar HTTPS siempre

❌ http://api.ejemplo.com/login
✅ https://api.ejemplo.com/login

2. Establecer tiempos de expiración cortos

javascript
const payload = {
  userId: 123,
  iat: Math.floor(Date.now() / 1000),
  // Access token: 15 minutos
  exp: Math.floor(Date.now() / 1000) + (15 * 60)
};

// Usar refresh tokens para renovar

3. Implementar refresh tokens

javascript
// Access token (corta duración)
const accessToken = createJWT({
  userId: 123,
  type: 'access',
  exp: now + (15 * 60) // 15 minutos
});

// Refresh token (larga duración)
const refreshToken = createJWT({
  userId: 123,
  type: 'refresh',
  exp: now + (7  24  60 * 60) // 7 días
});

4. Lista negra de tokens (blacklist)

javascript
// Almacenar tokens revocados en Redis
const revokedTokens = new Set();

function revokeToken(token) {
  revokedTokens.add(token);
  // En producción: redis.sadd('revoked_tokens', token)
}

function isRevoked(token) {
  return revokedTokens.has(token);
  // En producción: redis.sismember('revoked_tokens', token)
}

5. Validar claims importantes

javascript
function validateClaims(payload) {
  const currentTime = Math.floor(Date.now() / 1000);
  
  // Validar expiración
  if (!payload.exp || payload.exp < currentTime) {
    throw new Error('Token expirado');
  }
  
  // Validar emisor
  if (payload.iss !== 'https://mi-app.com') {
    throw new Error('Emisor inválido');
  }
  
  // Validar audiencia
  if (payload.aud !== 'https://api.mi-app.com') {
    throw new Error('Audiencia inválida');
  }
  
  return true;
}

JWT vs otras tecnologías de autenticación

JWT vs Sesiones tradicionales

Característica	JWT	Sesiones
Almacenamiento	Cliente (token)	Servidor (session store)
Escalabilidad	✅ Excelente (stateless)	⚠️ Requiere shared storage
Tamaño	⚠️ Mayor (>200 bytes)	✅ Menor (~32 bytes ID)
Revocación	⚠️ Compleja (requiere blacklist)	✅ Fácil (borrar del store)
Cross-domain	✅ Fácil	⚠️ Requiere CORS/config
Mobile-friendly	✅ Excelente	⚠️ Limitado

JWT vs OAuth 2.0

JWT y OAuth 2.0 no son competidores, son complementarios:

1. OAuth 2.0: Framework de autorización (flujo/proceso)
2. JWT: Formato de token (implementación)

OAuth 2.0 puede usar JWT como formato de access token.

JWT vs API Keys

Característica	JWT	API Key
Información	✅ Contiene claims	❌ Solo identificador
Expiración	✅ Integrada	⚠️ Manual
Rotación	✅ Fácil (refresh token)	⚠️ Manual
User context	✅ Incluido en payload	❌ Requiere lookup
Simplicidad	⚠️ Media	✅ Alta

Implementación en diferentes tecnologías

Node.js (Express)

javascript
const jwt = require('jsonwebtoken');
const express = require('express');
const app = express();

// Generar JWT
app.post('/login', (req, res) => {
  const { username, password } = req.body;
  
  // Validar credenciales
  if (validateUser(username, password)) {
    const token = jwt.sign(
      { userId: user.id, email: user.email },
      process.env.JWT_SECRET,
      { expiresIn: '1h' }
    );
    
    res.json({ token });
  } else {
    res.status(401).json({ error: 'Credenciales inválidas' });
  }
});

// Middleware de autenticación
function authenticateToken(req, res, next) {
  const token = req.headers['authorization']?.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ error: 'Token requerido' });
  }
  
  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({ error: 'Token inválido' });
    }
    req.user = user;
    next();
  });
}

// Ruta protegida
app.get('/protected', authenticateToken, (req, res) => {
  res.json({ message: 'Acceso permitido', user: req.user });
});

Python (Flask)

python
from flask import Flask, request, jsonify
import jwt
import datetime

app = Flask(name)
app.config['SECRET_KEY'] = 'tu-secreto-super-seguro'

@app.route('/login', methods=['POST'])
def login():
    data = request.get_json()
    
    if validate_user(data['username'], data['password']):
        token = jwt.encode({
            'user_id': user.id,
            'email': user.email,
            'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
        }, app.config['SECRET_KEY'], algorithm='HS256')
        
        return jsonify({'token': token})
    
    return jsonify({'error': 'Credenciales inválidas'}), 401

Decorador de autenticación
def token_required(f):
    def decorator(args, *kwargs):
        token = request.headers.get('Authorization', '').replace('Bearer ', '')
        
        if not token:
            return jsonify({'error': 'Token requerido'}), 401
        
        try:
            data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
            currentuser = data['userid']
        except:
            return jsonify({'error': 'Token inválido'}), 403
        
        return f(current_user, args, *kwargs)
    
    return decorator

@app.route('/protected')
@token_required
def protected(current_user):
    return jsonify({'message': 'Acceso permitido', 'user': current_user})

PHP (Laravel)

php

use Firebase\JWT\JWT;
use Firebase\JWT\Key;

// Generar token
public function login(Request $request) {
    $credentials = $request->only('email', 'password');
    
    if (Auth::attempt($credentials)) {
        $user = Auth::user();
        
        $payload = [
            'iss' => 'https://mi-app.com',
            'sub' => $user->id,
            'email' => $user->email,
            'iat' => time(),
            'exp' => time() + 3600
        ];
        
        $token = JWT::encode($payload, env('JWT_SECRET'), 'HS256');
        
        return response()->json(['token' => $token]);
    }
    
    return response()->json(['error' => 'Unauthorized'], 401);
}

// Middleware
public function handle($request, Closure $next) {
    $token = $request->bearerToken();
    
    if (!$token) {
        return response()->json(['error' => 'Token required'], 401);
    }
    
    try {
        $decoded = JWT::decode($token, new Key(env('JWT_SECRET'), 'HS256'));
        $request->user = $decoded;
        return $next($request);
    } catch (Exception $e) {
        return response()->json(['error' => 'Invalid token'], 403);
    }
}

Casos de uso avanzados

1. Multi-tenancy

javascript
const payload = {
  userId: 123,
  tenantId: 'company-abc',
  role: 'admin',
  permissions: ['read:all', 'write:own', 'delete:own']
};

2. Microservicios

javascript
// Gateway valida el token una vez
// Los microservicios confían en el token validado

// Gateway
if (validateToken(token)) {
  // Propagar a microservicios
  forward(request, { headers: { 'X-User-Id': payload.userId } });
}

// Microservicio
// Solo lee el header, no re-valida
const userId = request.headers['x-user-id'];

3. Delegación de permisos

javascript
const payload = {
  userId: 123,
  actingAs: 456, // Usuario 123 actúa como 456
  scope: ['read:profile', 'write:posts'],
  delegatedBy: 456
};

Herramientas y librerías

Librerías populares

Node.js:

1. jsonwebtoken: Más popular, fácil de usar
2. jose: Moderna, completa, soporta JWE

Python:

1. PyJWT: Estándar de facto
2. python-jose: Completa, soporta JWE

PHP:

1. firebase/php-jwt: Muy usada
2. lcobucci/jwt: Moderna, POO

Java:

1. jjwt: Completa y robusta
2. auth0/java-jwt: Mantenida por Auth0

Depuración y testing

jwt.io:

1. Decodificador online oficial
2. Permite verificar firma
3. Incluye debugger

Nuestra herramienta:

1. 100% privada (local)
2. Decodificación y codificación
3. Información de expiración
4. Sin almacenamiento de claves

Nuestra herramienta: JWT Decoder/Encoder

Características principales

✨ Decodificación instantánea:

1. Pega tu JWT y ve el contenido inmediatamente
2. Visualización clara de header, payload y firma
3. Información de expiración con alertas

🔐 Codificación segura:

1. Crea JWTs personalizados
2. Soporte para HMAC SHA256
3. La clave secreta NUNCA se almacena

🛡️ 100% privado:

1. Todo procesado en tu navegador
2. Sin envío a servidores
3. Sin almacenamiento de datos

📋 Copiar con un click:

1. Copia header, payload o JWT completo
2. Formato JSON indentado

¿Por qué usar nuestra herramienta?

1. Privacidad garantizada: A diferencia de otras herramientas online, todo el procesamiento ocurre localmente
2. Gratuita: Sin límites, sin registro, sin costos ocultos
3. Educativa: Incluye documentación completa sobre JWT
4. Rápida: Decodificación en tiempo real
5. Completa: Decodifica Y codifica tokens

Prueba el Decodificador JWT →

Preguntas frecuentes (FAQ)

¿Los JWT son seguros?

Los JWT son seguros cuando se usan correctamente. La seguridad depende de:

1. Usar HTTPS para transmisión
2. Claves secretas fuertes
3. Validación adecuada de firma y claims
4. No almacenar información sensible en el payload

¿Puedo decodificar un JWT sin la clave secreta?

Sí, DECODIFICAR no requiere la clave. El JWT está solo codificado en Base64, no encriptado. Sin embargo, para VERIFICAR la firma sí necesitas la clave secreta.

¿Debo almacenar JWTs en localStorage?

No es recomendado. localStorage es vulnerable a ataques XSS. Mejor usar cookies HttpOnly o mantener el token en memoria.

¿Cómo revoco un JWT?

Los JWT son stateless, pero puedes:

1. Implementar una blacklist de tokens
2. Usar tiempos de expiración cortos
3. Implementar refresh tokens
4. Cambiar la clave secreta (revoca todos)

¿Qué diferencia hay entre access token y refresh token?

1. Access token: Corta duración (15 min), usado para acceder a recursos
2. Refresh token: Larga duración (7 días), usado solo para obtener nuevos access tokens

¿Es seguro usar HS256?

Sí, si usas una clave secreta fuerte y la mantienes segura. Para mayor seguridad en producción, considera RS256 (asimétrico).

¿Por qué mi JWT es tan largo?

El tamaño del JWT depende de la cantidad de información en el payload. Mantén el payload mínimo para reducir el tamaño.

Conclusión

Los JSON Web Tokens son una herramienta poderosa y versátil para autenticación y autorización en aplicaciones modernas. Cuando se implementan correctamente siguiendo las mejores prácticas de seguridad, ofrecen una solución escalable, eficiente y segura.

Puntos clave:

🔑 Estructura clara: Header, Payload, Signature

🛡️ Seguridad primero: Validar siempre la firma

⏱️ Expiración: Usar tiempos cortos con refresh tokens

🔒 Privacidad: Nunca incluir información sensible

📚 Estándar: Seguir RFC 7519

🌐 Universal: Soportado en todos los lenguajes

¿Listo para decodificar y codificar JWTs?

Usa el Decodificador JWT →

Nuestra herramienta gratuita te permite inspeccionar y crear JWTs de forma segura, rápida y privada. Todo procesado localmente en tu navegador.

Explorar más herramientas de desarrollo