Skip to main content

Auth

Gate is Kilimanjaro's Identity-Aware Kernel. This page is the API-surface reference: token shapes, sign-in and sign-up flows, identity-provider configuration, MFA, sessions, transactional email, account lifecycle, and the credential primitives every other endpoint authenticates against.

1. Identity model recap​

A single User is the global identity. Org and project memberships layer on top. A User can authenticate through one or many identity providers — local email/password and federated providers coexist on the same row. Project context is established per request via the URL @<projectSlug> marker (with X-K9o-Project header as fallback); sessions are user-scoped. See Conventions §8.3 for the resolution order.

For the full identity-and-projects model see Identity-Aware Kernel. For the role taxonomy enforced on every endpoint see API → Security §1.

Host routing. Endpoints on this page fall into three host classes per the URL grammar: operator-scoped flows (/auth/sign-in, /auth/sign-up, /me/...) live on the root host api.k9o.io; org-scoped flows (org JWKS) live on the org subdomain <orgSlug>.api.k9o.io; project-scoped flows (per-project JWKS, identity providers, audit-log, session management) live on <orgSlug>.api.k9o.io/@<projectSlug>/.... The path examples below omit the host except where it disambiguates.

Two authentication planes share this page. The operator routes (/auth/*, /me/*) sign in the people who run an organisation; the Console and k9o login use them, and their access tokens live 15 minutes (900 s). The end-user Gate routes (/@<projectSlug>/gate/*) sign in the end users of a project; the SDK gate.* calls use them, with a 1-hour access token and a 30-day refresh token. Each section below says which plane it describes, and every SDK example on this page is the end-user Gate plane.

2. Token shape​

2.1 Two token kinds​

Two distinct token kinds are issued by the platform:

  • Bearer JWTs for SDK and API access. Stateless, signed with per-project keys, verifiable from the project's JWKS endpoint without a round-trip to the gateway. Used by every SDK, the CLI, and direct API consumers.
  • Opaque session IDs for Console cookies. Server-validated for revocation power. Used by console.k9o.io only; not exposed to SDK consumers.

The two kinds are not interchangeable. A JWT cannot establish a Console session; an opaque session ID cannot authenticate an SDK call. Consumers bridging the two (a Console-launched CLI invocation) exchange their opaque session for a short-lived JWT via gate.exchangeSessionForJwt.

2.2 Bearer JWT (access token)​

Header { alg: "EdDSA" | "RS256", kid: "<key-id>", typ: "JWT" }
Payload {
iss: "<this deployment's API origin>",
aud: "k9o.api" | "proj_<id>", // operator tokens: k9o.api; end-user Gate tokens: the project id
sub: "usr_<id>" | "tok_<id>" | "eu_<id>" | "swi_<id>" | "cwi_<id>",
iat: <unix-seconds>,
exp: <unix-seconds>,
jti: "<uuid>",
scope: ["read", "write", ...],
org_id: "org_<id>", // operator, service and workload tokens only
proj_id: "proj_<id>" | null, // operator, service and workload tokens only
roles: ["PROJECT_ADMIN", ...],
groups: ["finance-team", ...],
mfa: "verified" | "required" | "not_required"
}
Signature // signed with the project's signing key
PropertyValue
org_id, proj_id claimsPresent on operator, service and workload tokens only. End-user (eu_) tokens carry neither; their aud is the project id
Default algorithmEdDSA (Ed25519); RS256 supported as a per-project alternative
Access TTL30 minutes by default for end-user Gate tokens (a per-project setting, 5 to 60 minutes); 15 minutes (900 s) for operator tokens
mfa claimReflects the session's MFA verification state — verified, required, or not_required
Revocation propagationBounded by access TTL; the underlying refresh-token chain is invalidated immediately on revoke

Customers requiring sub-second revocation use opaque sessions for affected workloads.

2.3 Refresh tokens​

Refresh tokens are opaque and server-validated. They are issued alongside every access JWT at sign-in. An end-user session ends after 30 days without activity by default, and after 90 days in total; both limits are per-project settings (Session lifetime and sign-out).

The example in §3.1 is the end-user Gate plane (POST /@<projectSlug>/gate/refresh). gate.refreshToken({ refreshToken }) returns { accessToken, refreshToken, expiresAt }. The refresh token is rotated: the one you sent stops working, so store the new one, and sending an old one again ends the session. A refresh the session no longer allows is refused with K9O_SESSION_EXPIRED. The operator route POST /auth/refresh differs: it rotates the refresh token on every call, and each token is single-use.

2.4 Opaque session IDs (Console)​

The Console authenticates via Set-Cookie: K9O_SESSION=<ses_id>; HttpOnly; Secure; SameSite=Lax. The session ID is server-validated on every request; revocation is immediate.

PropertyValue
Session ID formatses_<24-char-base62>
Storagek9o_<proj_id>_sys.sessions keyed on (session_id_hash)
Bridge to JWTgate.exchangeSessionForJwt — returns a short-lived (default 5min) JWT for a single operation

Session lifecycle is bound in §9.

2.5 JWKS endpoint​

GET /@<projectSlug>/auth/jwks

Returns the public keys for the project's JWT signing key set, in the JWKS shape of RFC 7517 wrapped in the standard response envelope: { "data": { "keys": [...] }, "meta": { ... } }. A stock JWKS client expects a bare { "keys": [...] } and cannot read the response as is: use verifyJwt from @k9o/gate, which unwraps it, or take data yourself before handing the keys to your JWT library. For end-user Gate tokens, aud is the project id and iss is the deployment's issuer; read both from configuration, never hardcode them. Keys roll over every 90 days; rotated-out keys remain in the JWKS set for 30 days post-rollover so that JWTs minted just before rollover continue verifying.

Org-scoped tokens use the org's signing keys (separate JWKS at /auth/jwks on <orgSlug>.api.k9o.io — org subdomain; no @<projectSlug> marker).

TypeScript
// The SDK helper unwraps the JWKS response envelope for you.
import { verifyJwt } from '@k9o/gate';
const result = await verifyJwt({
  token:            accessToken,
  jwksUrl:          `${apiUrl}/@${projectSlug}/auth/jwks`,
  allowedAlgorithms: ['EdDSA', 'RS256', 'ES256'],
  expectedIssuer:   issuer,     // the iss claim your tokens carry (regional)
  expectedAudience: projectId,  // end-user tokens: aud is the project id
});
if (result.valid) { /* result.claims.sub */ } else { /* result.reason */ }

