Skip to main content

Advanced JWT Debugger

Decode, Edit, Verify, and Sign JSON Web Tokens locally. No data leaves your browser.

Encoded Token
Empty
Verify Signature
Awaiting Secret
Header
Payload
Security & Claims Analysis
Algorithm Warnings
Clock-Skew Tolerance
0s
Claims Checklist
Formulate JWT
Generated Token
Token Builder — Standard Claims
Generated Token
Decoded Preview
Build a token to see the decoded payload here.
JWT Algorithm Cheat-Sheet
AlgorithmTypeKeyStrengthBest for
HS256Symmetric HMACShared secret128-bitServer-to-server, internal APIs
HS384Symmetric HMACShared secret192-bitHigher-assurance internal tokens
HS512Symmetric HMACShared secret256-bitLongest HMAC — overkill for most uses
RS256Asymmetric RSAPrivate + Public2048-bit keyPublic key distribution (OAuth 2, OIDC)
RS384Asymmetric RSAPrivate + Public2048-bit keyLegacy compliance
RS512Asymmetric RSAPrivate + Public2048-bit keyHigh-security public-key scenarios
ES256Asymmetric ECDSAEC P-256 key pair128-bit equiv.Mobile apps, shorter tokens
ES384Asymmetric ECDSAEC P-384 key pair192-bit equiv.Financial services, high-security APIs
noneUnsecuredNone⚠️ No securityTesting only — never in production
Quick decision guide:
  • HS256 — default for server-side APIs where you control all parties
  • RS256 — use when third parties need to verify tokens without the signing secret (e.g. OIDC)
  • ES256 — same as RS256 but smaller signatures; prefer for mobile/IoT bandwidth
  • HS384/HS512 — rarely needed; SHA-256 collision resistance is sufficient for JWTs
Standard Authorization Code Flow with JWT

Understanding Authentication Tokens

JSON Web Tokens (JWT) are lightweight, cryptographically signed tokens primarily used to authorize requests against modern REST APIs and microservices. Because the server can mathematically verify a JWT's signature locally, it rarely needs to query a database to authenticate a request.

SAML (Security Assertion Markup Language) is a robust, XML-based standard primarily used for Enterprise Single Sign-On (SSO) systems. It requires heavier back-and-forth parsing and is highly secure, but JWT's JSON format makes it significantly easier to transmit across HTTP headers in web and mobile applications.

The Authorization Code flow securely exchanges a temporary code for an Access Token (JWT).

graph TD
    User([Resource Owner])
    Client[Client App]
    AuthServer[(Auth Server)]
    API[(API Server)]
    
    User -->|1. Clicks Login| Client
    Client -->|2. Requests Auth Code| AuthServer
    AuthServer -.->|3. Prompts for Consent| User
    User -.->|4. Grants Consent| AuthServer
    AuthServer -->|5. Returns Auth Code| Client
    Client -->|6. Exchanges Code for Tokens| AuthServer
    AuthServer -->|7. Returns Access Token JWT| Client
    Client -->|8. API Call with Bearer JWT| API
    API -->|9. Validates JWT & Returns Data| Client
                    

JWT Token Structure

A JSON Web Token consists of three parts separated by dots, each Base64Url encoded.

graph LR
    JWT[Encoded JWT Token]
    Header[Header: Algorithm & Type]
    Payload[Payload: Data & Claims]
    Signature[Signature: Verification]
    
    JWT -->|Part 1| Header
    JWT -->|Part 2| Payload
    JWT -->|Part 3| Signature
    
    style Header fill:#df3852,stroke:#fff,stroke-width:2px,color:#fff
    style Payload fill:#d72199,stroke:#fff,stroke-width:2px,color:#fff
    style Signature fill:#4d7dff,stroke:#fff,stroke-width:2px,color:#fff
                    

Frequently Asked Questions

Is it safe to paste a JWT here?

Decoding and signature verification run in your browser with the Web Crypto API and the open-source jose library, which is served from this site rather than a third-party CDN. Tokens, secrets and keys are not sent to our servers. The one network request you can trigger is fetching a JWKS URL that you enter. Treat real production tokens like passwords regardless: prefer test tokens or expired ones, and revoke any token you have shared.

What is the difference between decoding and verifying a JWT?

Decoding only Base64URL-decodes the header and payload, which anyone can do because they are not encrypted. Verifying recomputes or checks the signature with the right secret or public key, and then validates the claims (exp, nbf, iss, aud). A decoded token proves nothing about who issued it. Never trust claims from a token you have not verified.

Which JWT algorithms does the debugger support?

Any JWT can be decoded. Signature verification covers HS256/384/512, RS256/384/512, PS256/384/512 and ES256/384/512, using a shared secret, a PEM public key, a JWK or a JWKS URL (matched by kid). The Encoder signs with HS256/384/512, RS256 and ES256, or produces an unsecured alg none token for testing. EdDSA (Ed25519) is not supported.

Why do I get 'invalid signature' or 'token expired' errors?

For invalid signature, check that the secret or key matches the one that signed the token, that an HMAC secret is not Base64-encoded when the issuer used the raw string (or the reverse), that the algorithm matches, and that you are using the right key from the JWKS (the kid header). For expired tokens, the debugger shows exp, nbf and iat as times and a live countdown, and lets you set a clock-skew allowance, since a few seconds of drift between servers is a common cause.

What JWT security mistakes does the debugger warn about?

It warns about alg none tokens, HMAC tokens verified against a public key or JWKS (the algorithm-confusion attack), unrecognized algorithms, missing or far-future expiry and missing standard claims. The guidance follows RFC 8725, the JWT best current practice: pin the expected algorithm on the server instead of trusting the token header, validate iss, aud and exp, keep lifetimes short and never accept unsecured tokens.