Runs in your browser. Your files and text never leave your device - nothing is uploaded.
Decode a JSON Web Token Online
The Tools Kit’s free JWT Decoder turns an opaque token string into readable JSON. Paste a JSON Web Token and it shows the header (signing algorithm and token type), the payload with every claim the issuer put inside, and the raw signature. If the token carries an expiry claim, it also tells you at a glance whether the token has expired.
Decoding happens in your browser with plain JavaScript, so the token is never sent to a server. It is a decoder, not a validator: it reads what the token says but does not check the signature, which needs the issuer’s secret or public key.
How to Use the JWT Decoder
- 1
Paste the token
Paste the full JWT into the JWT Token box: three Base64URL segments separated by dots (header.payload.signature). If you copied it from an Authorization header, remove the "Bearer " prefix first.
- 2
Click Decode JWT
The decoder converts the header and payload from Base64URL and parses them as JSON. If the token does not have exactly three parts, or the header or payload is not valid Base64URL-encoded JSON, an error message appears instead.
- 3
Read the header and payload
The Header box shows the algorithm (alg), token type (typ) and any key id (kid). The Payload box shows every claim, such as sub, iss, aud, iat and exp, as formatted JSON.
- 4
Check the expiry banner
If the payload contains an exp claim, a banner says whether the token is expired or not yet expired and shows the expiry as a date and time in your local time zone.
What Is Inside a JWT?
A signed JWT has three parts joined by dots. The first is the header, the second the payload and the third the signature. The header and payload are JSON objects encoded with Base64URL, a variant of Base64 that swaps + and / for - and _ and drops the = padding so the token is safe in URLs and HTTP headers. You could decode a segment by hand with the Base64 decoder after swapping those characters back, which is exactly what this tool does for you.
For example, the header {"alg":"HS256","typ":"JWT"} always encodes to eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9, which is why so many tokens start with eyJ: those characters come from encoding the opening {" of a JSON object. A payload of {"sub":"1234567890","name":"Jane Doe","iat":1767225600,"exp":1767229200} describes a token issued at midnight UTC on January 1, 2026 and expiring one hour later. The decoder prints these objects with indentation; if you want to search or collapse a large payload, copy it into the JSON formatter.
The signature is computed over the encoded header and payload. With HS256 it is an HMAC-SHA256 using a shared secret, the same construction you can experiment with in the HMAC generator. RS256 and ES256 use a private key to sign and a public key to verify. The decoder shows the signature segment as-is because it is binary data, not JSON.
Standard JWT Claims and Expiry Times
RFC 7519 defines a small set of registered claims. Most identity providers add their own, such as email, roles or scope, alongside them.
| Claim | Name | What it holds |
|---|---|---|
| iss | Issuer | Who created and signed the token |
| sub | Subject | Who the token is about, usually a user id |
| aud | Audience | The API or app the token is meant for |
| exp | Expiration time | Unix time after which the token must be rejected |
| nbf | Not before | Unix time before which the token must not be accepted |
| iat | Issued at | Unix time the token was created |
| jti | JWT ID | A unique id, often a UUID, used to stop replay |
exp, nbf and iat are counted in seconds since January 1, 1970 UTC, not milliseconds. The decoder converts exp into your local date and time and compares it with your device clock; to read iat or nbf, paste the number into the timestamp converter. A unique jti is commonly a random identifier like those from the UUID generator.
Decoding vs Verifying a JWT
Anyone can decode a JWT, so a readable payload proves nothing about who issued it. A server must verify the token before trusting it: recompute or check the signature with the right key, reject alg none, confirm the token has not expired and is past its nbf time, and check that iss and aud match what it expects. When a token is rejected even though it has not expired, decoding it here is the quickest way to compare those claims and the header’s kid with your API’s configuration.
Because the payload is readable, keep secrets out of it, and sign HS256 tokens with a long random secret rather than a guessable phrase. The password generator can create a strong random string for that purpose.
Common uses
- Finding out why an API returns 401 Unauthorized by checking exp, aud and iss
- Inspecting the claims an OAuth or OpenID Connect provider puts in access and ID tokens
- Confirming which signing algorithm and key id a token was issued with
- Checking roles or scopes during development before wiring up authorization rules
- Learning how JSON Web Tokens are structured
For hashing, encoding and other token utilities, browse all security tools.
JWT terms explained
| Term | What it means here |
|---|---|
| JWT | JSON Web Token (RFC 7519): a compact, URL-safe string carrying JSON claims, usually signed |
| JWS | A signed JWT with three parts: header, payload and signature. This is the format the decoder reads |
| JWE | An encrypted JWT with five parts. Its payload cannot be read without the key, so the decoder rejects it |
| Base64URL | Base64 using - and _ instead of + and /, usually without = padding; it is an encoding, not encryption |
| Claim | A name/value pair in the payload, such as sub (subject) or exp (expiry) |
| alg | The header field naming the signing algorithm, for example HS256, RS256 or ES256 |
| kid | Key ID: tells the server which key in its key set should verify the signature |
| NumericDate | The time format used by exp, iat and nbf: whole seconds since 1 January 1970 UTC |
Frequently Asked Questions
Paste the token into the JWT Token box and click Decode JWT. The tool splits it at the dots, converts the header and payload from Base64URL to text and parses them as JSON, then shows the header, the payload claims and the raw signature in separate boxes.
Decoding runs entirely in your browser; the token is not sent to a server, stored or logged. Even so, a live access token works like a password until it expires, so prefer test or expired tokens and never share production tokens in screenshots or chat.
No. It only decodes the header and payload. Verifying the signature needs the issuer’s shared secret (for HS256) or public key (for RS256 or ES256), and that check belongs in your server code or auth library. A decoded token is not proof that the token is genuine.
A standard signed JWT is not encrypted. The header and payload are only Base64URL-encoded, so anyone who holds the token can read them. The signature stops people from changing the claims, not from reading them. Never put passwords or other secrets in a JWT payload.
exp is the expiry time, iat is when the token was issued and nbf is the earliest time it may be used. All three are Unix timestamps in seconds. The decoder converts exp to a readable local date and time; iat and nbf are shown as raw numbers.
If the payload has an exp claim, it compares exp with your device’s current time in seconds. A later exp shows "Token is valid (not expired)"; an earlier one shows "Token is expired". "Valid" here only refers to the expiry time, not the signature, and a wrong device clock will skew the result.
The decoder expects exactly two dots. The usual causes are a token cut off while copying, extra text pasted with it, or an encrypted JWE token, which has five parts and cannot be decoded without the key.
The tool does not strip the "Bearer " prefix from an Authorization header, so that word and the space become part of the header segment, which is then no longer valid Base64URL and decoding stops with an error. Delete the prefix and paste only the token itself.
It names the signing algorithm. HS256 is an HMAC with a shared secret, while RS256 and ES256 are asymmetric signatures verified with the issuer’s public key. alg set to none means the token is unsigned, and a server should never accept it.
You can decode it and edit the claims, but the signature will no longer match the new header and payload, so any correctly implemented server will reject the token. Only someone with the signing key can produce a valid signature.
Reviewed by Raja Jahangir · Last reviewed: October 7, 2026
How do you decode a JWT?
A JWT has three dot-separated parts - header, payload, and signature - and the first two are Base64URL-encoded, not encrypted. Decoding reveals the claims in plain text. Anyone holding the token can read its payload, so never put secrets in a JWT.
