Skip to content

For developers

One integration.
Every identity.

Authentication APIs, hosted flows and SDKs that let your team ship secure identity experiences without rebuilding the identity stack. One set of interfaces authenticates a customer, an employee, an application, a workload, a device and an agent — the same tenant, the same keys, the same event stream, the same verification step in your API. The developer experience is treated as part of the product here rather than as a link at the end of a marketing page, so this page sets out the map, the quickstart set, the shape of the API and the bar we hold all three to.

Documentation map

Eleven areas, and what each one owes you.

Identity documentation fails in a predictable way: the happy path is written beautifully and everything after it — rotation, recovery, revocation, the attribute that does not map — is left to support tickets. The map below exists so that each area can be held to the hard part. Each line is what that area must cover.

01

Getting started

Tenant, environments, first application, first authenticated principal — and how to verify the resulting token before trusting it.

02

Login and sessions

Authorization code with PKCE, hosted screens and embedded components, session records you can list and end, sign-out across applications, refresh and revocation.

03

Passkeys and MFA

WebAuthn enrolment and sign-in, factor lifecycle, step-up challenges, and recovery documented as a first-class journey rather than a footnote under passwords.

04

Organizations

Organization-scoped identity, invitations and membership, domain verification and discovery, and exactly which membership claims an application receives.

05

APIs and machines

Client credentials, signed client assertions, mTLS-compatible approaches, workload identities, short-lived credential exchange, key registration and rotation.

06

SCIM and federation

Inbound OpenID Connect and SAML connections, organization-aware provider discovery, claims mapping, SCIM provisioning — and what to do when an attribute has no faithful equivalent on the other side.

07

Proofing

Verification sessions, evidence capture and handling, outcomes and confidence records, reverification, and the retention decision that comes with each of them.

08

Verifiable credentials

Issuer identities and schemas, issuance, presentation verification, status and expiry checks, selective disclosure where the profile supports it, and wallet interoperability paths.

09

Agents

Agent identifiers and keys, operator binding, proof of possession, signed delegation evidence, and revocation that another platform can check independently.

10

Eventing

The event catalogue, webhook subscriptions, signature verification, delivery and retry behaviour, replay, and export for a review or an investigation.

11

Operations

Promoting configuration between environments, key rollover, credential expiry monitoring, diagnosing a login route that worked yesterday, and where service and incident communication arrives.

The Agents area stops where the platform stops: an agent gets an identifier, keys, an operator relationship and verifiable delegation evidence. Designing an agent, giving it tools and running it belong to an agent platform rather than here. The same boundary runs through every area above — the architecture page draws all three edges explicitly, and developer APIs, SDKs and webhooks is the catalogue entry these interfaces belong to.

Quickstarts

Each one ends in something you can check.

A quickstart that finishes with a screenshot has proved nothing and hidden every mistake you made on the way. Each of these is defined by its verifiable result instead — including, where it matters, the negative case: the forged token that must be rejected, the leaver that must propagate, the revocation that must show up in a status check.

Hosted login in a web application
Ends with: A signed-in session and an ID token you have validated against the published keys.
Add passkeys to an existing login
Ends with: A registered authenticator, a passwordless sign-in, and a recovery path you have actually walked.
Verify a token in your own API
Ends with: A request accepted on its signature, issuer, audience and expiry — and a deliberately forged one rejected.
Machine-to-machine access
Ends with: A workload credential, a short-lived token, and the same call failing from the wrong environment.
Connect a customer's identity provider
Ends with: An organization-aware sign-in that routes to the right enterprise connection, with the claims mapped.
Provision from a directory
Ends with: A SCIM synchronization that creates a user, updates an attribute and propagates a leaver.
Issue and verify a credential
Ends with: A signed credential, an independent verification of it, and a status check that reflects a revocation.
Give an agent an identity
Ends with: An agent proving possession of its key, plus a scoped delegation a verifier checks before acting on it.
Receive identity events
Ends with: A webhook whose signature you verified, a duplicate delivery your handler absorbed, and a replay you requested.

On languages

