Skip to main content
JD

JWT Decoder

Paste a JSON Web Token and instantly see its decoded header and payload, with a human-readable expiry date.

Did you like the tool? Thanks!
Share:
Decode only — signature is not verified. This tool reads the header and payload of a JWT locally in your browser. It does not check the token's signature, so it cannot prove the token is authentic or untampered. Never trust a decoded payload as valid without verifying the signature server-side against the correct secret or public key.


        

        

    

How to Use JWT Decoder

Paste a JWT into the box. The token is split on its dots, the header and payload segments are base64url-decoded and pretty-printed as JSON, and if an `exp` claim is present its expiry is shown in your local timezone. This tool only decodes — it does not verify the signature, since no secret or public key is provided, so the payload should never be treated as trustworthy without server-side verification.

About JWT Decoder

A JSON Web Token (JWT, defined in RFC 7519) is a compact, URL-safe way of representing a set of claims — statements about a user or session, like "user ID 42, expires at this time, role: admin" — as a signed piece of text that can be passed around in a URL, a cookie, or an HTTP header. A JWT has three dot-separated parts: a header describing the token type and signing algorithm, a payload containing the actual claims, and a signature that lets whoever holds the correct secret (or public key, for asymmetric algorithms) verify the header and payload have not been tampered with since they were signed. The header and payload are not encrypted — they are base64url-encoded, which is a reversible encoding, not a cipher. Anyone who has a JWT can decode its header and payload just by reversing that encoding, with no key, no password, and no special access required; that is exactly what this tool does. This is a deliberate and normal property of JWTs, not a flaw — the security of a JWT comes entirely from its signature, which proves the claims were issued by whoever holds the signing key and have not been altered since, not from hiding the claims' contents. Because of this, JWTs should never contain sensitive data like passwords or full card numbers in their payload — anyone who intercepts the token can read every claim inside it. This is also exactly why this tool's prominent warning matters: decoding a JWT tells you what the payload claims, but it tells you nothing about whether those claims are genuine. A token with a header and payload that decode cleanly could still have an invalid, expired, or entirely absent signature, or have had its payload altered by an attacker who does not know the signing secret but is testing whether anyone bothers to check. Verifying a signature requires the actual signing secret (for HMAC algorithms like HS256) or the issuer's public key (for asymmetric algorithms like RS256), neither of which this decode-only tool has or asks for — and that is intentional, since a tool that could "verify" without the real key would either be lying about verification or would need you to paste a secret into a webpage, which is not something you should ever do with a real signing key. A common practical use of this tool is debugging — checking that your backend issued a token with the claims you expect, confirming an `exp` (expiry) timestamp is set correctly, or inspecting a third-party token during integration work. It is not a substitute for your application's own signature verification, which should always happen server-side using a trusted library and the real secret or public key before any claim in the token is acted upon.

Details & Tips

How decoding works, step by step: the token is split on its two dots into exactly three segments — header, payload, signature. The header and payload segments are base64url-encoded (a URL-safe variant of base64 that replaces `+`/`/` with `-`/`_` and typically omits padding `=` characters); this tool restores standard base64 padding, decodes the resulting bytes, and interprets them as UTF-8 text, which is then parsed as JSON and pretty-printed. The signature segment is not decoded at all — it is opaque, cryptographically-derived bytes with no independent meaning without the signing key, so it is shown as-is rather than being (incorrectly) treated as decodable data. The `exp` claim, when present in the payload, is a Unix timestamp (seconds since 1 January 1970 UTC) marking when the token expires. This tool converts it to your browser's local timezone and displays whether the token is already expired or still valid, purely as a convenience for reading — this check is informational only and is not a substitute for your server rejecting expired tokens during real signature verification. Other common standard claims you may see include `iat` (issued-at time), `nbf` (not-before time), `iss` (issuer), `sub` (subject, typically the user ID), `aud` (intended audience), and `jti` (a unique token ID) — none of these are verified by this tool either, they are simply decoded and displayed. Malformed input is handled explicitly rather than crashing: if the pasted text does not split into exactly three dot-separated parts, if either segment is not valid base64url, or if the decoded bytes are not valid JSON, the tool shows a specific inline error describing which check failed, instead of a blank result or a browser console error. Why this tool will never add signature verification: doing it properly would require you to paste your application's actual signing secret or private key into a web page — the exact thing you should never do with a real credential, even on a tool you trust, because it defeats the purpose of keeping that key secret. Legitimate signature verification belongs in your backend code, using a well-maintained JWT library (there are mature ones for essentially every language) that has the real key available server-side and never exposes it to a browser. If you need to confirm a token's signature is valid, do that check in your application's own code or a trusted server-side script — not in any browser-based decoder, this one included.

Frequently Asked Questions

Does this tool verify the JWT signature?
No. It only decodes the header and payload for reading. Verifying a signature requires the original signing secret or public key, which this tool never asks for and never has — a decoded payload should not be trusted as authentic without your server verifying the signature separately.
Is it safe to paste a real production JWT into this tool?
The token is decoded entirely in your browser and never transmitted anywhere, so decoding itself is safe from a data-exposure standpoint. That said, treat any live token with the same care as a password — anyone who has the raw token string can already read its payload and, more importantly, use it to authenticate as whoever it represents until it expires.
Why can anyone read a JWT's payload without a password?
The header and payload are base64url-encoded, not encrypted — encoding is reversible by anyone with no key required. A JWT's security comes from its signature proving the claims are genuine and untampered, not from hiding the claims' contents.
What does the "exp" claim mean?
It is a Unix timestamp (seconds since 1 January 1970 UTC) marking when the token expires. This tool converts it to a readable local date/time and flags whether the token has already expired, purely for your convenience while debugging.
Why does it say my token is malformed?
A valid JWT must have exactly three dot-separated parts. This error appears if that structure is wrong, if a segment isn't valid base64url, or if a decoded segment isn't valid JSON — check you copied the entire token, including all three parts, with nothing truncated.
What is the difference between the header and the payload?
The header describes metadata about the token itself, typically the token type ("JWT") and the signing algorithm used (e.g. "HS256"). The payload contains the actual claims — the data the token is asserting, like a user ID, role, or expiry time.
Can I edit and re-sign a token with this tool?
No, this is a read-only decoder. Editing a token's payload would also invalidate its signature unless you re-sign it with the correct secret, which is a server-side operation this browser tool deliberately does not perform.
What algorithm does the header's "alg" field refer to?
It names the signing algorithm the issuer used, commonly HS256 (HMAC with SHA-256, a shared-secret algorithm) or RS256 (RSA with SHA-256, a public/private key algorithm). This tool displays the value but does not use it, since it performs no verification.
Why shouldn't a JWT contain sensitive data like a password?
Because the payload is trivially readable by anyone holding the token — it is not encrypted. Sensitive values should never be placed directly in a JWT payload; only non-secret identifiers and claims belong there.
What are "iss", "sub", and "aud" in a decoded payload?
Standard registered claims: "iss" is the issuer that created the token, "sub" is the subject the token is about (typically a user ID), and "aud" is the intended audience (which service the token is meant for). None of these are verified by this decode-only tool.

Part of These Collections

Also Available As

jwt decoder, decode jwt online, json web token decoder, jwt payload viewer, jwt expiry checker

Found a Problem?

Let us know if something with JWT Decoder isn't working as expected.

Thanks — we'll take a look.