Showing example in TypeScript

3. Sign-in surface​

3.1 Sign-in entry endpoint​

POST /auth/sign-in

This is the operator plane. Body (the method field discriminates):

{ "method": "EMAIL_PASSWORD", "email": "...", "password": "...", "projectHint": "..." }
{ "method": "AD_BIND", "email": "...", "password": "...", "username": "...", "providerId": "oic_..." }

projectHint is optional. When present, the gateway validates project membership and includes the project context in the issued JWT's proj_id claim. When absent, the JWT carries proj_id: null; project context is established per request via X-K9o-Project.

Response on success:

{
"data": {
"accessToken": "<jwt> | null",
"refreshToken": "<opaque> | null",
"accessTokenExp": <unix-seconds> | null,
"refreshTokenExp": <unix-seconds> | null,
"user": { "id": "usr_...", "email": "...", "displayName": "..." },
"org": { "id": "org_...", "slug": "...", "displayName": "..." },
"project": { ... },
"activeProjectId": "proj_..." | null,
"mfa": { "required": false, "methodsAvailable": [] },
"exchangeTicket": "<jws> | null",
"redirectUrl": "https://<consoleDomain>[/auth/exchange?ticket=<jws>] | null"
},
"meta": { }
}

Sign-in follows a two-tier session model. It always mints a root session at console.k9o.io and returns a redirectUrl pointing at the Console host the operator should land on next. The token fields are nullable because they depend on the branch: when the selected org uses the default Console host, the tenant tokens are returned inline; when it uses a custom domain, the tokens are withheld and a single-use exchangeTicket (a short-TTL JWS) is handed over instead, which the tenant Console redeems for its own session — so a tenant token never rides a cross-domain redirect.

