Skip to content

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.

Realms
12
9 active · +3 this week
Clients
38
34 active · 29 PKCE
Users
8.4K
across all realms
Billed events
126K
$114 est. cost

Distribution by Realm

  • vertexa-prod: 12
  • vertexa-staging: 9
  • partner-hub: 7
  • mobile-apps: 5
  • internal: 3
Clients
  • vertexa-prod: 128
  • vertexa-staging: 86
  • partner-hub: 64
  • mobile-apps: 41
  • internal: 18
Users

Realm Status

  • Active: 9 (75%)
  • Inactive: 3 (25%)

Recent Realms

View all
  • 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

Total Events
4,531
access events recorded
Successful
4,369
authentications passed
Failed
162
access attempts blocked
Success Rate
96%
Excellent

Recent Access Events

vertexa-prod

Password Login

2 min ago

Success
Sofia Almeida
187.44.120.8Chrome 126Windows 11
Jul 26, 2026, 10:42 AMView details

Client Credentials

8 min ago

Success
billing-service
34.201.10.77
Jul 26, 2026, 10:36 AMView details

Token Refresh

15 min ago

Success
Marcos Ribeiro
52.67.190.14Safari 17macOS 15
Jul 26, 2026, 10:29 AMView details

Password Login

23 min ago

Failed
unknown@mail.com
191.36.8.201Firefox 128Ubuntu 24.04

Invalid credentials, account locked after 5 attempts

Jul 26, 2026, 10:21 AMView details

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.

Realms
12
9 active · +3 this week
Clients
38
34 active · 29 PKCE
Users
8.4K
across all realms
Billed events
126K
$114 est. cost

Distribution by Realm

  • vertexa-prod: 12
  • vertexa-staging: 9
  • partner-hub: 7
  • mobile-apps: 5
  • internal: 3
Clients
  • vertexa-prod: 128
  • vertexa-staging: 86
  • partner-hub: 64
  • mobile-apps: 41
  • internal: 18
Users

Realm Status

  • Active: 9 (75%)
  • Inactive: 3 (25%)

Recent Realms

View all
  • 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.

Add user
Total users
8,412
all realms
Active
8,020
95% verified

Users

View all
  • Sofia Almeida

    sofia@vertexa.io

    Activelast login 2 min ago
  • Marcos Ribeiro

    marcos@vertexa.io

    Activelast login 15 min ago
  • Julia Castro

    julia@partner.co

    Pendinglast login never
  • Daniel Souza

    daniel@vertexa.io

    Activelast 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.

Rotate keys
Active keys
3
in rotation
Current
1
signing tokens now

RS256

Current

RSA Key · SIG

Active
8f2c1a9e-77b4-4f10-9d3a-2b6f0c4e8a51

Created Jun 12, 2026

ES256

EC Key · SIG

Active
c41d7b02-3e88-45c6-b7f9-91a2d5e6c3f0

Created May 30, 2026

RS256

RSA Key · ENC

Active
a93f5e17-6c02-49d8-8b41-f07c3a9d2e64

Created May 2, 2026

RS256

RSA Key · SIG

Revoked
5d80b6c3-19af-4e72-a0c5-84e1f2b7d9a3

Created 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.

New secret

Active secrets

3 secrets
  • production-api

    sk_live_9f2a••••••••••••
    Expires Dec 1, 2026used 4 min ago
  • ci-pipeline

    sk_live_c7d1••••••••••••
    Expires Oct 1, 2026used 1 hour ago
  • legacy-integration

    sk_live_04be••••••••••••
    Expires in 12 daysused 2 days ago

Client Authentication

PKCE requiredS256
Client secretEnforced
Lockout policy5 attempts / 15 min

Token Configuration

Issuer

https://auth.authio.com/realms/vertexa-prod

Audience

api://vertexa-platform
Access token TTL3600s

A 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.

vertexa-prod
users
clients
signing keys kid 8f2c1a9e
partner-hubits own users, clients and keys
mobile-appsits own users, clients and keys
one account, one bill
Three realms, drawn side by side. Nothing crosses the boundary.Three realms. The first holds its own users, clients and signing keys. A request from it toward a client in another realm stops at the boundary and is rejected, because each realm verifies against its own keys.

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
Auth.io
verifies the challenge
signs the token
records the event
authorize, with challenge
code
verifier, stays here
code and verifier
access token, 3600s
your API
Bearer
JWKS, cached
One sign-in, drawn as the six requests it actually is.A sequence diagram of three parties side by side: your app, Auth.io and your API. Auth.io is drawn nearly twice the height of the other two because it carries the three jobs you never have to build, verifying the challenge, signing the token and recording the event. Six requests run between the three, and the verifier stays with your app throughout the first three of them.
  1. Your app sends the user to Auth.io with a code challenge and keeps the verifier.
  2. Auth.io returns a short-lived code.
  3. Your app exchanges the code together with the verifier.
  4. Auth.io returns a signed access token valid for 3600 seconds.
  5. Your app calls your API with the token as a Bearer credential.
  6. 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
