JWT Verifier — Validate JWT Signatures Online (HS / RS / PS / ES)

What is JWT Verifier?

A JWT Verifier answers one question your JWT Decoder can't: is this token actually authentic? Decoders can show you the payload of any Base64URL string; verifiers cryptographically prove the payload was signed by the holder of a specific key and hasn't been tampered with. That's the difference between reading the header of a letter and confirming the wax seal — one is trivial, the other is what makes JWTs a security primitive.

How to verify a JWT signature

1. 1Paste the full three-segment JWT (header.payload.signature) into the token field.
2. 2The tool auto-detects the alg from the header — HS256, RS256, ES256, PS256, etc.
3. 3Paste the matching key: an HMAC secret for HS*, an SPKI PEM (-----BEGIN PUBLIC KEY-----) or JWK for RS*/PS*/ES*.
4. 4Signature valid ✅ / invalid ❌ shows immediately, together with decoded header + payload.
5. 5Time-based claims (exp, nbf, iat) are validated separately and shown as informational badges — an expired token can still be crypto-valid.

Use Cases

Code Examples

import jwt from "jsonwebtoken";

try {
  const decoded = jwt.verify(token, "your-256-bit-secret", { algorithms: ["HS256"] });
  console.log(decoded);
} catch (err) {
  console.error("Invalid token:", err.message);
}

import jwt from "jsonwebtoken";
import fs from "node:fs";

const pub = fs.readFileSync("public.pem");
const decoded = jwt.verify(token, pub, { algorithms: ["RS256"] });

import jwt

decoded = jwt.decode(token, key, algorithms=["RS256"], audience="my-api")

import "github.com/golang-jwt/jwt/v5"

token, err := jwt.Parse(raw, func(t *jwt.Token) (any, error) {
    if _, ok := t.Method.(*jwt.SigningMethodRSA); !ok {
        return nil, fmt.Errorf("unexpected alg: %v", t.Header["alg"])
    }
    return publicKey, nil
})

Key Concepts

Signature vs. claims

Signature verification proves who signed the token. Claim validation (exp/nbf/aud/iss/sub) proves the token is being used correctly. Both must pass for a token to be trusted — a valid signature on an expired token is still expired.

SPKI PEM

The `-----BEGIN PUBLIC KEY-----` format. This is what verifiers need. The other common format, `-----BEGIN RSA PUBLIC KEY-----` (PKCS#1), is not accepted by Web Crypto directly — convert with `openssl rsa -pubin -in pkcs1.pem -RSAPublicKey_in -out spki.pem`.

JWK Set (JWKS)

A JSON document at `/.well-known/jwks.json` containing multiple public keys with `kid`s. Your verifier picks the key whose `kid` matches the token header's `kid`. Enables key rotation without redeploying clients.

alg="none"

A special algorithm that means "no signature." Historically accepted by naive verifiers, letting attackers strip signatures and forge tokens. RFC 7518 §3.6 requires rejecting it whenever signature verification is on.

Tips & Best Practices

• ▸The key type must match the alg. HS256 wants a raw string; RS256 wants an RSA public key; ES256 specifically wants a P-256 EC public key (P-384/P-521 for ES384/ES512).
• ▸If you're building auth in production, always pass an explicit `algorithms` allowlist to your verify() call — this shuts down algorithm-confusion attacks like RS256→HS256.
• ▸Use `iat` (issued-at) to detect replay: reject tokens whose `iat` is older than your access-token TTL, even if `exp` says they're still valid.
• ▸Clock skew matters. Allow a small `leeway` (30-60s) for `exp` and `nbf` checks to survive minor server time drift.