When MFA is required, the response carries mfa.required: true and the access token's mfa: "required" claim. Subsequent calls fail with MFA_REQUIRED (401) until the user completes the MFA challenge via §6.4.

The SDK example below covers sign-up, sign-in, reading the signed-in user, refreshing the token and handling an error. It is the end-user Gate plane, not the operator endpoint above. It calls POST /@<projectSlug>/gate/signin, whose body is closed to { email, password } (any other field is refused with K9O_INVALID_FIELD_VALUE, reason unknown_field) and which answers { user, session }, where session carries accessToken (30 minutes by default), refreshToken and expiresAt. The refresh token rotates on every refresh; see §2.3.

Create the client once

client
import { createClient, realtimeTopic } from "@k9o/core";

const k9o = createClient({
  orgSlug: "acme",
  projectSlug: "task-app",
  apiKey: process.env.K9O_API_KEY,
});

Gate · A1: sign up, sign in, read the signed-in user

@k9o/gate is the Gate package; @k9o/core composes the same client as k9o.gate. Sign-up and sign-in need no end-user token. Use the org address as the base URL: the SDK follows the redirect to the project's region. whoami answers for whoever owns the token the client holds. A client built with an API key (including k9o.gate inside @k9o/core) therefore reports the key's identity, so to read the end user, build a second Gate client whose token is the user's access token (partnerToken).

Setup

Setup
import { createGateClient } from "@k9o/gate";

const baseUrl = "https://acme.api.k9o.io";
const projectSlug = "task-app";

// No API key is needed to sign an end user up or in.
const gate = createGateClient({ mode: "native", baseUrl, projectSlug });
1. Sign up
// Create the end user. The answer carries the new user and a first session.
const { data: signedUp } = await gate.signUp({
  email: "[email protected]",
  password: "a-long-passphrase",
  displayName: "Alice",
});

console.log(signedUp.user.id, signedUp.user.email, signedUp.user.status);
console.log(`first session expires ${signedUp.session.expiresAt}`);
Output · bash
eu_4f9a2c [email protected] active
first session expires 2026-11-02T10:15:00.000Z
  • Sign-up answers 409 when the email is already registered, and 400 when the password or a field is refused; a body field other than the email, the password and the optional display name is refused.

3.2 Sign-in methods​

MethodFlow
EMAIL_PASSWORDValidates against the user's Argon2id password hash per §10. Returns INVALID_CREDENTIALS (401) on mismatch; repeated failures lock the account's password sign-in per §3.3.
AD_BINDNative Active Directory / LDAP bind. The platform binds to the configured server as the user with the submitted password as the bind credential; group memberships are read at the same time and surfaced into the JWT's roles claim per Security §1.6. providerId is the identity provider's oic_... id.

Federated sign-in (OIDC, SAML, OAuth2) does not go through this body: those flows complete at the provider callbacks, /auth/idp/<provider>/callback and /auth/saml/callback.

The v1 invisible-form-dance callback rendering an HTML page that auto-submits to /j_security_check is not preserved. Direct token issuance happens at the callback endpoint.

3.3 Wrong-password limit​

