JWT Encoder/Decoder

A JSON Web Token (JWT) is a compact, URL-safe way to transport a set of signed claims between two parties. Authentication systems emit them to prove a user is logged in; authorisation services use them to carry permissions; API gateways use them to relay a user identity downstream. Every JWT has three parts separated by dots: a header that names the signing algorithm, a payload that holds the claims, and a signature that binds the first two together under a secret or private key. Tampering with the header or payload after signing invalidates the signature, so the recipient can trust the claims without re-contacting the issuer.

The wire format is three Base64URL-encoded segments joined by dots. Base64URL (the URL-safe variant of Base64, swapping +/ for -_ and stripping padding) means the token can travel in HTTP headers, query strings, and cookies without further escaping. That compactness matters: Authorization: Bearer eyJ… is the canonical HTTP pattern, and your application sees that header on every request.

Decoding is trivial — anyone with the token can read the header and payload with no secret. JWT is signed, not encrypted. Treat the payload as public; never put passwords, API keys, or PII there unless you're also using JWE (JSON Web Encryption, a separate spec). Sensitive claims should live in a server-side session with the JWT carrying only a session ID. The signature is what makes the claims trustworthy, not secret.

Our tool runs in two modes. Decode splits any JWT into its three parts, pretty-prints the JSON, surfaces the standard time claims (iat issued-at, nbf not-before, exp expiry) as human-readable ISO dates, and flags an expired token with a red label. Paste an HMAC secret and we verify the signature in the browser via the jose library. Encode takes a header and payload as JSON and signs a token with an HMAC secret — useful for quick test tokens during development.

Signature algorithms fall into three families. HS* (HS256, HS384, HS512) use HMAC with a shared secret — fast, simple, everyone who can verify can also sign. Use for internal service-to-service tokens. RS* (RS256…) use RSA with an asymmetric key pair; the private key signs, the public key verifies. Use when issuers and verifiers are different services. ES* (ES256…) use elliptic-curve signatures; similar properties to RS but with smaller keys and faster verification. Our tool currently supports the HS family — RS and ES require public-key parsing and are on the roadmap.

Security gotchas. Accept only the algorithms your system needs, and never accept alg: none — a famous early JWT bug. Rotate secrets; use at least 32 bytes of random data for HS256. Set an exp on every token and keep expiries short (minutes, not days) — use refresh tokens for longer sessions. Finally, do not roll your own JWT library in production; stick with battle-tested implementations (jose, jsonwebtoken, pyjwt, jjwt).

Privacy: token and secret stay in your browser. That matters because a real JWT often carries enough data (user ID, email, internal roles) that pasting it into an unknown tool is a potential leak risk. This decoder runs locally.

1. Pick decode or encode. Tabs at the top flip the mode.
2. In decode mode, paste a token. The header, payload, and signature appear on the right with time claims already converted to readable dates.
3. Paste the HMAC secret to verify the signature; a green or red badge tells you if it checks out.
4. In encode mode, edit the header and payload as JSON, then click Sign.
5. Copy the decoded parts or the signed token; every panel has its own copy button.

• Decode any JWT — header, payload, and signature shown separately.
• Auto-converts iat, nbf, exp to ISO dates and flags expiry.
• Live signature verification for HS256 / HS384 / HS512.
• Sign new tokens with any HMAC secret — great for local testing.
• Runs in your browser — no token or secret leaves your device.