HUMAN PASS FOR WEBSITES

Bots can't fake it.
Two lines to show it.

Human Pass is a holographic proof-of-personhood card, backed by a ShareRing-checked identity anchored on ShareLedger. Show your users' passes on your site, or ask visitors to prove they're human. You get one stable ID per real person and never see their personal data.

Inline chip: posted by @tim

1 · Show a Human Pass

Drop in the script once, then use the element anywhere: profile pages, seller listings, comment threads, author bios. The card is live. It tilts, shimmers and ticks, and it checks the pass's status on every load, so revoked or fake handles show as not verified.

<script src="https://gethumanpass.com/embed.js" async></script>

<human-pass handle="tim"></human-pass>
AttributeValuesNotes
handlethe holder's handleRequired.
sizecard · badge · chipCard scales to its container's width (set width in CSS).
gyrobooleanTilt with the device on phones (iOS asks permission on first tap).
flippablefalseDisable tap-to-flip (the back shows a QR and on-chain proof).

2 · Verify a visitor is human

For sign-ups, giveaways, reviews, marketplaces and anything else bots abuse: HumanPass.verify() opens a holographic QR sheet. The visitor scans it in ShareRing Me, sees your site's name and approves with their PIN. Then you get a signed token. The sub is the same every time this person verifies with your site, and different on every other site, so you can enforce one account per human without tracking anyone.

const { token, claims } = await HumanPass.verify({
  siteName: 'Acme Marketplace',
  nonce: sessionNonceFromYourServer,   // echoed back inside the token
});
// claims.sub  -> stable, per-site id for this person (one human = one sub)
// claims.human -> true, claims.level -> "sharering_checked"
// claims.hp_method -> "phone" (PIN on the phone) or "browser" (Human Pass Lens)
// People can approve in Human Pass Lens without their phone. To require the phone,
// add requirePhone: true here and when you check the token (that check enforces it).
// Then check the token on your server (below). Never trust it client-side.
// Node / any backend: ask Human Pass to check the token...
const r = await fetch('https://gethumanpass.com/api/v1/token/verify', {
  method: 'POST', headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ token, audience: 'https://acme.example' }),   // + requirePhone: true for phone only
}).then(r => r.json());
if (!r.valid || r.claims.hp_nonce !== sessionNonce) throw new Error('not human');

// ...or verify it yourself: EdDSA (Ed25519) JWS, keys at
// https://gethumanpass.com/.well-known/jwks.json  (iss = https://gethumanpass.com, aud = your origin)
// and, unless you take Human Pass Lens, require claims.hp_method === 'phone'.
You'll need ShareRing Me and a Human Pass.
ClaimMeaning
iss / audhttps://gethumanpass.com / your site's origin
subPairwise id: stable per person for your origin, unlinkable across origins
human, leveltrue, and the on-chain verification level (e.g. sharering_checked)
hp_nonceThe nonce you passed in. Bind it to your session to stop replays
hp_handle, hp_urlOnly when you ask for shareHandle: true and the person agrees
hp_methodphone: approved with a PIN on the phone. browser: one click in Human Pass Lens, which the person's phone linked with a PIN in the last 30 days. To accept only phone, start with requirePhone: true and send requirePhone: true to /api/v1/token/verify, which then rejects a browser token (reason: "phone_required"). The start option only changes what the person is shown: the check on your server is what enforces it. If you check tokens yourself, require hp_method === "phone"
iat / exp / jtiValid for 10 minutes; jti is unique per approval

3 · Sign in with Human Pass

See it live: Lovely Dates, a demo dating app →

A standard OpenID Connect provider, so it plugs into the login stack you already have: Auth0, Clerk, Supabase, NextAuth/Auth.js, Firebase, Keycloak, Cognito and the rest. Users scan a QR with their phone and approve with their PIN. You get a signed id_token with human: true and a sub that's stable for that person on your site, so one human gets one account.

PKCE (S256) is required on every sign-in, with or without a client secret. Auth.js and most OIDC libraries send it already; a request without code_challenge comes back with invalid_request.

Register your app

We keep your email with our payment provider, Stripe, for your account and billing. If a partner referred you, we tell our partner programme so they get the credit.

By registering you agree to the Human Pass developer schedule, which applies on top of the ShareRing Link terms of service.

// Auth.js / NextAuth
providers: [{
  id: 'humanpass', name: 'Human Pass', type: 'oidc',
  issuer: 'https://gethumanpass.com',
  clientId: process.env.HP_CLIENT_ID,
  clientSecret: process.env.HP_CLIENT_SECRET,
  authorization: { params: { scope: 'openid profile' } },
  checks: ['pkce', 'state'],   // PKCE is required
}]

// Anything else: discovery document
https://gethumanpass.com/.well-known/openid-configuration

// id_token claims
{ "sub": "hp_…", "human": true, "level": "sharering_verified",
  "acr": "urn:humanpass:phone",   // or urn:humanpass:browser (Human Pass Lens)
  "hp_method": "phone",           // or "browser"
  "hp_handle": "tim", "hp_number": 1 }   // handle only with scope "profile" + consent

