Auth for apps and AI agents

Passkeys for people. OAuth for agents.

One hosted auth layer for both. The sign-in your users never think about, plus the OAuth handshake Claude and ChatGPT require — on your own subdomain, wired up in an afternoon.

  • AuthPop is a hosted sign-in service: passkey login for your users and the OAuth flow AI agents require, on your own subdomain.
  • Built for developers shipping a web app or MCP server — you get sign-in and agent authorization without running auth infrastructure.
  • Free while in beta — 3 apps per account, 10,000 monthly active users, no card.
Watch it happen

AuthPop is in a private beta while we finish it properly. Leave your email and we will send your invite as spots open. Already have an account? Sign in.

Here because Claude said your MCP connector needs OAuth? Here are the two lines you need →

Runs the MCP auth for checkaeo.ai in production.

01$ curl api.yourapp.com/mcp
02401 WWW-Authenticate: Bearer
03↳ Claude asks AuthPop for access
04↳ you sign in — Face ID, no password
05↳ you authorize Claude
06200 { "email_verified": true }
OAuth 2.1 + PKCEWebAuthn passkeysDynamic client registration ES256 · JWKSRFC 8414 / 8707 / 9728
One layer, two doors

People sign in. Agents get authorized.

Both arrive at the same place: an identity your server can prove, on a request it can verify by itself.

People

Passkeys

Face ID, Touch ID, or a password manager, then a code that proves the inbox. No password is ever created, so none can be stolen.

Agents

OAuth 2.1

Claude, ChatGPT, and Cursor discover your sign-in server, register themselves, and ask the human for permission — the standard flow, hosted.

AuthPop

One verified identity

A signed ES256 token carrying sub, email, and email_verified.

Your API
How it works

Live in three steps

Your app gets its own sign-in server at yourapp.authpop.dev the moment you name it.

01

Name your app

yourapp.authpop.dev exists the moment you pick a name — sign-in pages, signing keys, everything included. From the dashboard, or by asking your AI assistant.

02

Paste two lines

Tell your API where sign-in lives. Claude, Cursor, and ChatGPT handle the rest of the flow themselves — there is no OAuth to implement. OAuth 2.1 · RFC 9728

03

Verify the token

Every request arrives with a signed JWT. Verify it with any JWT library — about 30 lines, sample included — and you know who the user is and that their email is real. ES256 · JWKS

The short path

Skip the OAuth docs. Just ask.

AuthPop is itself an MCP server. Add it to Claude once, and setting up auth becomes a sentence rather than an afternoon of reading specs.

You: Set up sign-in for my app "recipeboard"

Claude: Done.
        recipeboard.authpop.dev is live
        Passkey sign-in and email verification on
        Ready for MCP clients to connect
        I have the two lines your API needs and the token check

       Want me to add them to your code?
authpop.com/mcpAdd this to Claude. Signing in with your passkey is the setup — no key to copy, nothing to configure.
yourapp.authpop.devWhat your app gets: its own sign-in server, on its own subdomain, isolated from every other app.
Under the hood

Your entire auth integration

On one screen, in case you would rather see it than be told about it. There is no SDK and nothing proprietary — this is the OAuth your server already knows how to speak.

# 1 — your MCP server answers unauthenticated calls with:
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer resource_metadata=
  "https://api.yourapp.com/.well-known/oauth-protected-resource"

# 2 — that metadata points agents at your app's sign-in server:
{ "resource": "https://api.yourapp.com/mcp",
  "authorization_servers": ["https://yourapp.authpop.dev"] }

# 3 — verify the JWT that arrives (any JWT library):
jwks  = https://yourapp.authpop.dev/.well-known/jwks.json
alg   == ES256
iss   == https://yourapp.authpop.dev
aud   == https://api.yourapp.com/mcp
exp   still in the future

# you now know who the user is:
claims: sub, email, email_verified

Full walkthrough, including the trust rules that matter, in the docs.

Included

What you never have to build

The parts of auth that eat weekends, run as a service.

No passwords, ever

Users sign in with Face ID, Touch ID, or their password manager. There's no password to store, phish, or breach. WebAuthn

Agents connect out of the box

claude.ai, Cursor, and ChatGPT ask your server for sign-in; we answer in their protocol. You never touch it. OAuth 2.1 · DCR · PKCE

Emails you can trust

The inbox is verified before an account exists at all. Your server sees email_verified and can rely on it.

Every app isolated

Each app is its own WebAuthn relying party on its own subdomain, so a passkey made for one app cannot be presented to another — and credentials are looked up per app besides.

Any language. No SDK.

If your stack can verify a signed JWT, it works. Nothing proprietary to install, nothing to keep up to date. RFC 8414 · 7591 · 8707

Never in your request path

Tokens verify locally against public keys, so AuthPop is not a runtime dependency. If we are slow, your API is not.

In production

AuthPop runs the sign-in for checkaeo.ai — our own product, and the reason this exists.