kid 8f2c1a9e
published, no longer signing
kid c41d7b02
signing
kid 5d80b6c3
published
rotation
last token expires

not to scale

JWKS
kid 8f2c1a9e
kid c41d7b02
kid 5d80b6c3
Rotating a signing key, drawn on the timeline it actually happens on.A key rotation on a timeline. The retiring key stops signing at the rotation but stays published in JWKS until the last token it signed expires, so tokens already in flight still verify. The new key signs from the rotation onward. Both are published at once during the overlap.
  1. kid 8f2c1a9e: published, no longer signing
  2. kid c41d7b02: signing
  3. 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.

  1. 1
    AI agent → MCP server
    POST /mcp, no token
  2. 2
    MCP server → AI agent
    401 · resource_metadata
  3. 3
    AI agent → Auth.io
    sign in with PKCE + resource
  4. 4
    Auth.io → AI agent
    token, aud = the MCP server
  5. 5
    AI agent → MCP server
    tool call with Bearer
  6. 6
    MCP server → Auth.io
    introspect: still active?
  7. 7
    MCP server → Auth.io
    token exchange for github
  8. 8
    Auth.io → MCP server
    the person’s GitHub token
  9. 9
    MCP server → GitHub
    GET /user/repos
  10. 10
    MCP server → AI agent
    tool result
An agent reaches a protected MCP server: it discovers Auth.io, signs the person in, and its server trades for a GitHub token only when a tool needs one.Four parties are drawn side by side: an AI agent, an MCP server, Auth.io and GitHub. The agent calls the MCP server without a token and receives a 401 naming the server’s metadata, which leads it to Auth.io. The agent signs the person in at Auth.io with PKCE and names the MCP server as the resource, and receives a token whose audience is that server. It calls a tool with the token; the MCP server asks Auth.io whether the token is still active. To reach GitHub, the MCP server exchanges the person’s token at Auth.io for their GitHub token, calls GitHub, and returns the tool’s result to the agent.
  1. POST /mcp, no token
  2. 401 · resource_metadata
  3. sign in with PKCE + resource
  4. token, aud = the MCP server
  5. tool call with Bearer
  6. introspect: still active?
  7. token exchange for github
  8. the person’s GitHub token
  9. GET /user/repos
  10. 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.

Connect a coding agentbash
claude mcp add --transport http \
  --client-id your-mcp-client \
  my-tools https://mcp.example.com/mcp

Built 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.

Somebody arrives through the provider
sub — the provider’s own identifier for them
email — the address it says they hold
Create an account
A new account, linked to this provider
Link on a verified address
The existing account holding that address
while this provider is trusted for the addressotherwise nothing is linked, as if creating an account
Only linked accounts
Nobody: only identities already linked get in
Once the account is settled, the provider’s claim rules decide what it may do.
The one decision registering a provider actually makes: whose account somebody arriving through it lands in.An arrival is drawn once at the top, carrying the subject the provider named and an e-mail address. Three outcomes hang below it, identical in everything but the linking mode configured. Creating an account lands the arrival in a new one; linking on a verified address lands it in an existing account with that address, but only while the provider is trusted to have verified it, and without that trust is never linked, landing as an account would be created; denying lands nobody anywhere, since only an identity already linked to an account gets in. Role rules run after the account is settled, not before.
  1. The provider answers with a subject identifier and an e-mail address.
  2. The linking mode decides whose account that arrival lands in.
  3. 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.
  4. 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.

request
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" }
      }
    }
  ]
})
response200
{  "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.
The response body, with the fields you actually need marked.NextAuth.js Integration

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.

HighToken policy

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.

One finding, drawn the way the console draws it. The client, the numbers and the times are illustrative; the shape of the answer is not. A review takes up to a minute, and you can leave and come back.

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.

Dedicated environmentReady
  1. Create the project
  2. Create the database
  3. Create the cache
  4. Create the API
  5. Create the console
  6. Assign the addresses
  7. Configure the variables
  8. Deploy
  9. Wait until it answers
  10. 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
token refresh
not counted
token refresh
client credentials
token refresh
token refresh
session ends
failed attemptfailed attempt
never counted
One session, drawn from the first login to the last refresh.A successful authentication opens a session and is counted once. Everything that happens inside that session is free.
  1. successful login: counted once
  2. client credentials: counted once
  3. token refresh: not counted
  4. 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