Each quickstart is written against the SDK patterns the platform publishes — JavaScript, TypeScript, Python and more — and against the plain HTTP calls underneath them. Both, always: an SDK makes the common path short, and the raw calls mean a language without an SDK is never a dead end. Where a flow is a standard protocol exchange, the standard is named so you can read the specification rather than our paraphrase of it.

Illustrative API design

The resource naming, published before the API.

Resource names are the part of an API that is hardest to change later and easiest to agree on early, so we are putting ours up for argument first. What follows is naming guidance. It is not a deployed contract, it is not serving, and it carries no availability promise.

Read this first

Naming guidance, not a deployed contract.

  • No endpoint below is live. The listing describes intended resource naming, nothing more.
  • No request or response shapes are shown, because inventing a payload would be inventing the product.
  • There are no rate limits, SDK versions, performance figures or dates on this page, in any form.
  • Methods, names and groupings may change before anything is published as a version.
# ─────────────────────────────────────────────────────────────────────
# ILLUSTRATIVE RESOURCE DESIGN — NAMING GUIDANCE, NOT A DEPLOYED CONTRACT.
# Nothing below is serving. There is no published version, no payload
# shape and no availability date implied by this listing. It shows the
# resource naming and grouping the platform is being built to keep
# consistent; names, methods and groupings may still change.
# Paths are shown without a host: that comes from discovery metadata.
# ─────────────────────────────────────────────────────────────────────

# ── Discovery ────────────────────────────────────────────────────────
GET    /.well-known/openid-configuration
GET    /.well-known/jwks.json

# ── Protocol endpoints (OpenID Connect / OAuth 2.0) ──────────────────
# "authorize" here is the OAuth authorization-server endpoint: it issues
# grants for delegated access. It does not decide what a principal may
# do inside your application.
GET    /oauth2/authorize
POST   /oauth2/token
POST   /oauth2/introspect
POST   /oauth2/revoke
GET    /oidc/userinfo

# ── Principals ───────────────────────────────────────────────────────
GET    /v1/users
POST   /v1/users
GET    /v1/users/{user_id}
PATCH  /v1/users/{user_id}
GET    /v1/organizations
POST   /v1/organizations
GET    /v1/organizations/{organization_id}/members
POST   /v1/organizations/{organization_id}/invitations
GET    /v1/applications
POST   /v1/applications
GET    /v1/workloads                    # services, jobs, containers
GET    /v1/devices
GET    /v1/agents

# ── Credentials a principal holds ────────────────────────────────────
GET    /v1/users/{user_id}/factors
POST   /v1/users/{user_id}/passkeys/registration
GET    /v1/applications/{application_id}/keys
POST   /v1/applications/{application_id}/keys
POST   /v1/workloads/{workload_id}/keys
POST   /v1/agents/{agent_id}/keys
POST   /v1/devices/{device_id}/certificates

# ── Sessions ─────────────────────────────────────────────────────────
GET    /v1/users/{user_id}/sessions
DELETE /v1/sessions/{session_id}

# ── Federation and provisioning ──────────────────────────────────────
GET    /v1/connections                  # inbound OIDC / SAML 2.0
GET    /v1/connections/{connection_id}/metadata
GET    /scim/v2/Users                   # shape fixed by SCIM 2.0, not by us
POST   /scim/v2/Users
GET    /scim/v2/Groups

# ── Verified evidence ────────────────────────────────────────────────
POST   /v1/verification-sessions
GET    /v1/verification-sessions/{verification_session_id}
POST   /v1/business-verifications

# ── Credentials issued to others ─────────────────────────────────────
POST   /v1/credentials                  # issue a verifiable credential
POST   /v1/credentials/verify
GET    /v1/credentials/{credential_id}/status
POST   /v1/delegations
POST   /v1/delegations/verify

# ── Events ───────────────────────────────────────────────────────────
GET    /v1/events
GET    /v1/webhooks
POST   /v1/webhooks

# ── Absent on purpose ────────────────────────────────────────────────
#   POST /v1/authorize-action    "may this principal do X?"
# No endpoint above answers that question, and none will. The decision
# belongs to the consuming application or to a separate authorization
# layer that holds your policy.