Every flow on this page is the one running there: the same 401, the same passkey ceremony, the same tokens. Built because we needed it, then made worth selling.

Straight answers

Before you hand over your sign-in

Authentication is the one dependency you cannot casually swap, so these are the questions we would ask — answered including the parts that don't flatter us.

Is AuthPop production-ready, and who is actually using it?

One product runs on it in production today — CheckAEO — and CheckAEO is ours. It is first-party, which we would rather say plainly than imply a customer list we don't have; it also means every flow on this page is one we depend on daily rather than a demo.

The whole auth surface went through three adversarial security reviews in August 2026 — run by us, not hired auditors, and written up in full, findings and all. One finding is deliberately still open: an app's existence is discoverable from its subdomain. (Two others tracked at review time have since closed: signing-key rotation shipped, and privileged actions are now recorded internally — the owner-facing view of that record is planned as paid.) The free tier caps you at 3 apps per account.

What happens to my users if AuthPop goes down — or shuts down?

Requests that are already authenticated keep working. Your server verifies tokens locally against a JWKS it caches, so nothing calls us while your API is serving traffic — if we are slow or offline, your API is not.

What an outage does break is the front door: new sign-ins, consent, and refreshing an expired token all happen here, so nobody new gets in and access tokens drain away as they expire (1 hour). If AuthPop shut down permanently, your users' passkeys would not carry over to a replacement provider — you would point your app at another OAuth provider and your users would enroll a new credential there. We are a small operation; weigh that honestly.

Am I locked in? What does leaving look like?

There is no AuthPop SDK and no proprietary token format to unwind. It is standards-based OAuth — PKCE, RFC 8414 discovery, RFC 7591 client registration, ES256 JWTs — so moving to another provider means replacing the authorization-server configuration and re-registering your clients there, not rewriting your application around a different vendor's SDK.

Two honest caveats. A passkey is bound to the domain it was created on — that is what makes it phishing-resistant — so your users' AuthPop passkeys cannot simply be moved to another provider's domain; they would enroll a new credential there. And there is no bulk export endpoint today — in practice your app already holds the list, because every token you accept carries sub and email.

How are users verified, and what do you store about them?

No passwords — none are ever created, so there is nothing to breach, phish, or reset. Email ownership is proven with a 6-digit code before the account exists at all, so nobody can register an address they don't hold, and the token your server receives carries email_verified. Our docs still tell you to key your users off sub rather than email, as defence in depth.

Per user we store an email address, the public half of each passkey (the private half never leaves their device), sign-in timestamps, which OAuth clients they approved, and refresh-token records. No profile data, no analytics on your users. What we do not have yet: SOC 2, a signed DPA, or any other compliance paperwork — if procurement requires those, we are not the right fit today.

What if a user loses their passkey — or has never used one?

First-timers need no explanation: they see the prompt their device already shows for Face ID, Touch ID, or their password manager, and most people never learn the word "passkey". Most passkeys also sync through iCloud Keychain, Google Password Manager, or a password manager, so a new phone usually just works.

When it doesn't — a lost device, or a computer with none of their credentials on it — they enter their email on the sign-in page, get a 6-digit code, and enroll a fresh passkey on the same account; an account can hold several. The tradeoff worth naming: email is the recovery path, so an account is only as strong as its inbox. And there is no owner-side "reset this user" button in the dashboard yet.

Can I use my own domain instead of yourapp.authpop.dev?

Not yet, and we don't have a date to promise.

The subdomain is not cosmetic: a passkey is bound to the exact domain it was created on, which is what stops one app's passkey being usable against another. Custom domains mean per-customer domain verification plus a credential migration path for anyone already enrolled, and we would rather not ship that half-built. Until then, your users see yourapp.authpop.dev on the sign-in and consent screens.

How is this different from Auth0, Clerk, or WorkOS?

They are far bigger and do far more: enterprise SSO and SAML, organisation and role management, compliance paperwork, support contracts. AuthPop has none of that — if you need any of it, buy one of them instead.

What it does is narrow: one authorization server that handles human passkey sign-in and AI agents (Claude, ChatGPT, Cursor) through the same OAuth flow, MCP-ready by default, with no SDK to install and no passwords anywhere in it.

What will it cost, and what does free actually cover?

Nothing is paid today. The free tier is 3 apps per account, 10,000 monthly active users across them, AuthPop branding on the sign-in page, and fair-use rate limits — no card, no trial countdown.

Cross the user limit and we will not lock your existing users out. Sign-ins and tokens keep working; you get a note in the dashboard, creating a new app pauses, and we talk. Throttling real users to prompt an upgrade is a thing we have decided not to do.

A paid tier would eventually cover what the free one deliberately leaves out — your own domain, your own branding, an audit log, more users. What it costs is genuinely undecided, and we would rather say so than print a number we would have to change. Free today is not a promise of free forever; this is standard OAuth, so moving is a configuration change rather than a rewrite.

Launching soon

Free while in beta. Leave your email and we will send your invite as spots open.