⚡ 10-second version
Paste the token at tooladda.online/jwt-debugger.html. Header, payload and claims decoded, expiry checked against the clock, signature verified if you supply the key — all locally.
❗ Important
A JWT is a live credential. Pasting a production access token into a website means handing over whatever that token authorises, for as long as it's valid. Decoding here happens in your browser with no network request — which is the only acceptable way to debug a real token.
🔓 base64url is not encryption — read your own token right now
The single most consequential misunderstanding about JWTs: the payload is encoded, not encrypted. Anyone holding the token can read every claim inside it without any key at all.
eyJhbGciOiJIUzI1NiJ9 . eyJzdWIiOiIxMjMiLCJyb2xlIjoiYWRtaW4ifQ . SflKxwRJSMeKKF2QT4f
└──── header ────┘ └────────── payload ──────────┘ └──── signature ────┘
base64url base64url keyed hash
Base64-decode the middle segment and you get {"sub":"123","role":"admin"} in plain text. The signature stops anyone modifying the token; it does nothing to stop them reading it.
So never put secrets in a JWT payload. No passwords, no card numbers, no internal notes, no PII you wouldn't hand to the client — because you are handing it to the client.
The two classic JWT attacks
| Attack | How it works | The defence |
|---|---|---|
🚨 alg: none
|
Attacker sets the header to {"alg":"none"}, strips the signature, and edits the payload to "role":"admin". A naive verifier that trusts the header's algorithm accepts it. |
Never read the algorithm from the token. The server decides which algorithm it accepts, and rejects everything else. |
| 🚨 HS/RS confusion | The server verifies RS256 with a public key. The attacker re-signs the token with HS256 using that public key as the HMAC secret. A library that switches mode based on the header validates it happily. | Pin the expected algorithm server-side. Never let the token choose. |
Both attacks exist because the token gets to nominate how it's checked. The audit here flags alg: none, missing exp, an over-long lifetime, and a signature that doesn't verify — the things worth catching before they ship.
🧭 How it works
✨ What's inside
| ### ⏰ Expiry against the real clock `exp`, `nbf` and `iat` converted to readable local time with a live countdown. "Is my token expired or is my auth broken?" answered in a second. | ### 🔐 Real signature verification HS256, RS256, ES256 and PS256 — paste the secret or the public key and get a definitive valid/invalid, not just a decode. |
| ### 🚨 Security audit Flags `alg: none`, a missing `exp`, suspiciously long lifetimes, and absent `iss`/`aud` — the checks a code review should catch and often doesn't. | ### 🧩 Readable claim breakdown Standard claims explained (`sub`, `aud`, `iss`, `jti`) alongside your custom ones, formatted rather than dumped as one line of JSON. |
🛠️ Real jobs
| Situation | What you check |
|---|---|
| 🐛 401 from your API | Is it expired, or is the signature wrong? Two different bugs. |
| 🔍 "Why is this user unauthorised?" | Read the actual roles and scopes in the payload. |
| 🕐 Clock skew across services | Compare iat/exp against your machine's time. |
| 🔑 Rotated a signing key | Confirm tokens verify against the new key before deploying. |
| 🎓 Learning OAuth2 / OIDC | See what an ID token really contains. |
| 🛡️ Reviewing someone's auth code | Catch alg: none acceptance and missing expiry before it ships. |
📖 Four steps
1. Open → tooladda.online/jwt-debugger.html
2. Paste → the token (use a TEST token if you can)
3. Read → header, claims, expiry countdown
4. Verify → paste the secret / public key to check the signature
▶ Decode now — tooladda.online/jwt-debugger.html
⚠️ Warning
If you have pasted a production token into any online debugger — including this one — treat it as exposed and rotate it. Local processing removes the network risk, not the clipboard, screen-share and browser-history risk. Debug with test tokens whenever you can.
❓ FAQ
Is my token uploaded?
No. Decoding and verification run in your browser via the Web Crypto API. Check the Network tab — nothing leaves.
Can anyone read my JWT payload?
Yes. It's base64url-encoded, not encrypted. Any holder of the token can read every claim. Never put secrets in it.
Then what does the signature actually protect?
Integrity and authenticity — it proves the token wasn't altered and was issued by someone holding the key. It provides no confidentiality.
What is the alg: none attack?
Setting the algorithm to none, dropping the signature, and editing the claims. It works against verifiers that trust the token's own header. Always pin the accepted algorithm server-side.
Should JWTs be stored in localStorage?
It's convenient and exposes the token to any XSS on your page. HttpOnly, Secure, SameSite cookies are generally the safer default for browser sessions.
How do I revoke a JWT?
You largely can't — that's the trade-off of stateless tokens. Keep lifetimes short, use refresh tokens, and maintain a denylist by jti if you truly need instant revocation.
Can it verify RS256 with a JWK?
Yes — RS256, ES256 and PS256 verification with a public key, all client-side.
🔬 Under the hood
- Decoding and signature verification via the Web Crypto API in vanilla JavaScript — no upload endpoint exists.
- Supports HS256/384/512, RS256, ES256 and PS256.
- Audit rules target real-world misconfigurations rather than style preferences.
- Works offline once loaded.
Originally published on ToolAdda, where JWT Debugger runs free in your browser — nothing is uploaded, nothing leaves your device.
Top comments (0)