Too many wrong passwords for one account lock that account's password sign-in for a while. This applies to POST /auth/sign-in with EMAIL_PASSWORD and to the end-user sign-in at POST /@<projectSlug>/gate/signin.

  • Answer. 429 K9O_RATE_LIMITED with a Retry-After header. context.reason is account_budget for the account lock (it is platform_signin when one address sent too many attempts in a minute). recommendation.retryAfterSec repeats the wait.
  • The lock steps up. 15 minutes, then 1 hour, then 4 hours within a day.
  • Same answer whether the account exists or not, so the lock does not reveal which addresses have accounts.
  • One budget per account. The Gate host and the API door share it for end users; the Console and the admin host share it for operators.
  • A right password does not clear earlier failures, and during the lock it gets the same 429.
  • Other sign-in methods still work while the password is locked, where they are set up.
    • End users: magic link, single sign-on, social sign-in, passkey, one-time code and password reset.
    • Operators: magic link (where the membership allows it), organization single sign-on, social sign-in and Active Directory bind. On the admin host, Microsoft sign-in.

See also Gate → Wrong-password limit.

4. Sign-up surface​

POST /auth/sign-up

This is the operator plane. Body shape varies by signup path:

{ "path": "EMAIL_PASSWORD", "email": "...", "password": "...", "displayName": "...", "signupContext": { "displayName": "...", "initialProduct": "kibo" } }
{ "path": "MAGIC_LINK", "email": "...", "displayName": "...", "signupContext": { "displayName": "...", "initialProduct": "kibo" }, "returnTo": "..." }

