JWT generator

1. Write the header, at least {"alg":"HS256","typ":"JWT"}, and the payload with your claims.
2. Serialize each as JSON (UTF-8) and Base64URL-encode it without padding.
3. Join them with a dot. This string, header.payload, is the signing input.
4. Sign the signing input with the algorithm from the header, and Base64URL-encode the signature.
5. The token is header.payload.signature.

The verifier repeats step 4 over the exact characters it received, so any change to the header or payload, even reordering JSON keys, breaks the signature. Paste the result into the JWT decoder to read it back and check it with the key.

RFC 7518 makes HS256 the one algorithm every implementation must support and recommends RS256 and ES256. HS384/HS512, RS384/RS512, PS384/PS512 and ES384/ES512 use SHA-384 or SHA-512 and bigger keys or curves; ES512 runs on P-521, not P-512. The ECDSA signature in a JWT is the R and S values joined (64 bytes for ES256), not the DER format OpenSSL prints.

Node.js with jsonwebtoken (HS256 is its default):

const jwt = require('jsonwebtoken');
const token = jwt.sign({ sub: 'user_123', role: 'admin' }, process.env.JWT_SECRET, { expiresIn: '1h' });

// RS256 with a PEM private key
const rs = jwt.sign({ sub: 'user_123' }, privatePem, { algorithm: 'RS256', keyid: 'key-1', expiresIn: '15m' });

JavaScript with jose (Node, browsers, edge):

import { SignJWT, importPKCS8 } from 'jose';

const secret = new TextEncoder().encode(process.env.JWT_SECRET);
const token = await new SignJWT({ role: 'admin' })
  .setProtectedHeader({ alg: 'HS256' })
  .setSubject('user_123')
  .setIssuedAt()
  .setExpirationTime('1h')
  .sign(secret);

const key = await importPKCS8(privatePem, 'ES256');
const es = await new SignJWT({}).setProtectedHeader({ alg: 'ES256', kid: 'key-1' }).setExpirationTime('15m').sign(key);

Python with PyJWT (pip install pyjwt[crypto] for RS and ES):

import jwt, datetime as dt
now = dt.datetime.now(dt.timezone.utc)
token = jwt.encode({"sub": "user_123", "iat": now, "exp": now + dt.timedelta(hours=1)}, secret, algorithm="HS256")

Go with golang-jwt v5:

claims := jwt.MapClaims{"sub": "user_123", "exp": time.Now().Add(time.Hour).Unix()}
token, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte(secret))

OpenSSL, for secrets and key pairs:

openssl rand -base64 32                                                       # HS256 secret
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out private.pem  # RS256 / PS256
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-256 -out private.pem # ES256
openssl genpkey -algorithm ed25519 -out private.pem                            # EdDSA
openssl pkey -in private.pem -pubout -out public.pem                           # public key

Times are seconds since 1970, not milliseconds: in JavaScript that is Math.floor(Date.now() / 1000). The payload is readable by anyone who has the token, so never put passwords or other secrets in it. For random IDs and secrets elsewhere, see the UUID generator and the password generator.

• Keys made on any website, this one included, are for testing. Generate production keys on the server or in a key manager, and never share the private key.
• Do not use a human-memorable password as an HMAC secret. RFC 8725 says so because short secrets can be brute-forced offline from a single token.
• Verifiers must pin the algorithms they accept and reject alg "none" unless it was asked for on purpose.
• Publish public keys as a JWKS with a kid for each key, so you can rotate keys without breaking tokens that are still valid. The generator gives you that JWKS.