JWT Decoder and Verifier

How to decode a JWT

A JSON Web Token is three Base64URL strings joined by dots: header.payload.signature. Decoding simply reverses the Base64URL encoding of the first two parts to reveal JSON — no key is needed, which is exactly why a JWT payload must never hold secrets. Paste a token above (with or without the Bearer prefix) and the decoder shows:

• Header — the signing algorithm (alg), token type (typ) and often a key ID (kid).
• Payload — the claims: who the token is about, who issued it, who it is for, when it expires, plus any custom claims such as roles or scopes.
• Claim table — each registered claim explained, with timestamps converted to UTC, IST and your local time and an Expired, Not yet valid or Active badge.

How to verify a JWT (JWT verify)

Verifying proves the token was issued by someone holding the key and has not been modified. It has two parts, and a backend must do both on every request:

1. Signature: recompute the signature over header.payload with the expected algorithm and key, and compare. In the panel above, paste the HMAC secret for HS* tokens, or the issuer’s public key for RS*, PS* and ES* tokens. Identity providers publish these keys at a JWKS URL, typically https://<issuer>/.well-known/jwks.json; paste the whole JWKS and the matching kid is chosen for you.
2. Claims: reject the token if exp is in the past or nbf in the future (allow a small clock skew, usually 30–60 seconds), and check that iss and aud match what your service expects.

Always pin the algorithm on the server side. Accepting whatever alg the token declares enables the classic attacks: alg: none tokens with no signature, and HS256 tokens “signed” with an RSA public key used as an HMAC secret.

Registered JWT claims (RFC 7519)

Timestamps are Unix seconds. To convert one by hand, use the Unix timestamp converter.

JWT signing algorithms compared

Decode and verify JWTs in code

JavaScript (Node.js, jose)

import { jwtVerify, createRemoteJWKSet, decodeJwt } from "jose";
decodeJwt(token);                                   // decode only, no verification
const JWKS = createRemoteJWKSet(new URL("https://issuer.example.com/.well-known/jwks.json"));
const { payload } = await jwtVerify(token, JWKS, {
  issuer: "https://issuer.example.com", audience: "api.example.com", algorithms: ["RS256"],
});

Python (PyJWT)

import jwt
jwt.decode(token, options={"verify_signature": False})          # decode only
jwt.decode(token, "your-256-bit-secret", algorithms=["HS256"])   # verify HS256
jwt.decode(token, public_key_pem, algorithms=["RS256"], audience="api.example.com")

Java (jjwt)

Claims claims = Jwts.parser()
    .verifyWith(Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8)))
    .build()
    .parseSignedClaims(token)
    .getPayload();

Go (golang-jwt)

tok, err := jwt.Parse(s, func(t *jwt.Token) (any, error) {
    return []byte("your-256-bit-secret"), nil
}, jwt.WithValidMethods([]string{"HS256"}), jwt.WithAudience("api.example.com"))

Bash (decode only)

cut -d. -f2 <<< "$TOKEN" | tr '_-' '/+' | base64 -d 2>/dev/null | jq .

Common questions