Quick access

Saved in this browser. Sign in to keep it on all your devices.

JWT Verifier

Check a JSON Web Token the way your server should: the signature, the algorithm, and the exp, nbf, iss and aud claims, with one clear verdict.

Checked in your browser, never sent

This is an encrypted token (JWE). It is decrypted, not verified, by its recipient.

Signed with . Read all its claims in the JWT Decoder

Rules · what your server expects

Pin the one algorithm you issue. Accepting several is how algorithm-confusion attacks get in.

Signature verified and every rule passed.
  • Signature

Paste a token and its key to see whether your server should accept it. Just want to read what’s inside? Use the JWT Decoder.
Version 1.1 Updated What's new

Release notes

  1. v1.1 Latest
    • Added an in-depth guide below the tool, written from what the tool actually does.

About the JWT Verifier

The JWT verifier checks a JSON Web Token the way a server should before trusting it: the signature first, then that the algorithm is one you allow, that the token is in date, and that it was issued by and for the right parties.

How to use it

  1. 1 Paste the token and the secret or public key (PEM, certificate, JWK or JWKS).
  2. 2 Set your rules: allowed algorithm, expected issuer and audience, clock leeway.
  3. 3 Read the verdict and fix any check that failed.

Frequently asked questions

Why does signature verification fail?

Usually the key is wrong: a different environment’s secret, extra spaces, or a secret that should be read as Base64. For RS and ES tokens, check that the key’s kid matches the token header. Otherwise the token was changed after it was signed.

Can a token with a valid signature still be rejected?

Yes, and it should be when it has expired (exp), is not valid yet (nbf), comes from another issuer (iss), is meant for another service (aud), or uses an algorithm you do not allow.

What is an algorithm-confusion attack?

An attacker changes alg from RS256 to HS256 and signs the token with your public key as the HMAC secret. A server that trusts the header’s alg may accept it. Pin the one algorithm you issue; this tool also refuses keys that do not match the algorithm.

What is clock leeway?

A few seconds or minutes of tolerance on exp, nbf and iat, because the clocks of the issuer and your server are never exactly in sync. 30 to 60 seconds is common.

Is my secret sent anywhere?

No. Verification uses your browser’s Web Crypto and nothing is sent or saved; only your rules are remembered. Even so, avoid pasting production secrets into any online tool.

Decoding is not verifying

The header and payload of a JWT are only Base64URL-encoded, so anyone can read them; the JWT Decoder does exactly that. Verifying answers a different question: was this token really signed by the issuer you trust, and has nobody changed a single character since? Only the signature can answer that, and only with the right key. A server that reads the claims without checking the signature will accept any token a user writes by hand.

The checks, in the order a server should run them

  • Reject a header with alg set to none, and any algorithm you did not pin.
  • Pick the key: the shared secret for HS256, HS384 or HS512, or the public key whose kid matches the header for RS, PS, ES and EdDSA tokens.
  • Check the signature over the exact header.payload text.
  • Check the time claims: exp in the future, nbf and iat not in the future, allowing a little clock leeway.
  • Check iss is your identity provider and aud names your API.

This verifier runs the same steps and shows which one failed, so a red result tells you whether to look at the key, the clock or the claims.

Which key to paste

HMAC tokens (HS256 and friends) use one shared secret to sign and to verify. Paste it as text, or tick “Secret is Base64-encoded” if your provider shows it in Base64, a common cause of “invalid signature”. RSA, ECDSA and EdDSA tokens are signed with a private key and checked with the matching public key, so you never need, and should never paste, a private key to verify. A PEM public key, an X.509 certificate, a single JWK or a whole JWKS all work.

Finding the JWKS for Auth0, Okta and Cognito

Identity providers publish their public keys as a JWKS, a JSON list of keys, each with a kid. Open the URL, copy the JSON and paste it in as the key:

Auth0:   https://YOUR_DOMAIN/.well-known/jwks.json
Okta:    https://YOUR_DOMAIN/oauth2/default/v1/keys
Cognito: https://cognito-idp.REGION.amazonaws.com/USER_POOL_ID/.well-known/jwks.json

Most providers also list the JWKS address as jwks_uri in their OpenID configuration at /.well-known/openid-configuration. Keys rotate, so if a token suddenly fails with a kid that is not in your copy, fetch the JWKS again.

Verifying a JWT in Node.js

In your own code, use a maintained library and pass the same rules you set here. With the jose package:

import { createRemoteJWKSet, jwtVerify } from 'jose';

const jwks = createRemoteJWKSet(new URL('https://YOUR_DOMAIN/.well-known/jwks.json'));

const { payload } = await jwtVerify(token, jwks, {
  issuer: 'https://YOUR_DOMAIN/',
  audience: 'https://api.example.com',
  algorithms: ['RS256'],
  clockTolerance: 30,
});

jwtVerify throws if any check fails, so treat an error as “not signed in”. Use this page to work out why a real token is rejected, then fix the rule or the key in code.