The Three-Part JWT Structure
A JSON Web Token is a single string made of three parts separated by dots (.): header.payload.signature. Each part is encoded separately using base64url (a URL-safe variant of base64 that replaces + with - and / with _, typically without padding) before being joined together.
| Part | Contains | Purpose |
|---|---|---|
| Header | A small JSON object, e.g. {"alg":"HS256","typ":"JWT"} | Describes the token type and the signing algorithm used |
| Payload | A JSON object of claims - who, when, what | Carries the actual data the token is asserting |
| Signature | A cryptographic signature over the header and payload | Lets a server with the right key confirm the token wasn't altered |
Because the header and payload are only base64url-encoded, not encrypted, they're plain text to anyone who decodes them - that's the whole point of this tool, and exactly why a JWT should never carry secret data in its payload.
Common JWT Claims Explained
Decoding vs. Verifying: The Critical Distinction
It's easy to conflate "I can read this token" with "this token is genuine" - but they are two completely different operations. Decoding is simply reversing the base64url encoding to reveal the JSON that was already sitting inside the token in plain sight; anyone, including an attacker, can do this with no special knowledge at all. This tool - and every purely client-side JWT tool - only decodes.
Verifying is cryptographically proving the signature was produced by the real issuer and that the header/payload haven't been tampered with since. That requires the secret key (for symmetric algorithms like HS256) or the issuer's public key (for asymmetric algorithms like RS256), neither of which lives anywhere near your browser - it stays on the issuing server, exactly where it's supposed to. So a decoded payload is safe to inspect and debug, but it must never be treated as trusted or authentic input for a security decision until a server with the signing key has verified it.
Common JWT Use Cases
Frequently Asked Questions
No. Decoding only reveals the JSON already sitting inside the token - anyone can do it, including an attacker. Proving a token is genuine requires verifying its signature with the issuer's secret or public key, which never reaches this browser-only tool.
No. Everything is decoded entirely in your browser using JavaScript - your token, including any sensitive claims inside it, never leaves your device.
sub identifies who the token is about, typically a user ID. iat records when the token was issued, as a Unix timestamp. exp is the Unix timestamp after which the token must be treated as expired and rejected, even if its signature is still valid.
iss (issuer) identifies who created and signed the token. aud (audience) identifies who the token is intended for. A service should check both - reject tokens from an untrusted issuer, and reject tokens meant for a different audience than itself.
Because the header and payload are only base64url-encoded, not encrypted - anyone can decode them, which is exactly what this tool does. Only the signature requires a secret key, and that's what makes the token trustworthy, not the payload itself. JWTs should never contain secret data in the payload.
JWTs are most often used as session/authentication tokens after a user logs in, and as bearer tokens for authorizing requests to an API - the server issues a signed token once, and every subsequent request includes it instead of re-sending credentials.