signupContext carries the org-creation parameters per the identity-and-projects model: displayName (required) and initialProduct (core, kibo, pulse, keep or gate). password is at least 12 characters. Sign-up through an identity provider uses the /signup/idp/* callbacks, not this body.

MAGIC_LINK (passwordless). A passwordless account is created with no stored password. The emailed single-use link serves as both email verification and first sign-in — clicking it completes account setup and mints the session. Because the emailed link is the only way into a passwordless account, the project's transactional-email configuration (transactionalEmailProvider) must be set (§8). If it isn't configured, the call fails with K9O_EMAIL_DELIVERY_NOT_CONFIGURED (503).

Subsequent sign-ins use a fresh emailed link, not EMAIL_PASSWORD, since there is no password to validate.

When email verification is required, the sign-up response carries session: null until the email is verified (§7.1); when no mailer is configured, the session is returned immediately. Passwordless accounts complete verification via the magic-link click.

The end-user Gate plane sign-up (POST /@<projectSlug>/gate/signup, shown in the example in §3.1) has a body closed to { email, password, displayName? } (path and signupContext are refused as unknown fields). It answers 201 with { user, session }, so a successful sign-up also signs the user in; user.status is active, pending or disabled.

5. Identity providers​

5.1 The IdentityProvider resource​

IdentityProvider {
id: "epc_<base62>"
projectId: "proj_<id>"
idpProvider: "google" | "github" | "microsoft" | "apple" | "facebook" | "twitter"
| "oidc" | "saml" | "scim" | "ldap" | "active_directory"
displayName: string
clientId: string
clientSecretSet: boolean // the secret itself is write-only and never returned
redirectUri: string // platform-derived callback URL
metadataUrl: string | null
attributeMap: object // string -> string, §5.6
enabled: boolean
allowedRedirectUris: string[]
createdAt: string
updatedAt: string | null
}

The provider response also carries the directory settings as directory* fields (used by the ldap and active_directory providers, §5.3).

Multiple identity providers may be configured per project. A User may authenticate through multiple providers; the primary provider is recorded on User.identityProviderId, secondary providers attach via IdentityProviderLink.

5.2 Endpoints​

EndpointVerbDescription
/@<projectSlug>/identity-providersPOSTCreate a provider. PROJECT_ADMIN minimum.
/@<projectSlug>/identity-providersGETList providers. Standard cursor pagination.
/@<projectSlug>/identity-providers/<idp-id>GETRead a single provider. The client secret is never returned; reads carry clientSecretSet instead.
/@<projectSlug>/identity-providers/<idp-id>PATCHUpdate mutable fields.
/@<projectSlug>/identity-providers/<idp-id>DELETEDelete. Federated users tied to the deleted provider remain in the User table but cannot sign in via it.
/@<projectSlug>/identity-providers/<idp-id>/testPOSTProbe a stored provider; no persistence, no side effects.
/@<projectSlug>/identity-providers/bind-testPOSTTest LDAP / AD bind credentials before saving a provider.
TypeScript
const { data: idp } = await k9o.gate.identityProviders.create({
  idpProvider:     'oidc',
  displayName:     'Corporate SSO',
  clientId:        'k9o-app-1',
  clientSecretRef: process.env.OIDC_CLIENT_SECRET!, // the client secret; write-only, never returned
  metadataUrl:     'https://login.example.com/.well-known/openid-configuration',
  enabled:         true,
});

Showing example in TypeScript

5.2.1 Test-connection probes​

POST /@<projectSlug>/identity-providers/<idp-id>/test probes a provider that is already saved. It checks reachability and metadata validity of the endpoint derived from the stored configuration; the client secret is never decrypted or sent. The result carries ok and, on failure, a reason.

POST /@<projectSlug>/identity-providers/bind-test checks LDAP / AD credentials before any provider exists. Everything in the body is request-supplied; nothing is stored, and the password is never persisted, logged or echoed.

5.3 LDAP / AD configuration​

For ldap and active_directory providers the generic fields carry the directory settings: metadataUrl is the server URL (ldap:// or ldaps://), clientId is the bind DN template containing a {username} placeholder, and attributeMap maps directory attributes to platform claims. The bind test takes the same pieces:

POST /@<projectSlug>/identity-providers/bind-test
{
"serverUrl": "ldaps://ad.example.com:636",
"bindDnTemplate": "uid={username},ou=people,dc=example,dc=com",
"username": "alice",
"password": "<write-only>",
"confirmInternal": false // optional; confirms a private-network target
}

For Active Directory a UPN-form template such as {username}@example.com works as well.

5.4 OIDC configuration​

POST /@<projectSlug>/identity-providers
{
"idpProvider": "oidc",
"displayName": "Corporate SSO",
"clientId": "k9o-app-1",
"clientSecretRef": "<the client secret; write-only>",
"metadataUrl": "https://login.example.com/.well-known/openid-configuration",
"enabled": true
}

The provider's endpoints come from the discovery document at metadataUrl. clientSecretRef carries the client secret on create and update and is never returned; reads report clientSecretSet: true. redirectUri is derived by the platform: omit it, or send exactly the derived callback.

5.5 SAML and social providers​

idpProvider: "saml" takes the IdP's metadata URL as metadataUrl. The social providers (google, github, microsoft, apple, facebook, twitter) need only clientId and clientSecretRef. Every provider type is available to every project.

5.6 Attribute mapping​

attributeMap is a flat string-to-string object that maps platform claim names to provider-side attribute names. For a directory it looks like this:

attributeMap: {
"email": "mail",
"name": "cn"
}

Group-to-role mapping is bound in Security.

6. MFA​

6.1 Methods at v2​

MethodDetail
TOTP (RFC 6238)SHA-1 / SHA-256 / SHA-512; default SHA-256; 30-second interval; 6 digits. Compatible with standard TOTP authenticators.
WebAuthn (FIDO2)Platform authenticators (Touch ID / Windows Hello / Android biometric) and cross-platform (security keys). Resident keys preferred.

SMS is not at v2 — NIST SP 800-63B deprecates SMS as a restricted authenticator and SIM-swap risk is material.

6.2 Recovery codes​

Mandatory at MFA enrollment. The platform issues 10 single-use recovery codes; the user must record them before enrollment completes. Codes rotate via POST /me/mfa/recovery-codes/regenerate (voids the prior set). Presenting a recovery code to the challenge route (method: "recovery_code", §6.4) substitutes for a TOTP / WebAuthn challenge.

6.3 Enrollment endpoints​

POST /me/mfa/totp/enroll → provisioning QR + secret
POST /me/mfa/totp/confirm → confirm with first code; activates
POST /me/mfa/webauthn/begin → WebAuthn challenge
POST /me/mfa/webauthn/finish → verify attestation; activates
GET /me/mfa/methods → list active methods
POST /me/mfa/methods/<m>/disable → re-auth required
POST /me/mfa/recovery-codes/regenerate

6.4 Challenge flow​

This is the operator step-up: it clears the mfa: "required" state of an operator session. There is no end-user MFA challenge route on Gate; end users can enrol and confirm a TOTP factor (/@<projectSlug>/gate/mfa/totp/enroll and .../confirm).

POST /auth/mfa/challenge { "method": "totp" | "recovery_code", "code": "..." }
POST /auth/mfa/challenge { "method": "webauthn", "phase": "begin" }
POST /auth/mfa/challenge { "method": "webauthn", "phase": "finish", "response": { ... } }
→ 200 { "data": { "accessToken": "...", "accessTokenExp": ..., "mfa": { "verified": true } } }

method is lowercase. code is the 6-digit TOTP code or the XXXXX-XXXXX recovery code. The call answers K9O_STATE_CONFLICT (409) when the session has no challenge pending. The re-issued token is the new authoritative token for the session; the prior mfa: "required" token is invalidated immediately.

6.5 MFA-required actions​

MFA-gated actions are surfaced through the IRREVERSIBLE_ACTION_GATE family bound in Control. MFA-required actions:

  • Org / project deletion
  • Custody-mode downgrade
  • Project KEK zeroize
  • Member-role escalation to ORG_ADMIN / ORG_OWNER / PROJECT_ADMIN
  • Identity-provider creation or mutation with clientSecretRef changes

The list is binding at v2; Policy's features-catalogue surface extends it via configuration without spec amendment.

7. Account lifecycle​

7.1 Email verification​

Triple-trigger per the Q4 pattern (§8): gate.sendVerificationEmail({userId}), gate.generateVerificationLink({userId}), auth.user.verification_requested webhook. The emailed link redeems through the redirect flow, and a new link can be requested:

GET /auth/verify-email?token=<token>
POST /auth/verify-email/resend { email }

Token TTL: 24 hours; single-use. User transitions to verified; project-scoped operations unblock.

7.2 Password reset​

Triple-trigger: gate.sendPasswordResetEmail({email}), gate.generatePasswordResetLink({email}), auth.user.password_reset_requested webhook. Reset requests and redeems via:

POST /auth/password-reset/request { email }
POST /auth/password-reset/redeem { token, newPassword }

newPassword is at least 12 characters, and redeeming does not sign the user in. Token TTL: 1 hour; single-use. All of that user's existing sessions end on reset; the session the reset opens stays.

7.3 Email change​

Two-step verified change:

POST /me/email/initiate-change { newEmail } → confirmation sent to newEmail
POST /me/email/confirm-change { token } → email updated

The current email also receives a notification of the in-flight change via the platform's secure-notifications channel (independent of transactionalEmailProvider setting).

7.4 Account deletion​

POST /me/delete

The call takes no body and answers with the user plus a closure status. The user enters pending_deletion; a 30-day grace window starts. During grace, every action surfaces a deletion-in-progress warning in meta.warnings; the user can cancel via POST /me/delete/cancel. After grace, the User row hard-deletes; org / project memberships are revoked; audit-ledger retention obligations preserve the audit trail in pseudonymised form.

The user must not be the sole ORG_OWNER of any organisation. If they are, deletion returns STATE_CONFLICT (409) with a recommendation (text when present) pointing at the ownership-transfer flow.

7.5 Invitations​

Invitations create a pending membership row and emit an invitation token via the triple-trigger pattern (gate.sendInvitationEmail, gate.generateInvitationLink, auth.user.invitation_sent webhook). Redeem:

POST /invitations/redeem { token, password?, displayName? }

password is required only when the invited email has no existing platform account. Token TTL: 7 days; single-use.

8. Transactional email — the triple-trigger pattern​

Every transactional-email event ships three first-class triggering paths:

  • gate.send<Event>Email({...}) — uses platform-provided email infrastructure when the project's transactionalEmailProvider is 'platform'. Returns INVALID_PROVIDER_CONFIG (400) when set to 'byo'.
  • gate.generate<Event>Link({...}) — returns the link / token for the developer's own email infrastructure. Always available regardless of transactionalEmailProvider.
  • auth.<event> webhook — fires for event-driven flows. Always emitted.
EventSDK sendSDK generateWebhook
Email verificationgate.sendVerificationEmailgate.generateVerificationLinkauth.user.verification_requested
Password resetgate.sendPasswordResetEmailgate.generatePasswordResetLinkauth.user.password_reset_requested
Magic-link sign-ingate.sendMagicLinkEmailgate.generateMagicLinkLinkauth.magic_link.requested
MFA enrollment confirmationgate.sendMfaEnrollmentEmailgate.generateMfaEnrollmentLinkauth.user.mfa_enrolled
Invitationgate.sendInvitationEmailgate.generateInvitationLinkauth.user.invitation_sent
Email-change confirmationgate.sendEmailChangeEmailgate.generateEmailChangeLinkauth.user.email_change_requested

Platform-provided email is opt-in. The default is 'byo'; the developer chooses to delegate email delivery to the platform explicitly. The project-level provider setting is not yet exposed through the API. The generate<Event>Link form is always available.

9. Sessions​

9.1 Lifecycle​

A session is created at sign-in and lives until:

  • The user explicitly signs out
  • The session reaches its absolute timeout
  • The session reaches its idle timeout without activity
  • The session is revoked
  • The user's password is reset, MFA is reset, or the user is deleted

9.2 Session policy​

SessionPolicy {
idleTimeoutMins: number // default 30; min 1; max 1440
absoluteTimeoutMins: number // default 480 (8h); min 1; max 10080 (7d)
maxConcurrentSessions: number // integer, min 1; max 1000
}

9.3 Revocation​

EndpointScope
POST /auth/sessions/<session-id>/revokeA single session
POST /me/sessions/revoke-allAll sessions of the current user
POST /@<projectSlug>/auth/sessions/revoke-allAll sessions in a project (PROJECT_ADMIN)
POST /@<projectSlug>/auth/users/<user-id>/sessions/revoke-allOne user's sessions in a project (PROJECT_ADMIN)

Revocation is immediate for opaque sessions (server-side row update; subsequent Console requests fail with INVALID_SESSION 401) and bounded for JWT access tokens by their TTL (the underlying refresh-token chain is invalidated; the next refresh fails; the access JWT continues to verify until expiry).

The SDK example below is the end-user Gate plane: POST /@<projectSlug>/gate/signout takes the session's refresh token and answers { revoked }. It revokes that session's refresh token; an access JWT already issued stays valid until it expires. rt in the examples is the refresh token returned at sign-in.

TypeScript
const { data } = await k9o.gate.signOut({ refreshToken: session.refreshToken });
// data.revoked — false when the token was unknown or already revoked

Showing example in TypeScript

10. Password policy​

PropertyValue
HashArgon2id only (no bcrypt fallback at v2)
Argon2id parametersmemory cost 64 MiB, time cost 3, parallelism 4
Minimum length12 characters
Composition rulesNone (NIST SP 800-63B-4 deprecates mandatory composition)
Brute-force protectionTemporary lockout per account after too many wrong passwords: 15 minutes, then 1 hour, then 4 hours within a day (§3.3)
Compromised-password checkAt sign-up and password-change; haveibeenpwned k-anonymity API; rejected with COMPROMISED_PASSWORD (400)
Mandatory rotationNot enforced (NIST SP 800-63B-4 deprecates absent compromise evidence)

Customers needing local-password migration from external systems use federated identity (LDAP / OAUTH2) — there is no plaintext-password import path.

11. Migration​

Migrating from a third-party identity provider? See Gate → Migration Guide for the migration paths, the API-shape mapping, and per-vendor sub-pages.

12. See also​