JWT Decoder

Decode and inspect JSON Web Tokens (header, payload, signature, expiry) entirely in your browser.

runs locally on your browser. Your data never leaves your device.

Showing example token preview; paste your own to replace

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

HeaderPayloadSignature
{
  "alg": "HS256",
  "typ": "JWT"
}
{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Issued atJan 18, 2018, 01:30 AM UTC

Common Use Cases

Inspect the claims in an auth token during API debugging
Check when a token expires to diagnose authentication errors
Verify which roles or permissions a user's token contains
Decode a token from an Authorization header in an HTTP request log

About JWT Decoder

JSON Web Tokens (JWTs) are the standard mechanism for stateless authentication in modern web applications. When you log into a service that uses JWT-based auth, the server issues a token that encodes your identity and permissions in a self-contained, cryptographically signed package. Your browser sends this token in the `Authorization: Bearer <token>` header on subsequent requests, and the server can verify your identity without consulting a database.

A JWT consists of three Base64url-encoded parts separated by dots: the header (algorithm and token type), the payload (claims such as user ID, expiry time, and roles), and the signature (a cryptographic hash that proves the token wasn't tampered with). The header and payload are just encoded, not encrypted, so their contents are visible to anyone who holds the token. This is by design: the secrecy of the payload is not the point; the integrity guarantee (signature verification) is.

This is why it's safe and useful to decode a JWT without the signing secret: you're simply reading the un-encrypted claims. The signature verification step requires the secret or public key and is only necessary if you need to confirm the token is genuine. Common claims you'll see in JWTs include `sub` (subject/user ID), `iat` (issued at, a Unix timestamp), `exp` (expiry, a Unix timestamp), `aud` (audience), `iss` (issuer), and application-specific claims like `role` or `email`.

This decoder shows you all three parts formatted for readability, the expiry time as a human-readable date, and a warning if the token has already expired.

Frequently Asked Questions

Is it safe to paste my JWT token into a decoder?
It is safe to use this tool specifically because it runs entirely in your browser, so your token is never sent to any server. However, you should be cautious with online tools that are not explicitly client-side, because a JWT contains your identity claims and a stolen token can be used to impersonate you until it expires. Treat JWT tokens like session cookies.
Can I verify the JWT signature with this tool?
This tool decodes the header and payload but does not verify the signature, because signature verification requires the server's secret key (for HMAC algorithms like HS256) or the server's public key (for RSA/ECDSA algorithms like RS256). Signature verification is always performed server-side. This tool is for reading and inspecting token contents.
What is the 'exp' claim and why does it matter?
The 'exp' (expiration time) claim is a Unix timestamp that indicates when the token expires. After this time, the token must be rejected even if the signature is valid. Short-lived tokens (15 minutes to a few hours) are more secure because a stolen token becomes useless quickly. This tool shows the expiry as a human-readable date and warns you if the token is expired.
What is the difference between HS256 and RS256?
HS256 (HMAC-SHA256) is a symmetric algorithm: the same secret key is used to both sign and verify the token. It's simple but requires the same secret on both the issuing server and any verifying server. RS256 (RSA-SHA256) is asymmetric: a private key signs the token and a public key verifies it. RS256 is preferred in distributed systems where multiple services need to verify tokens without sharing a secret.