JWT decoder

A signed JWT is three Base64URL strings joined by dots: header.payload.signature. The decoder colors them the same way. The header and payload are JSON; the signature is raw bytes computed over the first two parts, exactly as they appear in the token.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9      header    {"alg":"HS256","typ":"JWT"}
.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6...  payload   {"sub":"1234567890","name":"John Doe",...}
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQ   signature HMAC-SHA256(header + "." + payload, secret)

The header says how the token was signed:

Base64URL is Base64 with - and _ instead of + and /, and no = padding. To decode one part by hand, use the Base64 decoder, which accepts this alphabet as is.

RFC 7519 defines seven registered claims. All are optional; which ones a server requires is up to the application. The time claims are NumericDate values: whole or fractional seconds since 1970-01-01 UTC, not milliseconds. A value with 13 digits is almost always a bug, and the decoder warns about it.

The claims view above also explains common OpenID Connect claims (nonce, azp, auth_time, email_verified) and OAuth ones (scope, client_id). To convert any timestamp by hand, use the Unix timestamp converter.

Anyone can decode a JWT, and anyone can make a new one with whatever claims they like. Only the signature tells you the token came from the issuer and was not changed. Paste the key in the verify box to check it. Which key you need depends on the algorithm in the header:

Most identity providers (Auth0, Okta, Google, Microsoft Entra ID, Keycloak, Clerk) publish their public keys at the jwks_uri listed in {issuer}/.well-known/openid-configuration. If the token has an https issuer, the fetch JWKS from iss button loads that key set for you. Only the issuer's public endpoints are contacted, and some issuers block browser requests; then copy the JWKS from the URL yourself.

The decoder also accepts PEM in every common shape: BEGIN PUBLIC KEY, BEGIN RSA PUBLIC KEY (PKCS#1) and BEGIN CERTIFICATE. Need a token to test with? Make one with the JWT generator.

JavaScript with jose, which runs in Node, Deno, Bun, browsers and edge runtimes:

import { decodeJwt, decodeProtectedHeader, jwtVerify, createRemoteJWKSet } from 'jose';

decodeJwt(token);               // payload, NOT verified
decodeProtectedHeader(token);   // header

// HS256
await jwtVerify(token, new TextEncoder().encode(secret), { algorithms: ['HS256'] });

// RS256 / ES256 from an identity provider's JWKS
const JWKS = createRemoteJWKSet(new URL('https://auth.example.com/.well-known/jwks.json'));
const { payload } = await jwtVerify(token, JWKS, { issuer: 'https://auth.example.com', audience: 'my-api' });

Node.js with jsonwebtoken:

const jwt = require('jsonwebtoken');
jwt.decode(token, { complete: true });                 // { header, payload, signature }, NOT verified
jwt.verify(token, secret, { algorithms: ['HS256'] });  // throws TokenExpiredError, JsonWebTokenError...

Python with PyJWT:

import jwt
jwt.decode(token, options={"verify_signature": False})        # NOT verified
jwt.decode(token, secret, algorithms=["HS256"], audience="my-api", leeway=30)

Go with golang-jwt v5:

claims := jwt.MapClaims{}
_, _, err := jwt.NewParser().ParseUnverified(tokenString, claims) // NOT verified

token, err := jwt.Parse(tokenString, func(t *jwt.Token) (any, error) {
    return []byte(secret), nil
}, jwt.WithValidMethods([]string{"HS256"}))

Bash, to peek at the payload (adds the padding base64 wants):

p=$(printf %s "$TOKEN" | cut -d. -f2 | tr '_-' '/+')
while [ $(( ${#p} % 4 )) -ne 0 ]; do p="$p="; done
printf %s "$p" | base64 -d | jq .

Always pass the list of algorithms you accept when verifying. RFC 8725 asks for this so a token cannot switch itself to none or to HS256 signed with your public key.