Why it is grouped this way

Principals first, then the credentials each principal holds, then sessions, then the connections out to identity you do not own, then the evidence and the events. That is the same order as the architecture, which means a developer reading the API and an architect reading the platform are looking at one model rather than two. A user, a workload and an agent sit in the same group on purpose: they differ in the evidence that establishes them, not in how they are stored or how they prove themselves later.

The endpoint that will never exist

Nothing in this design answers may this principal perform this action? Every resource above establishes who or what is making a request and hands your system a verified principal with the claims you asked for. The allow-or-deny decision stays with the consuming application or with a separate authorization layer that holds your policy.

That is a design boundary, not a gap in the roadmap. An API that offered both would be vaguer about each.

Developer quality

Two checklists, both of them specific.

The left column is what we hold the interfaces and the documentation to; you can hold us to it too. The right column is what a sound identity integration checks, whoever built it. Most identity incidents are a missing line from the right column, and most frustration is a missing line from the left.

What we hold ourselves to

  • Every endpoint documented with its error cases, not only its success path
  • Snippets complete enough to run, with no hidden setup step between the lines
  • Development environments that behave like production, including the failures
  • Explicit API versioning, and idempotency on anything that creates a record
  • A replacement available before anything is deprecated, and the deprecation announced rather than discovered
  • Errors that name the field and the fix, structured for a log as well as for a human
  • No secret in a URL, a query string or an example — in the documentation or anywhere else

What your integration should check

  • Validate signature, issuer, audience and expiry on every token — decoding one is not verifying it
  • Take keys from the discovery document and cache them, so a key rotation is not an outage
  • Treat the session record as the source of truth, not a cookie you set once and trust forever
  • Verify webhook signatures before acting, and make handlers idempotent: a retry is normal traffic
  • Separate development, staging and production credentials from the first commit, not after the first incident
  • Design recovery and rotation on day one; both are considerably harder to retrofit
  • Keep the authorization decision in your application or in a dedicated authorization layer, and keep it out of the token-verification path

How the platform itself is built and operated — and what we will and will not claim about it — is set out in the trust centre. If you find something on this page that we have not met, tell us; a quality bar nobody can report against is decoration.

Standards

Build on specifications, not on our vocabulary.

Every flow in the platform is an implementation of something written down and published elsewhere. Each name below links to the specification itself, so you can read the source rather than our paraphrase — and so you can check our behaviour against it.

OpenID Connect
Interactive authentication and federated login.
OAuth 2.0
Authorization-server protocol functions and token lifecycle, following current security best practice.
WebAuthn / FIDO2
Passkeys and phishing-resistant authenticators.
SAML 2.0
Enterprise identity federation.
SCIM 2.0
User and group provisioning.
JWT / JOSE / JWK
Signed tokens and key discovery.
mTLS and client assertions
Strong confidential-client and machine authentication.
W3C Verifiable Credentials
Portable digitally signed claims.
DID Core
Decentralized identifiers and verification methods.
OpenID4VCI / OpenID4VP
Credential issuance and presentation interoperability.
FAPI 2.0
Higher-security profiles for financial-grade deployments.
NIST SP 800-63-4
Reference model for identity assurance and proofing vocabulary.

An honest note on alignment

Alignment is not certification. Everything above describes a specification the platform is designed around. None of it is an accreditation, a conformance result or a formal profile certification, and building on a specification does not make us certified against it — those come from independent assessment, and where we have none we say so rather than borrowing the vocabulary.

The practical consequence is better for you anyway: because the protocols are published, you can verify our behaviour yourself. Read the discovery document, check the signatures against the published keys, and test the flow against the specification rather than against a claim on a marketing page.

Argue with the design before you depend on it.

Tell us what you are building and which identities it has to authenticate. We will walk the integration through — flows, token verification, tenancy, key rotation and the parts that belong in your application instead of ours.

Usage and packaging are structured the same way the catalogue is — see how pricing is put together, and the figures themselves are set with our team against the services you need. The product catalogue lists every service these interfaces reach.