JWT Expiration Checker

Check JWT token expiration and decode JWT payload

All JWT decoding and checking is done locally in your browser. Your tokens never leave your device.

In-depth guide

Reading a JWT's expiry: what the checker decodes and what it cannot tell you

How the checker splits and decodes a compact JWT, how it judges exp, nbf and iat, what its green 'Valid Token' does and does not mean, and the input shapes it rejects; all outputs come from the real page.

Last verified: Sources: IETF — RFC 7519 Plain-text version of this guide

Key figures at a glance

Signature
Never verified
'Valid Token' only means the exp claim is in the future. Anyone can forge a token that passes this check.
Source: IETF — RFC 7519
Expired when
exp is earlier than the device clock
At the exact second equal to exp the page still says valid; RFC 7519 says 'on or after' exp must be rejected.
Accepted shape
Three parts separated by dots, nothing else
A leading 'Bearer ', embedded line breaks, or a 5-part encrypted token give an error.
Displayed times
UTC, day/month/year, 24-hour
For example 20/10/2026, 02:26:54 UTC, in every language.

Debugging a 401 that may be an expired token

The checker answers 'what does this token claim?', not 'will the server accept it?'.

  1. Step 1: Copy only the token

    Take the three-part string, without the Authorization header name or the Bearer prefix. Treat it as a credential: a live token lets whoever holds it act as the user.

  2. Step 2: Read the status and the exp line

    Note whether exp is in the past, how far, and whether nbf is still ahead. Ignore the green tick as proof of anything else.

  3. Step 3: Compare with the server's clock

    If exp looks fine but the server disagrees, convert exp and your device time and look for a clock difference.

  4. Step 4: Refresh or re-issue the token

    Expired tokens must be renewed by the identity provider. Verification of the signature, issuer and audience stays on the server.

What the page does

A compact JWT is three base64url strings joined by dots: header, payload, signature. The page trims the pasted text, splits on ., and requires exactly three parts. It decodes the first two as UTF-8 JSON and shows them re-indented; the third is not read. Nothing is sent anywhere: the page's script makes no network request. A Decode JWT click and a Check Expiration click do exactly the same thing, and Ctrl+Enter in the box also runs it.

A JWT payload is encoded, not encrypted. Anyone holding the token can read every claim, which is why the decoding is trivial and why you should not put secrets in claims.

How exp, nbf and iat are judged

Claims are NumericDate values: seconds since 1970-01-01T00:00:00Z, ignoring leap seconds (RFC 7519). The page compares them with your device clock.

Claim Behaviour on this page RFC 7519 meaning
exp Past: red "Token Expired" with how long ago. Future: green "Valid Token" with time remaining Token MUST NOT be accepted on or after this time
nbf Shown only when it is still in the future ("Token Not Yet Valid", "Valid in …"); a past nbf is not mentioned Token MUST NOT be accepted before this time
iat Displayed, never judged; a future iat raises no warning When the token was issued

Tokens that fail these checks on the server can still look healthy here, because the server also checks signature, issuer (iss), audience (aud) and its own rules, and RFC 7519 says which claims are required is context dependent.

Verified behaviours (run with generated tokens):

  • Missing exp, or exp equal to 0, gives a yellow "No Expiration Set". Zero is treated as absent.
  • exp as the string "1792455807" is accepted and compared as a number.
  • exp given in milliseconds (13 digits) is read as seconds: the page reports "Valid Token" with about 20 million days remaining and a year 58770. If you see an absurd expiry, the issuer used the wrong unit.
  • The exact-second boundary counts as still valid, one second later than the RFC rule.
  • No leeway is applied. RFC 7519 allows a small allowance for clock skew; servers often use one, this page does not.
  • Time remaining shows days, hours and minutes, and seconds only when under one day; the English labels are not singular-aware ("1 minutes").
  • Unsecured tokens (alg: none, empty signature, valid under RFC 7519 section 6) display as "Valid Token" too.

Examples

Token with exp 2 h 5 m ahead (generated with an HS256 header): Time Remaining "2 hours 5 minutes 3 seconds", Expiration Time 20/10/2026, 02:26:54 UTC, Issued At shown. Token with exp 2 days 1 hour 5 seconds ago: "Expired: 2 days 1 hours ago". Token with nbf ten minutes ahead and exp two hours ahead: both "Valid Token" and "Token Not Yet Valid / Valid in: 9 minutes 55 seconds".

