JWT Decoder

Gerelateerde aanbevelingen

Wat is JWT Decoderen, Verifiëren en Genereren?

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

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

Output Example

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

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

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

Codevoorbeelden

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'])

5 families van JWT-handtekeningalgoritmen: welke kies je?

JWT is niet één enkel algoritme — de 5 families maken elk andere afwegingen op het gebied van sleuteltype, prestaties, beveiliging en ecosysteemondersteuning. Kies eerst op basis van het scenario en je vermijdt veel omwegen.

Best Practices

Veelgestelde vragen

Probleemoplossing

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.

Supported Video Formats

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