Skip to content
Token helper

JWT Tool

Enter a header and payload in JSON format to generate, copy, decode, and verify HS256-signed JWTs directly in your browser. RS256 tokens can be verified too by pasting a public key (PEM) or a JWKS, and an expired token (exp) is reported separately from the signature check.
Generated tokens are displayed instantly and can be copied with a single click.

All processing happens entirely in your browser; nothing is sent anywhere.

Decode a JWT

Enter the secret, or a public key (PEM / JWK / JWKS), to verify the signature
Header
Payload

Header and secret checks

Looks at the header of the token in the verify box above for known risky patterns, and tries a dictionary of common weak HMAC secrets. Everything runs in your browser; the token is not sent anywhere.

To sign with RS256 / ES256 / EdDSA, paste a PKCS#8 private key (BEGIN PRIVATE KEY) into the secret field.

Header findings

    Weak secret check

    Test key pair

    Create a key pair for testing RS256, PS256, ES256, ES384 or EdDSA. The keys are made in your browser and are not sent anywhere. Use them only for tests, never in production.

    Guide

    How to use & features

    • Paste a JWT to automatically decode its header and payload.
    • Enter the shared secret and click “Verify” to check the signature.
    • To issue a new token, edit the payload, set a secret, and click “Sign.”
    • All operations run locally, so secrets never leave your browser.
    Samples

    Sample input & output

    Decode a JWT

    Input
    eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjoiZGV2a2l0cyIsImV4cCI6MTcwNjY0MDAwMH0.v9kpsYy6oF9E9e_t1z23v8GpU0mHP5uP6fMIv1wBtRM
    Output
    {
      "user": "devkits",
      "exp": 1706640000
    }
    FAQ

    FAQ

    • What is the difference between decoding and verifying a JWT?

      Decoding just reads the header and payload and anyone can do it. Verifying checks that the signature was made with the right key. This tool shows the contents when you paste a token and also verifies the signature when you give it a key.
    • Can I paste the contents of an `Authorization` header as is?

      Yes. A leading `Bearer ` and surrounding whitespace or quotes are removed automatically.
    • Which keys can be used to verify a signature?

      An HMAC secret (HS256 / HS384 / HS512), a public key PEM, an X.509 certificate, a JWK or a JWKS (`{"keys": [...]}`). With a JWKS it picks the key that matches the token's `kid`.
    • For an expired token, can I still tell whether the signature is valid?

      Yes. The signature result and the `exp` (expired) and `nbf` (not yet valid) checks are shown separately, so you can tell "valid signature but expired" from "wrong signature".
    • Can it create tokens too?

      Yes. Enter a header, payload and secret to create a JWT signed with HS256, HS384 or HS512. If you have not written `iat`, the current time is added automatically.
    • Are my token and secret sent anywhere?

      No. Decoding, verification and signing all happen in your browser.
    Use cases

    Common use cases

    • Narrowing down authentication errors

      When an API returns 401, look inside the token to check for expiry (`exp`), not-yet-valid (`nbf`), or a different issuer (`iss`) or audience (`aud`).
    • Checking the contents of Auth0, Cognito or Firebase tokens

      Quickly read claims such as `sub`, `scope` and `email` in ID tokens and access tokens.
    • Verifying a signature with a JWKS

      Paste a public JWKS and check the signature with the key that matches the `kid`.
    • Creating development tokens

      Make JWTs signed with HS256 and similar, with the payload you need, for local development and tests.
    Notes

    Notes & limitations

    • Being able to decode a token does not make it trustworthy

      The payload is not encrypted and anyone can read it. Do not put secrets such as passwords in it. And even if it decodes, do not trust its contents until the signature is verified.
    • Only the signature and `exp` / `nbf` are checked

      Check other claims such as `iss` (issuer) and `aud` (audience) in your application. A token whose header `alg` is `none` is treated as unsigned and is never shown as verified.
    • Only HS256 / HS384 / HS512 can be created

      Only signing with a shared secret is supported. For RS256 and similar, use the JWKS tool. The secret is used as UTF-8 text and is not Base64-decoded.
    • Handle production tokens with care

      Processing happens in your browser and nothing is sent. Still, do not paste a valid token into shared places such as chat. Expiry is judged against your device's clock.
    About

    About this tool

    JWT Decoder and Verification Tool

    JWTs are commonly used for authentication, session handling, and API authorization. This tool decodes the header and payload of a JSON Web Token in your browser so you can inspect claims such as sub, iss, aud, iat, and exp. It also helps you check token structure and review signature-related data during debugging.

    When it helps

    • Debug login issues: Confirm whether a token contains the expected user ID, issuer, audience, and expiration time.
    • Inspect API authorization: Review token claims before sending requests to protected endpoints.
    • Check token lifetime: Convert iat and exp values into human-readable times and spot expired tokens.

    Security note

    JWT payloads are encoded, not encrypted. Anyone with the token can read the header and payload. Avoid pasting production tokens into tools you do not trust, and never share tokens that contain session or authorization data.

    Articles for this tool

    Recent Articles