JWT Decoder

Gerelateerde aanbevelingen

Toepassingsgevallen

• JWT online decoderen: snel een token splitsen tijdens OAuth 2.0 / OIDC login debugging om Header algoritme en Payload Claims te inspecteren
• JWT handtekeningen verifiëren: gebruik een Secret / publieke sleutel om token handtekeningen in real-time te valideren en te bepalen of een 401 'slechte handtekening', 'verlopen' of 'algoritme mismatch' is
• Test JWT's genereren tijdens integratie: geef een JWT uit in de browser met een test sleutelpaar, zonder dat de backend tijdelijk code moet wijzigen om een token te maken
• PEM ↔ JWK conversie: de OIDC IdP gaf je JWK maar de server heeft PEM nodig (of andersom) — converteer ter plekke in plaats van een OpenSSL script te schrijven
• Diagnose 401 Unauthorized: stap voor stap verloop, alg-vs-gateway match, sleutel match en PEM formattering controleren
• RS256 vs PS256 vergelijken: veel OIDC providers gebruiken standaard RS256 terwijl AWS SigV4 de voorkeur geeft aan PS256 — wissel van algoritme met hetzelfde RSA sleutelpaar en vergelijk resultaten
• JWT internals leren: verander de alg, bewerk de Payload, wissel de sleutel in de browser en zie de handtekening in real-time breken — veel sneller dan de RFC lezen

Functies

• Decoderen + Verifiëren + Genereren op één plek: plak een token om Header/Payload/Signature te splitsen, wissel van algoritme en sleutel om de handtekening te verifiëren, bewerk Claims en onderteken opnieuw om een nieuw token te maken — dekt de volledige JWT troubleshooting-keten
• Alle 13 algoritmen ondersteund: HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — dekt OAuth 2.0, OIDC, JWS, API-gateways en enterprise SSO
• PEM en JWK formaten: RSA, ECDSA en Ed25519 sleutels accepteren PEM-strings (met -----BEGIN PUBLIC KEY----- headers) en JWK JSON (kid/kty/n/e velden) — plaats direct een OIDC /.well-known/jwks.json uitvoer
• Meerdere HMAC secret invoervormen: raw UTF-8 string, hex bytes, of Base64/Base64URL-gecodeerde secret — wissel met één klik, zodat 'lijkt hetzelfde maar handtekening faalt' nooit gebeurt
• Automatische sleutelpaar generatie: RSA-2048, RSA-4096, P-256, P-384 en Ed25519 sleutelparen gegenereerd in-browser, gepresenteerd in zowel PEM als JWK formaten voor direct testgebruik
• Semantische Claims markering: exp / iat / nbf automatisch omgezet naar leesbare tijd met verlopen / nog-niet-geldig / uitgegeven status gemarkeerd; alg / typ / kid in Header apart gelabeld
• 100% client-side, zero upload: elke parse, verify en sign draait via de browser's native Web Crypto API — tokens, sleutels en payload verlaten nooit de browser, volgens het beveiligingsprincipe van 'plak nooit productietokens in willekeurige online tools'
• Eén-klik kopie: Header, Payload, Signature en het nieuw gegenereerde token zijn elk onafhankelijk kopieerbaar voor documentatie, tickets en curl commando's

Hoe te gebruiken

1. Plak of typ het token: plaats de JWT string in het invoerveld; de tool splitst automatisch Header, Payload en Signature en toont elk als JSON
2. Selecteer het algoritme: wissel tussen HS256 / RS256 / ES256 / PS256 / EdDSA; de tool leidt af uit Header.alg en markeert elke mismatch
3. Importeer een sleutel: plak een HMAC secret, een PEM string, of een JWK JSON; voor asymmetrische algoritmen, klik op 'Genereer sleutelpaar' om direct een testsleutel te krijgen
4. Verifieer of onderteken opnieuw: in Decode modus verifieer met een publieke sleutel en zie '✅ handtekening geldig / ❌ handtekening ongeldig'; in Encode modus bewerk Claims en onderteken met een private sleutel om een nieuw token te maken

Veelgestelde vragen

Wat is JWT Decoderen, Verifiëren en Genereren?

Code Examples

const crypto = require('node:crypto')

function b64url(input) {
  return Buffer.from(input)
    .toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '')
}

function hmacSign(data, secret) {
  return b64url(crypto.createHmac('sha256', secret).update(data).digest())
}

function sign(payload, secret) {
  const header = b64url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
  const body = b64url(JSON.stringify(payload))
  const signature = hmacSign(`${header}.${body}`, secret)
  return `${header}.${body}.${signature}`
}

