Free tool
JWT decoder
Decode the header and payload of a JSON Web Token and see the claims, expiry and algorithm at a glance.
Runs entirely in your browser
What this checks
- The algorithm in the header, including the unsigned alg "none"
- The expiry claim, and whether the token is already expired
- How long the token stays valid — a long-lived token cannot be revoked
- The not-before and issued-at claims, which reveal clock skew
- Whether iss, sub and aud are present, as RFC 8725 recommends
- Claims that carry secrets or personal data, which the token exposes to anyone holding it
Your data stays in this tab
This tool runs as JavaScript in your browser. Whatever you paste is read by the page and analysed locally — it is never uploaded, logged or stored, and the tool does not send any request to the API you are inspecting. Close the tab and it is gone.
What a JWT actually is
A JSON Web Token is three base64url-encoded parts separated by dots:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signatureThe first part is the header — the algorithm and any key identifier. The second is the payload — the claims. The third is the signature. Both of the first two are encoded, not encrypted: anyone with the token can read them, which is why a token is not a place to put a password, a card number or anything else you would not paste into a chat window.
The signature is what stops a token from being modified. It is computed over the first two parts with a key only the issuer holds (for asymmetric algorithms such as RS256, the issuer holds the private key and verifiers hold only the public one). This tool deliberately does not verify it, because verification needs the key, and a signing key pasted into a webpage is a much worse outcome than an unverified decode.
The claims that matter
exp— expiry, in seconds since the epoch. A token without one never expires.nbf— not valid before. A token that is not yet valid usually means the issuer and the verifier disagree about the clock.iat— issued at. Useful for spotting replay and for measuring token lifetime.iss,sub,aud— who issued it, who it is about, and who it is for. RFC 8725 recommends validating all three, and rejecting anything that does not match what you expect.
A worked example
Press Use an example and the tool builds a token with a current timestamp, so the expiry check is live rather than a snapshot that goes stale. Decoding it gives:
// header
{
"alg": "HS256",
"typ": "JWT"
}
// payload
{
"iss": "https://issuer.example.com",
"sub": "user-123",
"iat": 1730000000,
"exp": 1730040000
}The token is valid for 4000 seconds — a little over an hour. The algorithm is HS256, so the check reports it as a symmetric scheme: the server holds the signing secret, so anyone who can read the server's configuration can mint tokens that verify. Where the architecture allows it, an asymmetric algorithm means a verifier only ever needs the public key. The missing aud claim is reported as a note, because RFC 8725 recommends validating it along with iss andsub.
Try decoding a token whose payload contains"password" and the tool reports it as a failure rather than a note, because the payload is readable by anyone who has the token.
Questions
Does this verify the signature?
No, and it cannot. Verifying a signature means recomputing it with the key that signed the token — which for HS256 is the shared secret, and for RS256 needs the public key plus the exact algorithm the server expects. Sending a signing key to a webpage is precisely the thing you should never do, so this tool stops at decoding. The signature bytes are shown so you can see whether a signature is present at all.
Is the token I paste sent anywhere?
No. Decoding happens with base64url and JSON.parse in your browser. The token never leaves the page, is never logged and is never stored. If you paste a live token here, treat the tab as part of the token's blast radius anyway — a browser extension with page access can read the input field.
Why does it say a JWT payload is not encrypted?
Because it is not. A JWT consists of three base64url-encoded parts separated by dots. The first two are encoded, not encrypted, and any browser can decode them in a few lines. The signature exists to prove the token was not modified, and to prove who issued it — it does not hide the contents. If you need secrecy, the contents do not belong in a JWT.
What is the "alg: none" finding?
A token whose header says alg is none carries no signature at all, so anyone can mint one that verifies. Some libraries accepted unsigned tokens by accident for years. The check also looks at how the algorithm is treated overall: RFC 8725 recommends pinning the algorithms you accept rather than trusting whatever the token says it used, because a verifier that honours the token's own alg field can be walked into accepting a weaker algorithm than you intended.
Can I use this to check whether a token is still valid?
It tells you what the expiry claim says, and whether that expiry has passed — which is useful context. It cannot tell you whether the token would actually be accepted by your server, because that depends on the signature and on the server's own checks. A token this tool shows as valid may still be rejected.
Get EndpointCheck when it launches
We're building automated API security scanning for teams that ship REST APIs. It isn't live yet. Join the waitlist and we'll email you once when it is.