Hacks VitaeAll tools
Hacks Vitae Tools
Precision · Instant · Private

Read a JWT without sending it anywhere

Paste a token to read its header and payload. It is decoded in this tab, which matters more than usual here: a token is a credential, and pasting one into a website means handing that credential over. Reading a token is not the same as accepting it, and the difference is set out below.

SYSTEM ● ONLINE · LOCAL COMPUTE · ZERO UPLOAD
UNIT // JWT.DECODELIVE
—
Algorithm
0
Claims
—
Expiry
What it does

It reads two of the three parts

// In short

RFC 7519 defines a JSON Web Token as “a compact, URL-safe means of representing claims to be transferred between two parties”. In the form you usually meet, it is three pieces joined by dots: a header, a payload of claims, and a signature. This page Base64URL-decodes the first two and shows you the JSON inside. The signature is displayed and left alone.

Decoding is not verifying, and the standard says so

Anyone holding a token can read its claims; that is what this page does. Whether a token should be believed is a separate question, answered by checking the signature with the right key. RFC 7515 puts the bar plainly: “in all cases, at least one JWS Signature value MUST successfully validate, or the JWS MUST be considered invalid” (5.2). RFC 7519 adds that if any step of validating a JWT fails, the token “MUST be rejected” (7.2).

This tool does neither of those things, and could not: it does not have your keys. Treat what you see here as what the token claims, not as what is true.

One claim is worth knowing by name. exp “identifies the expiration time on or after which the JWT MUST NOT be accepted for processing” (RFC 7519, 4.1.4). It is a count of seconds, so the readout converts it to a date you can read.

FAQ

Frequently asked questions

No, and that distinction matters. RFC 7515 (5.2) requires that at least one signature validate “or the JWS MUST be considered invalid”. Verification needs the signing key, which stays in your own system.
Header, payload and signature, joined by dots and each Base64URL-encoded. The header names the algorithm; the payload carries the claims; the signature is what a verifier checks.
The expiry. RFC 7519 (4.1.4) calls it “the expiration time on or after which the JWT MUST NOT be accepted for processing”, counted in seconds, which this page shows as a date.
The decoding happens in your browser and nothing is sent, which you can confirm in the Network tab. The habit worth keeping is still to prefer an expired or test token when one will do.
No. A JWT may instead be encrypted (RFC 7519 allows a JWE form), and then there is nothing to read without the key.
Limits

What this tool is not for

  • It does not verify signatures. No key input, no verification, by design.
  • It does not tell you a token is authentic. The alg value in the readout is copied out of the token's own header, which is the one part an attacker controls freely.
  • The Expiry readout only reads exp. When it says "Valid" it means the exp timestamp has not passed. It is not a verdict on the token.
  • It does not check revocation. A perfectly signed, unexpired token may have been withdrawn server-side. There is no way to see that from the token.
  • It reads text, not cookies or headers. You have to paste the token yourself.
Worked example

Reading a token part by part

The field above arrives pre-filled with the standard demonstration token, so you can see the shape of the output before pasting anything of your own. Every JWT has the same three-segment layout:

SegmentDecodes toWhat this tool does
Header{"alg":"HS256","typ":"JWT"}Decoded and shown
Payload{"sub":"1234567890","name":"John Doe","iat":1516239022}Decoded, shown, claims counted
SignatureRaw bytes, not textIgnored entirely

Now the part worth practising. Picture a payload such as {"sub":"user-0001","exp":1700000000} and read it as a reviewer rather than a developer. (The demonstration token has no exp, which is why its Expiry readout says No exp.) sub is the subject, the thing the token is about. exp is an expiry expressed in seconds since 1 January 1970, which is why the tool multiplies it by a thousand before turning it into a date — paste a value in milliseconds by mistake and you will see an expiry tens of thousands of years away. That wrong-looking date is a useful signal, not a bug.

The other registered claims defined by the JWT specification are worth knowing by name, because seeing which ones are missing is often the finding. iss is the issuer, aud the intended audience, nbf the not-before time, iat the issued-at time, and jti a unique identifier for the token. Where one issuer serves several applications, RFC 8725 (3.9) says the token “MUST contain an ‘aud’ (audience) claim”, and the receiving application must reject it if the audience is missing or not its own. A token with no exp never expires on its own.

The mistake

Two ways people get this wrong

Treating the payload as secret. The payload is Base64URL, not ciphertext. Base64URL is a transport alphabet — the same idea as ordinary Base64 encoding, with - and _ swapped in so the result survives a URL. Anyone holding the token can read every claim in it, in a browser, in a second. Do not put anything in a JWT payload you would not print on a postcard: no internal notes, no roles you would rather users could not enumerate, and certainly no secondary credential. If a value genuinely must be confidential, it does not belong in the token at all; keep it server-side and reference it by an opaque id.

Trusting the alg header. The header is part of the token, so whoever sends the token chooses what it says. The specification even defines (RFC 7519, 6) none, meaning "unsecured, no signature". A verifier that reads alg and does whatever it says can be handed a token claiming none, or one claiming HMAC when the server expected RSA. RFC 8725, the best-current-practice document for JWTs, puts the fix on the verifier: libraries “MUST enable the caller to specify a supported set of algorithms and MUST NOT use any other algorithms” (3.1).

Why local matters

A pasted token is a live credential

JWTs are very often used as bearer tokens. RFC 6750 puts it plainly: “Any party in possession of a bearer token (a ‘bearer’) can use it to get access to the associated resources”. Holding one is the authorisation — no password needed, no second factor. So when you copy an access token out of your browser's network tab to find out why an endpoint keeps returning 403, and paste it into a decoder that runs on a server, that server now holds a working key to your account for as long as the token lives.

Nothing you paste here is sent to a server. The script contains no fetch, no XMLHttpRequest and no analytics beacon; it reads the textarea, splits the string, and writes into two other textareas. Confirm it the hard way: open your network panel, paste a token, and watch that no request is made. Or switch the Wi-Fi off and use the page anyway.

The same reasoning runs through the rest of the set. Hashing uses the browser's own Web Crypto API, UUIDs come from crypto.getRandomValues rather than a remote generator, and JSON formatting never sees a server — which matters when the JSON is a customer record pulled from production. Full list on the developer tools page.

Sources

Where these facts come from

Last reviewed 21 October 2026

4 more

More developer tools

All 18 →

Everything here runs in your browser. Browse all the tools, or start from the home page.

Ask an assistant about this page

Opens in a new tab with this page and the question already filled in.