Check any seal. Free.

// npm i jose
import { createRemoteJWKSet, jwtVerify } from 'jose';

// Fetched once, then cached in-process and refreshed on rotation.
const JWKS = createRemoteJWKSet(
  new URL('https://api.5arz.com/.well-known/jwks.json'),
  { cacheMaxAge: 86400000 }   // 24h
);

export async function verifySeal(token) {
  const { payload, protectedHeader } = await jwtVerify(token, JWKS, {
    algorithms: ['ES256'],
    issuer: 'https://5arz.com'
  });
  // Signature is valid and exp/nbf were enforced by jwtVerify.
  return { ok: true, kid: protectedHeader.kid, claims: payload };
}

# pip install pyjwt[crypto] requests
import jwt, requests, time
from jwt import PyJWKClient

# PyJWKClient caches the key set and only refetches on an unknown kid.
_jwks = PyJWKClient("https://api.5arz.com/.well-known/jwks.json",
                    cache_keys=True, lifespan=86400)

def verify_seal(token: str) -> dict:
    key = _jwks.get_signing_key_from_jwt(token).key
    claims = jwt.decode(
        token, key,
        algorithms=["ES256"],
        issuer="https://5arz.com",
    )  # raises on bad signature or expiry
    return claims

// go get github.com/lestrrat-go/jwx/v2
package seal

import (
    "context"
    "time"
    "github.com/lestrrat-go/jwx/v2/jwk"
    "github.com/lestrrat-go/jwx/v2/jwt"
)

const jwksURL = "https://api.5arz.com/.well-known/jwks.json"

var cache = jwk.NewCache(context.Background())

func Init() { cache.Register(jwksURL, jwk.WithMinRefreshInterval(24*time.Hour)) }

func VerifySeal(ctx context.Context, token []byte) (jwt.Token, error) {
    set, err := cache.Get(ctx, jwksURL)   // served from cache
    if err != nil { return nil, err }
    return jwt.Parse(token,
        jwt.WithKeySet(set),
        jwt.WithValidate(true),
        jwt.WithIssuer("https://5arz.com"),
    )
}

# Look at the key set — this is the only network call verification needs.
curl -s https://api.5arz.com/.well-known/jwks.json

# {
#   "keys": [{
#     "kty": "EC", "crv": "P-256",
#     "x": "amC_s6qLClaKsDqE5594am8QSc5GP6agTTbjbM_jRdM",
#     "y": "GYq97U3A7ZuBGJdGEnC_f6dq6HG4MS1RBuKRhJf1T2U",
#     "kid": "5arz-oracle-2", "alg": "ES256",
#     "use": "sig", "key_ops": ["verify"]
#   }]
# }

# Save it. From here on, verification is local:
curl -s https://api.5arz.com/.well-known/jwks.json > jwks.json

# Read a credential's claims without verifying (inspection only —
# NEVER trust these until the signature checks out):
echo "$JWT" | cut -d. -f2 | base64 -d 2>/dev/null | jq .

// No dependencies — WebCrypto is in every modern browser and in
// Node 16+ via globalThis.crypto. This is what the widget above runs.

const b64u = s => Uint8Array.from(
  atob(s.replace(/-/g,'+').replace(/_/g,'/')
        .padEnd(Math.ceil(s.length/4)*4,'=')),
  c => c.charCodeAt(0));

async function verify(token, jwks) {
  // An SD-JWT VC is "<jws>~…" — the signature covers the part before the first ~
  const [h, p, s] = token.split('~')[0].split('.');
  const hdr = JSON.parse(new TextDecoder().decode(b64u(h)));
  const jwk = jwks.keys.find(k => k.kid === hdr.kid);
  if (!jwk) throw new Error('unknown kid: ' + hdr.kid);

  // IMPORTANT: strip use/key_ops before importKey. Chrome and Safari
  // reject a JWK whose key_ops does not exactly match the usages you
  // request, and our JWKS publishes both fields. This one line is the
  // difference between working and a DataError.
  const { use, key_ops, ...clean } = jwk;

  const key = await crypto.subtle.importKey(
    'jwk', clean, { name:'ECDSA', namedCurve:'P-256' }, false, ['verify']);

  return crypto.subtle.verify(
    { name:'ECDSA', hash:'SHA-256' }, key,
    b64u(s), new TextEncoder().encode(h + '.' + p));
}