Enterprise authentication platform
Ship auth,
not infrastructure
OAuth2, OpenID Connect, passkeys and multi-tenant identity for your product and the AI agents that use it. First token in minutes.
Every account starts on a free trial. No credit card, and you reach the console straight away.
Welcome back!
Track activity across your realms, clients and users at a glance.
Distribution by Realm
- vertexa-prod: 12
- vertexa-staging: 9
- partner-hub: 7
- mobile-apps: 5
- internal: 3
- vertexa-prod: 128
- vertexa-staging: 86
- partner-hub: 64
- mobile-apps: 41
- internal: 18
Realm Status
- Active: 9 (75%)
- Inactive: 3 (25%)
Recent Realms
- Active
vertexa-prod
12 clients · 128 users · created 2 months ago
- Active
partner-hub
7 clients · 64 users · created 3 weeks ago
- Inactive
mobile-apps
5 clients · 41 users · created 5 days ago
Standards Auth.io implements
Built on published specifications
OAuth 2.0
RFC 6749
OpenID Connect
Core 1.0
JSON Web Token
RFC 7519
PKCE
RFC 7636
JSON Web Key Set
RFC 7517
Server Metadata
RFC 8414
Introspection
RFC 7662
Revocation
RFC 7009
Device Authorization
RFC 8628
Token Exchange
RFC 8693
Resource Indicators
RFC 8707
Passkeys
WebAuthn L2
Every endpoint follows the published spec. You can check any of it against the RFC before you sign up.
A portal built for identity teams
Six screens, one glance. Every card below is built with the real components of the product, rendered with representative data.
Charts that answer security questions
Access activity over time, grant type distribution, and environment breakdowns per realm: devices, browsers and top IP addresses.
Access Analytics
Traffic, grant types and environment breakdowns for every realm.
Access Activity
- 08: 42
- 09: 88
- 10: 134
- 11: 121
- 12: 96
- 13: 84
- 14: 128
- 15: 156
- 16: 148
- 17: 117
- 18: 74
- 19: 51
- Success: 1,239 (96%)
- Failed: 48 (4%)
Grant Types
- Password Login1,289
- Token Refresh704
- Authorization Code458
- Client Credentials261
- API Key135
Devices
- Desktop1,892
- Mobile743
- Tablet212
Browsers
- Chrome1,521
- Safari634
- Firefox388
- Edge304
Top IP Addresses
- 187.44.120.8402
- 34.201.10.77288
- 52.67.190.14173
- 191.36.8.20196
Every access attempt, on the record
Every token issued, and every one blocked, becomes an audit event with full context: who, from where, and why it failed.
Audit & Access Intelligence
4,531 events recorded
Recent Access Events
Password Login
2 min ago
187.44.120.8Chrome 126Windows 11Client Credentials
8 min ago
34.201.10.77Token Refresh
15 min ago
52.67.190.14Safari 17macOS 15Password Login
23 min ago
191.36.8.201Firefox 128Ubuntu 24.04Invalid credentials, account locked after 5 attempts
Everything at a glance
Realms, clients, users and billing in a single command center, updated in real time.
Welcome back!
Track activity across your realms, clients and users at a glance.
Distribution by Realm
- vertexa-prod: 12
- vertexa-staging: 9
- partner-hub: 7
- mobile-apps: 5
- internal: 3
- vertexa-prod: 128
- vertexa-staging: 86
- partner-hub: 64
- mobile-apps: 41
- internal: 18
Realm Status
- Active: 9 (75%)
- Inactive: 3 (25%)
Recent Realms
- Active
vertexa-prod
12 clients · 128 users · created 2 months ago
- Active
partner-hub
7 clients · 64 users · created 3 weeks ago
- Inactive
mobile-apps
5 clients · 41 users · created 5 days ago
Identity details with context
Inspect user, realm and role information with security signals in one place.
User Management
Search, inspect and manage identities across every realm.
Users
Sofia Almeida
sofia@vertexa.io
vertexa-prod3 rolesActivelast login 2 min agoMarcos Ribeiro
marcos@vertexa.io
vertexa-prod2 rolesActivelast login 15 min agoJulia Castro
julia@partner.co
partner-hub1 rolePendinglast login neverDaniel Souza
daniel@vertexa.io
vertexa-staging4 rolesActivelast login 1 hour ago
Key lifecycle at scale
Active and revoked key inventory with rotation, ready for audit.
Security Keys
Signing and encryption key material per client, with rotation.
RS256
CurrentRSA Key · SIG
8f2c1a9e-77b4-4f10-9d3a-2b6f0c4e8a51Created Jun 12, 2026
ES256
EC Key · SIG
c41d7b02-3e88-45c6-b7f9-91a2d5e6c3f0Created May 30, 2026
RS256
RSA Key · ENC
a93f5e17-6c02-49d8-8b41-f07c3a9d2e64Created May 2, 2026
RS256
RSA Key · SIG
5d80b6c3-19af-4e72-a0c5-84e1f2b7d9a3Created Feb 18, 2026
Security controls where they matter
Centralize API secrets, authentication requirements and token configuration in a single flow for each client.
- Scoped secrets with expiry and usage tracking
- PKCE and client authentication enforcement
- Token issuer, audience and TTL settings
API Secrets
Scoped machine credentials with expiry and usage tracking.
Active secrets
production-api
sk_live_9f2a••••••••••••api:readapi:writeExpires Dec 1, 2026used 4 min agoci-pipeline
sk_live_c7d1••••••••••••api:readExpires Oct 1, 2026used 1 hour agolegacy-integration
sk_live_04be••••••••••••api:readusers:readExpires in 12 daysused 2 days ago
Client Authentication
Token Configuration
Issuer
https://auth.authio.com/realms/vertexa-prodAudience
api://vertexa-platformA realm is a wall, not a filter.
Users, clients and signing keys belong to exactly one realm. A token issued in one realm does not verify in another.
Separate signing keys
Each realm publishes its own JWKS. That is where the boundary is enforced, on every token you verify.
Separate clients
Client ids, secrets and redirect URIs are scoped to the realm that created them.
One account, one bill
Realms share nothing except the account they are billed to.
How a token is issued, and how it stays valid.
Three moments: the challenge, the exchange, and the key that outlives its own rotation.
The verifier never leaves your app
Your app sends a challenge and keeps the verifier. A code intercepted on the way back is worth nothing without it.
- 4 OAuth2 grant types
- PKCE support (S256, Plain)
- OIDC discovery & JWKS
One exchange, one signed token
The code and the verifier come back together. Auth.io signs the token, records the event, and hands it over.
- Signed RS256
- Every issue is audited
- Your app sends the user to Auth.io with a code challenge and keeps the verifier.
- Auth.io returns a short-lived code.
- Your app exchanges the code together with the verifier.
- Auth.io returns a signed access token valid for 3600 seconds.
- Your app calls your API with the token as a Bearer credential.
- Your API verifies the signature against the realm's cached public keys, with no call back to Auth.io.
Rotation does not break tokens in flight
The retiring key stays published in JWKS until the last token it signed has expired. Your API keeps verifying offline throughout.
- Verified against JWKS
- No call back to Auth.io
not to scale
- kid 8f2c1a9e: published, no longer signing
- kid c41d7b02: signing
- kid 5d80b6c3: published
- Your app sends the user to Auth.io with a code challenge and keeps the verifier.
- Auth.io returns a short-lived code.
- Your app exchanges the code together with the verifier.
- Auth.io returns a signed access token valid for 3600 seconds.
- Your app calls your API with the token as a Bearer credential.
- Your API verifies the signature against the realm's cached public keys, with no call back to Auth.io.
not to scale
- kid 8f2c1a9e: published, no longer signing
- kid c41d7b02: signing
- kid 5d80b6c3: published
Give AI agents access, not your passwords.
Auth.io is the authorization server for your MCP servers. Agents find it on their own, sign the person in, and get a token that only works where it was sent.
- 1AI agent → MCP serverPOST /mcp, no token
- 2MCP server → AI agent401 · resource_metadata
- 3AI agent → Auth.iosign in with PKCE + resource
- 4Auth.io → AI agenttoken, aud = the MCP server
- 5AI agent → MCP servertool call with Bearer
- 6MCP server → Auth.iointrospect: still active?
- 7MCP server → Auth.iotoken exchange for github
- 8Auth.io → MCP serverthe person’s GitHub token
- 9MCP server → GitHubGET /user/repos
- 10MCP server → AI agenttool result
- POST /mcp, no token
- 401 · resource_metadata
- sign in with PKCE + resource
- token, aud = the MCP server
- tool call with Bearer
- introspect: still active?
- token exchange for github
- the person’s GitHub token
- GET /user/repos
- tool result
RFC 9728 · RFC 8414
Zero-config discovery
Protected resource metadata leads the agent to your realm’s server metadata. No client-side setup.
RFC 8707
Tokens with an address
The token’s audience is the MCP server it was requested for. Any other server refuses it.
RFC 7662
Revocation that reaches agents
Introspection answers whether a token is still active, so ending a session stops tools, not just browsers.
RFC 8693
Connected accounts
GitHub and other providers are connected once per person. Servers exchange for a short-lived token and never see a refresh token.
Plug in any MCP client that speaks OAuth
Register the MCP server as a resource server, allow the agent’s client, and connect. Usage is audited per server, per person and per client, and licensed by plan.
claude mcp add --transport http \
--client-id your-mcp-client \
my-tools https://mcp.example.com/mcpBuilt for every use case
Filter by area to see how Auth.io fits your architecture.
MCP authorization
Protect MCP servers as resource servers: discovery, audience-bound tokens and introspection, per realm.
Connected accounts
A vault for each person’s GitHub and provider tokens, exchanged on demand for the MCP server that needs them.
OAuth2 & OIDC
Authorization Code, Password, Refresh Token and Client Credentials grants.
Passkeys
Phishing-resistant WebAuthn sign-in, as a second factor or with no password at all.
Second factors
Authenticator codes and push approval on a registered device, configured per client.
Realm isolation
Complete tenant separation with independent realms for data and configuration.
Identity federation
Google, Entra ID, GitHub or any OIDC provider, with roles mapped from the claims they send.
Organizations
B2B customers inside a realm, routed by claimed e-mail domain and carried in the token.
Custom token keys
Per-client signing and encryption keys with full configuration control.
Device flow
Sign in on TVs, command-line tools and kiosks with a short code typed on another device.
Delegation and impersonation
Narrowed on-behalf-of grants, and audited support sessions as a user.
Claim mappers
Shape what each client’s tokens carry, drafted from a sentence by the advisor and reviewed as a diff.
User management
Role-based access control per user, client and realm with fine-grained permissions.
Session management
Track and manage active sessions and tokens through the portal.
Network policy
IP allowlists per client and per user, with approval for sign-ins from somewhere new.
AI advisor
Reviews each client’s configuration, explains failed sign-ins and proposes changes you approve.
Webhooks
Signed events per realm and client, with a delivery log, retries and replay.
Migration
Import users from Keycloak, Auth0, Cognito and Okta, with a preflight check before anything is written.
Custom login UI
Brand the hosted authentication screens to match your product.
NextAuth integration
Seamless OIDC integration with NextAuth for modern applications.
Client management
Full client lifecycle with independent configuration per application.
Audit logs
Every access attempt recorded with device, browser, IP and failure context.
Access analytics
Activity timelines, grant type distribution and environment breakdowns per realm.
Token inspector
Decode and verify a JWT in the portal, without leaving the realm it was issued for.
Usage-based pricing
Pay only for successful logins and active sessions, billed through Stripe.
Showing 25 capabilities
Every flow, drawn before you sign up.
The questions identity teams ask on the first call, answered as drawings of what Auth.io actually does.
Sign in with your customers’ identity providers
Google, Entra ID, GitHub or any OIDC provider, per realm. You decide whose account an arrival lands in, and an e-mail only links accounts while the provider is trusted to have verified it.
- The provider answers with a subject identifier and an e-mail address.
- The linking mode decides whose account that arrival lands in.
- Linking on a verified address depends on this provider being trusted for it; without that trust nothing is linked, and the arrival is treated as creating an account.
- Role rules run afterwards, and decide only what the settled account may do.
Integrate in minutes
Copy-paste ready snippets for the most common authentication flows.
import NextAuth from "next-auth"
export const { handlers, signIn, signOut, auth } = NextAuth({
providers: [
{
id: "authio",
name: "Auth.io",
type: "oidc",
issuer: process.env.AUTHIO_ISSUER,
clientId: process.env.AUTHIO_CLIENT_ID,
clientSecret: process.env.AUTHIO_CLIENT_SECRET,
authorization: {
params: { scope: "openid profile email" }
}
}
]
}){ "exp": 1774170000, "iat": 1774166400, "auth_time": 1774166400, "jti": "0b9d3a5e-1c48-4f27-9a63-84e0d7f2b615", "iss": "https://auth.authio.com/realms/vertexa-prod", "aud": "vertexa-web", "sub": "9c4f2b71-0d3a-4f88-b0d2-5a1e7c6d4e10", "typ": "ID", "azp": "vertexa-web", "sid": "6f1b0c4d-2e77-4a91-8f30-c25d9b3a7e02", "acr": "1", "email_verified": true, "scope": "openid profile email"}- iss
- The realm this token came from. Check it on every request.
- sub
- The stable id of the person who signed in.
Replace {realm}, YOUR_CLIENT_ID and YOUR_CLIENT_SECRET with the values from your dashboard.
The AI advisor proposes. You apply.
Auth.io reads how a client is configured and what its sign-ins actually look like, then tells you what to change. It reads no configuration of yours until you switch it on, it changes nothing you have not pressed Apply on, and it is nowhere near the sign-in path.
What it hands back
A review reads one client’s configuration and its sign-in activity over a window you choose — thirty days unless you say otherwise, and ninety at most — then comes back with findings: what it noticed, why that matters, and what to change. What arrives is a paragraph you read, not an action already taken.
- Findings
- What a review of one client turned up, ranked worst first, each one quoting the setting it is about.
- Proposed changes
- Current value beside proposed value, across sixteen settings, with Apply and Undo left in your hands.
- Highlights
- One reading across the realms you turned it on for, which says how many it was not allowed to read.
- Causes
- Why this client’s sign-ins are failing, with the counted failure reasons printed underneath so you can check the answer.
Four of the thirteen. The other nine answer inside the screen where the question comes up: a typed sentence instead of an audit filter, a security questionnaire answered from your real configuration, a token read against the use case you describe, an integration guide for a stack we ship no guide for.
Access tokens outlive the session that issued them
In your setup
Access tokens on this client last 720 minutes. The session they belong to lasts 60. Of 39,004 authentication attempts in the last 30 days, 38,412 used the refresh token grant.
Why it matters
A token that stays valid for twelve hours cannot be withdrawn for twelve hours. Ending somebody’s session leaves every access token already issued to them working until it expires on its own.
What to change
Bring the access token lifetime down to 15 minutes and let the refresh token carry the session. This client is already refreshing, so nobody has to sign in again.
Before you switch it on
- What leaves
- The snapshot is assembled one field at a time, so a setting reaches the advisor only because somebody added it there by name. Where a value cannot be shown, what is shown is what can be concluded about it: a signing key contributes its age and whether it is overdue for rotation, never its material.
Leaves for analysis
- This client’s protocol, token and password settings
- How old its keys and secrets are
- Its sign-in successes and failures, added up
Never leaves
- Client secrets
- Passwords and password hashes
- Private key material
- Machine credentials and API keys
- Anything that identifies one of your users
None of that is stripped out of what is sent. None of it is ever put in. The sign-in figures are counts the database computed, and no individual row of the access log is read at any point, so an address, a username or a failure message has nothing to be removed from.
- Where it goesclaude-haiku-4-5
- One provider, Anthropic’s Claude, reached from one file. Every capability runs on the model below unless a deployment names another one. The standing instruction is byte-identical for every account, because what belongs to your tenant travels in the request and never in the part that is cached.
- What it can change
- One capability out of the thirteen that call a model can write to a client, and only when you press Apply on a proposal you have read — there is no path in the product that applies one on its own. It writes through the same validated, audited route your own edit takes, over a fixed list of sixteen settings that does not include client secrets or redirect URIs, and it records what each setting held so it can be put back. If the client changed while the proposal was sitting there, Apply is refused rather than resolved for you.
Three of the sixteen
- Protocol.PkceRequired
- TokenPolicy.AccessTokenLifetimeMinutes
- Lockout.MaxFailedAccessAttempts
- Who turns it on
- Reading a client’s configuration is off until somebody in your account switches it on, per realm or per client. A client’s own decision wins in either direction: it can be read inside a realm that opted out, and left out of one that opted in. Four things sit outside that switch, and they are named here because you would find them anyway. Turning a typed sentence into an audit filter sends your realm and client names, so the sentence has something to be matched against. A documentation answer sends only the passages the console already had. A token reading sends the shape your browser reduced a token to, and the server rejects the request outright if anything in it still looks like a token. An import pre-flight sends counts. None of the four sends a configuration.
- What a run costs you
- This is bounded twice: a run allowance on your plan, counted per calendar month in UTC rather than per billing cycle, and a per-minute request limit under it. A client review, a configuration proposal and a dashboard reading each spend one run of that allowance. The console reads the figure it shows you from the same place the platform reads it when it refuses a run, so the number you are shown and the number you are held to cannot disagree. A plan that names no ceiling is not capped.
- Switching it off
- Withdrawing consent is recorded rather than deleted, so “never asked” and “asked and declined” stay different answers. Undoing a proposal that was applied is deliberately not gated on consent still being on, so switching the advisor off does not strand a change it made. And where a deployment has configured no provider credential at all, every one of these endpoints refuses at the moment of asking rather than accepting work it will never do.
None of this is in the sign-in path. Every one of these endpoints lives under the admin API: not in the token endpoint, not on the login page, and not in anything your users ever touch.
Coming in, and getting back out.
The two questions nobody asks until they are already committed to a vendor.
- Migrating in
- Import an export from Keycloak, Auth0, Cognito or Okta. Keycloak realms hashed with PBKDF2 or Argon2id bring their passwords across, verified in place, so those people never notice the move. So does an Auth0 export carrying its bcrypt hashes. Cognito and Okta release no credential material at all, so those arrive needing a password reset.
- Taking the record with you
- Filter the access and change trails by date, realm, client or outcome, then export exactly that range as CSV. It is the same trail an auditor asks for.
Your own Authio, on infrastructure of its own
On the Dedicated plan, Authio provisions a complete environment for your account alone — its own API, console, database and cache — and your console becomes the place you watch and operate it.
- Create the project
- Create the database
- Create the cache
- Create the API
- Create the console
- Assign the addresses
- Configure the variables
- Deploy
- Wait until it answers
- Send the welcome e-mail
- Nothing shared
- Its own API, console, PostgreSQL and Redis, in a project no other customer runs in.
- Provisioned when you pay
- Paying starts the assembly. Your console shows each step as it completes, and you get an e-mail when the environment is ready.
- On your domain
- Reach it at its own addresses from the start, and move it to a domain of yours with a couple of DNS records.
- Watched and operated from your console
- CPU, memory, network and disk per service, usage and logs — and restart, redeploy or stop any service when you need to.
- Rebuilt in one step
- Remove an environment or recreate it from scratch, even one that is stuck or failed.
- Kept when a payment lapses
- A lapsed subscription suspends the environment and keeps its data for 30 days, with a reminder a week before anything is deleted.
Pricing that grows with you
You are counted once per successful authentication. Token refreshes and failed attempts inside a session are free.
What counts as one billable event
A successful authentication opens a session and is counted once. Everything that happens inside that session is free.
- successful login: counted once
- client credentials: counted once
- token refresh: not counted
- failed attempt: never counted
Loading pricing plans...
Frequently asked questions
Everything you need to know about Auth.io.
Auth.io supports 4 OAuth2 grant types: Authorization Code, Password, Refresh Token, and Client Credentials. We also provide full OIDC support with NextAuth.js integration.
Each realm provides complete tenant isolation with independent configurations, users, and clients. You can create multiple realms to separate different environments or customers, each with their own authentication rules.
Yes! Each client can have its own signing and encryption keys. You have full control over token lifetimes, refresh token policies, and custom claims through the dashboard.
You only pay for successful logins and active sessions. Billing is calculated per authentication event (login with password or client_credentials grant). Failed attempts and token refreshes are not charged.
An environment of Authio for your account alone: its own API, console, PostgreSQL and Redis, provisioned automatically once you pay. There is no trial on it — you pay before the first sign-in — and your console turns into the place you watch and operate the environment: metrics, logs, deployments and its domain.
Yes. It starts on addresses of its own, and you can point a domain of yours at it from the environment’s domain settings by adding the DNS records the console shows you.
Yes. On plans that include login customization, each client’s sign-in screen takes your layout, colors, logo and background; the plans on the pricing page say which include it.
Users are isolated by realm. Each user belongs to a specific realm, shares one set of credentials across it, and signs in only through the clients of that realm that let it in.
The portal includes complete management interfaces for realms, clients, users, sessions, tokens, and billing. You can view real-time analytics, manage roles, configure authentication flows, and monitor active sessions.
Start building with Auth.io
Create your realm, register a client and issue your first token today. Every account starts on a free trial, and no credit card is asked for.
- Setup in minutes
- Usage-based pricing
- Cancel anytime