Everything you need to know about Auth.io
Explore every screen, understand each flow, and learn how all the pieces connect — from creating your first realm to issuing tokens in production.
Welcome back!
Track activity across your realms, clients and users at a glance.
12
9 active · +3 this week
38
34 active · 29 PKCE
8.4K
across all realms
126K
$114 est. cost
Distribution by Realm
Realm Status
Recent Realms
acme-prod
12 clients · 128 users · created 2 months ago
partner-hub
7 clients · 64 users · created 3 weeks ago
mobile-apps
5 clients · 41 users · created 5 days ago
Platform architecture
How entities connect in Auth.io
Realm
Tenant boundary
Client
App registration
Users / Consumers
Identities & APIs
Roles & Scopes
Authorization
Keys & Secrets
Security layer
Every screen explained
Every entity in the platform — what it's for, how it's configured, and how it connects to the rest of Auth.io.
Realms
Multi-tenant isolation
A Realm is the top-level tenant boundary. It isolates users, clients, scopes, roles, keys, and all configurations. Everything starts with creating a realm.
Key features
Create separate realms for development, staging, and production environments to maintain complete isolation.
Welcome back!
Track activity across your realms, clients and users at a glance.
12
9 active · +3 this week
38
34 active · 29 PKCE
8.4K
across all realms
126K
$114 est. cost
Distribution by Realm
Realm Status
Recent Realms
acme-prod
12 clients · 128 users · created 2 months ago
partner-hub
7 clients · 64 users · created 3 weeks ago
mobile-apps
5 clients · 41 users · created 5 days ago
Connections
Fields
Clients
Application registration
Clients represent the applications that participate in OAuth2 and OIDC flows. Each client has its own configuration for identity, tokens, login branding, and email.
Key features
Use Authorization Code + PKCE for public apps (SPA/mobile) and Client Credentials for server-to-server integrations.
API Secrets
Scoped machine credentials with expiry and usage tracking.
Active secrets
3 secretsproduction-api
sk_live_9f2a••••••••••••ci-pipeline
sk_live_c7d1••••••••••••legacy-integration
sk_live_04be••••••••••••Client Authentication
Token Configuration
Issuer
https://auth.authio.com/realms/acme-prodAudience
api://acme-platformConnections
Fields
Users
Identity management
Users are human identities that authenticate through interactive login flows. They have credentials, roles, sessions, and follow the client's identity policies.
Key features
Users authenticate via the hosted login page. Their permissions come from the combination of assigned roles and their scopes.
User Management
Search, inspect and manage identities across every realm.
8,412
all realms
8,020
95% verified
Users
View allSofia Almeida
sofia@acme.io
Marcos Ribeiro
marcos@acme.io
Julia Castro
julia@partner.co
Daniel Souza
daniel@acme.io
Connections
Fields
Consumers
API & integration credentials
Consumers represent non-interactive (machine-to-machine) integrations. They are credentials bound to a client with their own scopes and roles for API access.
Key features
Use consumers for backend services, cron jobs, and third-party integrations that need API access without user interaction.
Connections
Fields
Roles & Scopes
Authorization model
Roles group permissions, and scopes define what actions or resources are accessible. Together they form the authorization model for users, consumers, and API calls.
Key features
Start with OIDC standard scopes, then add custom scopes as your API grows. Map scopes to roles for clean authorization.
Connections
Fields
Keys & Secrets
Cryptography & security
Keys handle signing and encryption of tokens (JWS/JWE). Secrets include client secrets, API keys, encryption keys, and other credentials needed for security operations.
Key features
Rotate keys regularly and use different algorithms (RS256, ES256) based on your security requirements.
Security Keys
Signing and encryption key material per client, with rotation.
3
in rotation
1
signing tokens now
RS256
RSA 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 02, 2026
RS256
RSA Key · SIG
5d80b6c3-19af-4e72-a0c5-84e1f2b7d9a3Created Feb 18, 2026
Connections
Fields
Security
Dashboard & monitoring
The security dashboard provides visibility into active sessions, token usage, key status, and overall security posture of the environment.
Key features
Review the security dashboard regularly to detect anomalies, expired keys, and unusual session patterns.
Audit & Access Intelligence
4,531 events recorded4,531
access events recorded
4,369
authentications passed
162
access attempts blocked
96%
Excellent
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
Connections
Fields
Settings
Account & configuration
The settings area manages your account profile, notification preferences, account security, and subscription management.
Key features
Keep your subscription active and monitor usage to avoid rate limiting or feature restrictions.
Connections
Fields
From zero to the first issued token
Follow the recommended implementation order. Click each step to see details and the corresponding API call.
Create your Realm
Define the main environment for your application. The realm establishes tenant isolation, naming, and organizational context.
Checklist
API example
{
"name": "My Application",
"realmId": "my-app",
"description": "Production environment"
}Every flow, end to end
Pick a flow to read what each step actually does and see the request that drives it. Every URL below is a real Auth.io endpoint — only the issuer is a placeholder.
Authorization Code + PKCE
Web apps, SPAs and mobile apps — anything with a person in front of it. PKCE is on by default for new clients.
Code example
// 1. Send the browser to the authorization endpoint.
const params = new URLSearchParams({
response_type: 'code',
client_id: 'web-app',
redirect_uri: 'https://app.example.com/api/auth/callback/authio',
// offline_access is what buys a refresh_token — nothing else does.
scope: 'openid profile email offline_access',
code_challenge: codeChallenge,
// Always send this. The authorization endpoint accepts a challenge
// without a method, and the exchange then fails at the token
// endpoint — a long way from the request that caused it.
code_challenge_method: 'S256',
state: randomState,
})
window.location.href =
'https://auth.example.com/realms/acme/protocol/openid-connect/auth?' + params
// 2. Exchange the code for tokens, from your server.
const tokens = await fetch(
'https://auth.example.com/realms/acme/protocol/openid-connect/token',
{
method: 'POST',
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
body: new URLSearchParams({
grant_type: 'authorization_code',
code: authorizationCode,
// Byte-for-byte the redirect_uri sent in step 1.
redirect_uri: 'https://app.example.com/api/auth/callback/authio',
client_id: 'web-app',
code_verifier: codeVerifier,
}),
},
)Ready-to-use code snippets
The Next.js examples use authio-provider-nextauth, the first-party provider package — one entry point per NextAuth major, with the Authio defaults already set. Inside the console, each client's Integration guide prints these same recipes with its own values filled in.
// npm install next-auth@5.0.0-beta.32 authio-provider-nextauth@^2
// .env.local — Auth.js resolves these three from the provider id, "authio".
// AUTH_AUTHIO_ISSUER="https://auth.example.com/realms/acme"
// AUTH_AUTHIO_ID="web-app"
// AUTH_AUTHIO_SECRET="…" omit entirely for a public client
// AUTH_URL="https://app.example.com"
// AUTH_SECRET="…" npx auth secret — NOT the client secret
// auth.ts
import NextAuth from 'next-auth'
import { Authio } from 'authio-provider-nextauth/v5'
export const { handlers, signIn, signOut, auth } = NextAuth({
providers: [
Authio({
// The v5 entry point sets no checks of its own, so Auth.js would
// default to ['pkce'] alone. 'state' ties the callback to the
// request that started it.
checks: ['pkce', 'state'],
// offline_access is what buys a refresh token. Nothing else does.
authorization: {
params: { scope: 'openid profile email offline_access' },
},
}),
],
session: { strategy: 'jwt' },
callbacks: {
async jwt({ token, account }) {
if (account) {
token.accessToken = account.access_token
token.refreshToken = account.refresh_token
}
return token
},
async session({ session, token }) {
session.accessToken = token.accessToken as string
return session
},
},
})
// app/api/auth/[...nextauth]/route.ts
import { handlers } from '@/auth'
export const { GET, POST } = handlers
// Register this exact callback on the client:
// https://app.example.com/api/auth/callback/authioBeyond setup: governing the environment
Authentication is just the beginning. These areas require ongoing attention to maintain security and compliance.
Login branding
Customize the hosted login page: title, subtitle, colors, logo, background, and behavior per client.
Identity policies
Control password rules, username validation, lockout thresholds, email verification, and sender configuration.
Token & encryption
Configure JWS/JWE algorithms, token lifetimes, audience, key rotation, and signing strategies per client.
Observability
Monitor active sessions, consumer usage, client status, secret expiration, and security posture.
Common questions answered
Start building your authentication layer today
You now understand the full platform: realms, clients, users, consumers, roles, scopes, keys, and all authentication flows. Time to bring it to life.