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.
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>
| Attribute | Values | Notes |
|---|---|---|
handle | the holder's handle | Required. |
size | card · badge · chip | Card scales to its container's width (set width in CSS). |
gyro | boolean | Tilt with the device on phones (iOS asks permission on first tap). |
flippable | false | Disable 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'.| Claim | Meaning |
|---|---|
iss / aud | https://gethumanpass.com / your site's origin |
sub | Pairwise id: stable per person for your origin, unlinkable across origins |
human, level | true, and the on-chain verification level (e.g. sharering_checked) |
hp_nonce | The nonce you passed in. Bind it to your session to stop replays |
hp_handle, hp_url | Only when you ask for shareHandle: true and the person agrees |
hp_method | phone: 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 / jti | Valid 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.
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 false5 · "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.
7 · REST API
Every endpoint below is public, CORS-enabled JSON.
| Endpoint | Returns |
|---|---|
GET /api/v1/pass/:handle | The public pass: number, level, country, on-chain proof, status, stats. 404 means not a verified human. |
GET /api/v1/pass/:handle/attestation | A signed JWS of the same facts, valid for 1 hour. Cache it or show it offline. |
GET /api/v1/live/:handle | The 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/:id | pending · 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 …/ask | The 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/:id | Ask a holder to prove, right now, that it's them |
GET /api/v1/stats | Live #BanTheBots counters |
/.well-known/openid-configuration | Sign in with Human Pass (OIDC, code + PKCE, RS256) |
GET /.well-known/jwks.json | Public keys for offline verification |
Why bots and AI can't fake one
sub per person.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