function verify(token, secret) {
  const [h, p, s] = token.split('.')
  const expected = hmacSign(`${h}.${p}`, secret)
  const a = Buffer.from(s)
  const b = Buffer.from(expected)
  return a.length === b.length && crypto.timingSafeEqual(a, b)
}

const SECRET = 'my-super-secret-key'
const payload = { userId: 42, role: 'admin', exp: Math.floor(Date.now() / 1000) + 3600 }
const token = sign(payload, SECRET)

console.log(token)
console.log(verify(token, SECRET))       // true
console.log(verify(token, 'wrong-key'))  // false

<!doctype html>
<html>
  <body>
    <pre id="out"></pre>
    <script>
      const out = document.getElementById('out')

      const b64url = buf =>
        btoa(String.fromCharCode(...new Uint8Array(buf)))
          .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

      const b64urlStr = str => b64url(new TextEncoder().encode(str))

      async function sign(payload, secret) {
        const header = b64urlStr(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
        const body = b64urlStr(JSON.stringify(payload))
        const data = new TextEncoder().encode(`${header}.${body}`)

        const key = await crypto.subtle.importKey(
          'raw',
          new TextEncoder().encode(secret),
          { name: 'HMAC', hash: 'SHA-256' },
          false,
          ['sign']
        )

        const sig = await crypto.subtle.sign('HMAC', key, data)
        return `${header}.${body}.${b64url(sig)}`
      }

      ;(async () => {
        const token = await sign({ user: 'alice', role: 'admin' }, 'browser-demo-secret')
        out.textContent = token
      })()
    </script>
  </body>
</html>

import { jwtVerify, importSPKI } from 'jose'
import { readFile } from 'node:fs/promises'

const token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IjEifQ.payload.signature'
const publicKeyPem = await readFile('public.pem', 'utf8')

try {
  const { payload, protectedHeader } = await jwtVerify(
    token,
    await importSPKI(publicKeyPem, 'RS256'),
    {
      issuer: 'https://idp.example.com',
      audience: 'my-app',
      algorithms: ['RS256'],     // critical: algorithm whitelist blocks alg:none and HS256-substitution attacks
    }
  )
  console.log('alg =', protectedHeader.alg)
  console.log('sub  =', payload.sub)
} catch (err) {
  console.error('verify failed:', err.code, err.message)
  // common: ERR_JWT_EXPIRED / ERR_JWS_INVALID / ERR_JWS_SIGNATURE_VERIFICATION_FAILED
}

import jwt

token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.SflKxw'

# Parse (no signature check, just look at Header and Payload)
print(jwt.get_unverified_header(token))
# {'alg': 'HS256', 'typ': 'JWT'}

print(jwt.decode(token, options={'verify_signature': False}))
# {'sub': '1234'}

# Full verification
claims = jwt.decode(
    token,
    'my-super-secret-key',
    algorithms=['HS256'],
    audience='my-app',
    issuer='my-service',
)
print(claims['sub'])

Supported Video Formats

Output Example

A real MP3 file encoded to a Data URI — copy-ready:

Header (Base64URL):  eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
Payload (Base64URL): eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkphbmUgRG9lIiwiaWF0IjoxNzE2MjM5MDIyfQ
Signature:            kZJfaYjK3iCkVFL5EL9zGRZ5SmD8_x2h6B5c7pVFfVGo

Privacy & Security

Deze JWT werkbank draait 100% in je browser, ondersteund door de browser's native Web Crypto API. Het token dat je plakt, de Header, de Payload, de Signature, de HMAC Secret, eventuele RSA/ECDSA private sleutels, eventuele gegenereerde sleutelparen, en elke handtekening/verify berekening blijven op je apparaat — ze reizen nooit naar een server, worden nooit gelogd, nooit geanalyseerd, en nooit gecached. De pagina kan offline worden gebruikt zodra hij is geladen. Best practice: plak nooit langlevende productietokens of productie private sleutels in een online tool, inclusief deze. Deze tool is geschikt voor debugging, integratie testing, leren en het maken van test tokens — productie secrets en private sleutels moeten worden behandeld in een gecontroleerde, lokale omgeving.

Authoritative References

• IETFRFC 7519: JSON Web Token (JWT)
• IETFRFC 7515: JSON Web Signature (JWS)
• IETFRFC 7517: JSON Web Key (JWK)
• Auth0JWT.io — official debugger and library index
• OWASPOWASP JSON Web Token Cheat Sheet
• IETFJOSE working group overview

Troubleshooting