JWT Decoder

Decode a JWT (JSON Web Token) to inspect its header, payload, and signing algorithm instantly in your browser. Check an access token's expiration, verify a custom claim, or share a decoded token with a teammate, all without sending the token to a server.

Usage examples

Checking what's inside a login token

Curious what claims (user ID, roles, etc.) your server's JWT access token carries? Paste it in and see the header and payload as readable JSON instantly.

Checking when a token expires

Debugging why users keep getting logged out? The exp claim is shown as a human-readable date and time, with a badge telling you if it's already expired.

Checking the signing algorithm

Not sure if a token is HS256 or RS256? The header's alg value is shown right in the summary panel.

Sharing a decoded token with a teammate

Want a coworker to look at the same token? Click "Copy share link" to copy a link containing the token you're viewing — anyone who opens it sees the same token decoded instantly.

Inspecting an OAuth access token from a third-party API

An OAuth provider handed you an opaque-looking access token, but it's actually a JWT? Paste it in to see the scope, audience (aud), and issuer (iss) claims without writing a single line of code.

Verifying a custom claim made it into the token

Just added a custom claim like "role": "admin" or "tenantId" to your token issuer? Paste a freshly issued token here to confirm the claim is actually present and spelled correctly before you wire up authorization logic around it.

Comparing two tokens issued moments apart

Trying to figure out why a refreshed token behaves differently from the old one? Decode both side by side and compare their payloads to spot exactly which claims changed.

Double-checking a token before pasting it into a bug report

About to paste a JWT into a GitHub issue or Slack thread? Decode it first so you can confirm exactly what's inside and scrub any sensitive claims (like email or internal IDs) before sharing.

Quick reference

Common JWT header segments

Base64URLHeader
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9{"alg":"HS256","typ":"JWT"}
eyJhbGciOiJIUzM4NCIsInR5cCI6IkpXVCJ9{"alg":"HS384","typ":"JWT"}
eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9{"alg":"HS512","typ":"JWT"}
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9{"alg":"RS256","typ":"JWT"}
eyJhbGciOiJSUzUxMiIsInR5cCI6IkpXVCJ9{"alg":"RS512","typ":"JWT"}
eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9{"alg":"ES256","typ":"JWT"}
eyJhbGciOiJQUzI1NiIsInR5cCI6IkpXVCJ9{"alg":"PS256","typ":"JWT"}
eyJhbGciOiJFZERTQSIsInR5cCI6IkpXVCJ9{"alg":"EdDSA","typ":"JWT"}
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9{"typ":"JWT","alg":"HS256"}
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9{"typ":"JWT","alg":"HS512"}
eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9{"typ":"JWT","alg":"RS256"}
eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NiJ9{"typ":"JWT","alg":"ES256"}

Frequently asked questions

Does this tool verify the signature?

No. Verifying a signature requires the secret (or public) key that only the issuer should know, and typing that into any website is a security risk. This tool only decodes and displays the header and payload — it never checks whether the signature is valid.

How does the share link carry the token?

Clicking "Copy share link" copies a link with ?jwt=<token> appended — so the token itself is exposed right in the URL. Opening that link shows this token instantly (instead of whatever was previously saved) and updates local storage to match. If you share the link over chat or email, the token can end up sitting in that history, so think twice before sharing a link built from a real, valid production token.

Is the token I paste sent to a server?

No. All decoding happens entirely in your browser and is never sent to a server. So you can pick up where you left off on your next visit, the token you type is saved only in your browser's local storage (localStorage) — it's not shared across devices or browsers. Clearing the input also clears what's saved. That said, it's still good practice to avoid pasting real production tokens into random websites.

What are exp, iat, and nbf?

These are common standard JWT claims. iat is when the token was issued, exp is when it expires, and nbf ("not before") means the token isn't valid until that time. They're stored as Unix timestamps (seconds since Jan 1, 1970), which this tool converts into human-readable dates.

I'm getting an invalid format error.

A JWT must have exactly 3 dot-separated parts (header.payload.signature). Check whether stray whitespace got mixed in, or whether the token was copied incompletely.

Is a JWT's payload encrypted?

No — this is one of the most common misconceptions about JWTs. The header and payload are only base64url-encoded, not encrypted, per RFC 7519. Base64url is a reversible encoding, not a cipher, so anyone who gets hold of a token can decode and read every claim in it without needing any secret or key — which is exactly what this tool does. The signature exists to let the issuer verify the token hasn't been tampered with and really came from them; it does not hide the payload's contents. If a token carries sensitive data, treat it as readable plaintext and never put truly secret information (passwords, raw card numbers, etc.) inside a claim.

What exactly does "base64url" mean, and how is it different from regular base64?

Base64url is the same idea as standard base64 — encoding arbitrary bytes as text — but it swaps the two characters that aren't URL-safe: + becomes -, / becomes _, and trailing = padding is typically omitted. JWTs use base64url for the header and payload specifically because the resulting token needs to travel safely inside URLs, HTTP headers, and cookies without extra escaping.

Could someone forge a token using what this tool shows me?

Seeing the decoded header and payload doesn't give you the ability to forge a valid token. To produce a token that a server will accept, you'd need to re-sign it with the issuer's secret key (for HS256-style algorithms) or private key (for RS256/ES256-style algorithms) — information this tool never asks for or has access to. Editing the decoded JSON and re-encoding it by hand would change the payload but invalidate the signature, so a correctly implemented server would reject it.

Why does the signature section look like random characters instead of JSON?

Unlike the header and payload, the signature isn't JSON that got encoded — it's the raw cryptographic output of signing the header and payload with the algorithm named in the header (e.g. HMAC-SHA256 or RSA-SHA256). That's why decoding it further doesn't produce readable text; this tool just shows it as the base64url string it already is.