Inputs that fail

Pasted Message
Bearer eyJ… Error decoding JWT (the prefix makes the first part invalid)
two parts, or five parts (an encrypted JWE) JWT must have 3 parts separated by dots
a token wrapped over several lines Error decoding JWT (whitespace inside is not removed)
a payload that is not JSON Error decoding JWT
padding = characters Error decoding JWT (the format uses base64url without padding)

A payload that is a JSON array decodes fine, shows "No Expiration Set" and prints the array.

Tip: Convert a suspicious exp with the Unix timestamp converter. If it lands in 1970 the unit is wrong the other way (seconds treated as milliseconds), and if it lands in the far future it is milliseconds.

Common mistakes

  • Reading "Valid Token" as "authentic token". Only the server, holding the key, can verify the signature.
  • Pasting live production tokens into tools you do not control. This page runs locally, but a token in your clipboard or history is still a credential.
  • Forgetting that large numbers in the payload print as JavaScript numbers (12345678901234567890 becomes 12345678901234567000).
  • Comparing your device clock with a server in another timezone and forgetting that exp is always UTC.

Convert exp and iat with the Unix timestamp converter, inspect the decoded JSON in the JSON viewer, or decode a single segment by hand with the Base64 encoder.

Frequently Asked Questions

What is a JWT token?

JWT (JSON Web Token) is a compact, URL-safe token format used for securely transmitting information between parties. JWTs are commonly used for authentication and authorization in modern web applications. A JWT consists of three parts: header, payload, and signature, separated by dots.

Is my JWT token sent to a server?

No, all JWT decoding and expiration checking happens entirely in your browser. Your tokens never leave your device, making this tool completely safe for production and sensitive authentication tokens.

Does this tool verify JWT signatures?

No, this tool only decodes JWT tokens to read their contents and check expiration. It does not verify cryptographic signatures. Always verify JWT signatures on your server before trusting token contents in production applications.

What does "Token Expired" mean?

Token Expired means the "exp" (expiration) claim in the JWT has passed the current time. Expired tokens should not be accepted by servers and typically require the user to re-authenticate or refresh the token.

What if my JWT doesn't have an expiration?

If a JWT doesn't contain an "exp" claim, it technically doesn't expire automatically. However, this is generally not recommended for security reasons. Most authentication systems should set expiration times on JWTs.

How do I read the decoded JWT data?

After decoding, the tool displays the header (containing algorithm and token type) and payload (containing claims like user ID, expiration, issued at, and custom data). All data is displayed in JSON format for easy reading.

Why is my valid token showing as expired?

Check your device's system time. Expiration checking is based on your local clock. If your system time is incorrect, it may show valid tokens as expired or vice versa. Also verify the token was issued with the correct expiration time.

Can I decode tokens from any application?

Yes, this tool can decode any standard JWT token regardless of which application or framework created it. JWTs follow a standardized format (RFC 7519) that works across all platforms and programming languages.

What are the three parts of a JWT?

A JWT has three Base64URL-encoded parts separated by dots: Header (algorithm and type), Payload (claims and data), and Signature (cryptographic signature for verification). The format is: xxxxx.yyyyy.zzzzz

Is it safe to use this tool with production tokens?

Yes, since all processing happens locally in your browser and tokens never leave your device. However, always be cautious about where you paste sensitive tokens. Avoid sharing decoded token contents that may contain confidential information.

What is the difference between exp, iat, and nbf claims?

exp (expiration time) is when the token expires. iat (issued at) is when the token was created. nbf (not before) is when the token becomes valid. All three use Unix timestamps (seconds since January 1, 1970).

How often should JWT tokens expire?

For security, access tokens should typically expire in 15 minutes to 1 hour. Refresh tokens can last longer (days to weeks). The ideal expiration time depends on your security requirements and user experience needs.

Sources

  1. IETF — RFC 7519, JSON Web Token (JWT) — exp, nbf, iat, NumericDate, unsecured JWTs, context-dependent validity.
  2. IETF — RFC 7515, JSON Web Signature (JWS) — The compact serialisation: base64url header, payload and signature.
  3. IETF — RFC 4648, Base64url encoding

This guide explains published rules in plain language. It is not financial, legal or official advice — rules change, so confirm with the agency linked above before you commit.

Embed this tool on your website

Free to use. Paste this code into your page and keep the link back to ToolSG.