// Human Pass Lens: on for every client. Register with allow_browser: false, or ask us,
// to make a client phone only. We enforce that on our side. To ask for the phone on one sign-in, add acr_values=urn:humanpass:phone,
// and check acr on your server: the browser can drop that parameter.

4 · Is this account a verified human?

Holders link their accounts (X, Instagram, TikTok, YouTube, Facebook, LinkedIn, Twitch, Bluesky, Threads, OnlyFans, Tinder, Whatnot and more) by publishing a code from each one, so a link can't be claimed by someone who doesn't control it. Any platform, moderation tool or bot-checker can ask:

GET https://gethumanpass.com/api/v1/lookup?platform=x&handle=timbos
→ 200 { "verified": true, "private": false, "pass": { "handle": "tim", ... }, "anchored": { "tx": "…" } }
→ 200 { "verified": true, "private": true, "pass": null, "url": "https://gethumanpass.com/check/x/timbos" }
                                 // a verified human who keeps their pass private: url is their sealed pass
→ 404 { "verified": false }      // no verified human has linked this account

<human-pass account="x:timbos"></human-pass>        // the card behind an account: full, or sealed if private
https://gethumanpass.com/check/x/timbos                          // the same as a page anyone can open

GET https://gethumanpass.com/api/v1/pass/tim/check?platform=x&account=timbos
→ { "match": true, "anchored": { "tx": "…" } }   // public accounts only: a private one always says false

5 · "Prove it's really you"

For dating, marketplaces and DMs: before you trust someone who says they're @tim, send them a code. Only the real holder can answer it, with their phone and PIN. Every pass page has this button, and you can build it into your own product:

POST https://gethumanpass.com/api/v1/pass/tim/ask          → { "id": "…", "code": "7KQ2XR" }
// show the code; the person types it into Human Pass → Scan and approves with their PIN
GET  https://gethumanpass.com/api/v1/ask/{id}               → { "status": "pending" | "proved" | "expired" }

6 · Human Pass Lens (browser extension)

It puts a holographic tick next to verified humans on X, Bluesky, GitHub and TikTok, profiles and feeds alike, and warns you when a profile shows a Human Pass link it doesn't own.

Download for Chrome / Edge / BraveUnzip, open chrome://extensions, turn on Developer mode, then "Load unpacked".

7 · REST API

Every endpoint below is public, CORS-enabled JSON.

EndpointReturns
GET /api/v1/pass/:handleThe public pass: number, level, country, on-chain proof, status, stats. 404 means not a verified human.
GET /api/v1/pass/:handle/attestationA signed JWS of the same facts, valid for 1 hour. Cache it or show it offline.
GET /api/v1/live/:handleThe pass's rolling 30-second live code.
POST /api/v1/verify/start{ siteName, nonce, shareHandle, requirePhone } → { id, code, url, expires }. The embed calls this for you.
GET /api/v1/verify/:idpending · approved (with token) · declined · expired
POST /api/v1/token/verify{ token, audience, requirePhone? } → { valid, claims, reason? }, including whether the person has since revoked your site. With requirePhone: true a Human Pass Lens token is valid: false, reason: "phone_required"
GET /api/v1/lookup?platform=&handle=The verified human behind an account on any supported platform, or a website
GET /api/v1/account/:platform/:handle · POST …/askThe pass behind an account (sealed when private), and a live "prove it" request that never names a private holder
POST /api/v1/invite{ platform, handle, ref?, replyTo? } → a ready-made "prove you're human" post and the platform's compose link. Credits ref if that account joins
POST /api/v1/pass/:handle/ask · GET /api/v1/ask/:idAsk a holder to prove, right now, that it's them
GET /api/v1/statsLive #BanTheBots counters
/.well-known/openid-configurationSign in with Human Pass (OIDC, code + PKCE, RS256)
GET /.well-known/jwks.jsonPublic keys for offline verification

Why bots and AI can't fake one

Anchored identityA pass is only minted for a key that ShareLedger records as a ShareRing-verified identity, with at least one checked, unrevoked document.
Proof of presenceMinting, re-proving and website approvals need a fresh PIN-gated signature over a single-use challenge. Generated keys, copied signatures and replays all fail. Unless you require the phone, an approval can instead be one click in Human Pass Lens, in a browser the holder's phone linked with a PIN in the last 30 days, and the token says so.
One person, one passAn identity token, and every identity document, can back only one pass. Sites get one pairwise sub per person.
Live, not a pictureCards load from this server, tick, shimmer and show a rolling code. The pass page shows the same code. Revocations show up on every embed within hours.
Domain lockHolders can restrict where their badge may be embedded. Anywhere else, it shows a warning, not a check mark.
AccountableBehind every pass is a KYC'd person. A human can still choose to help a bot, but only once per site, and never anonymously.

Privacy and security

Built under ShareRing's ISO 27001 information security programme. Human Pass keeps no names, dates of birth, documents or photos, and sites get a pairwise id, not an identity.

Human Pass privacy notice · Human Pass terms of use · Developer schedule · ShareRing privacy policy · ShareRing terms and conditions