Skip to main content
This guide explains how a production Didit Authentication integration fits together, from the first redirect to the go-live checklist. Start with the quickstart if you have not signed a person in yet, and use the platform quickstarts for the code of each SDK.

Architecture

Four parts are involved: No Didit API key and no secret ever belongs in your app: the publishable key is public, and the code exchange is protected by PKCE instead of a client secret.

Hosted pages or your own screens

Choose where people type their email, password or code. The setting is sign_in_ui (hosted by default, or own), and you can change it later. Passkeys belong to your application’s sign-in origin. The SDKs’ passkey methods work only on pages served from that origin, so on your own screens on another domain, send people to the hosted page for passkeys.

Choose your SDK

Without an SDK, implement the authorization code flow with PKCE yourself: the JavaScript quickstart shows the whole contract.

Protect your backend

A frontend session check only controls what you show. Your backend makes every decision from a verified token.
  1. Verify the access token on every request. Check the ES256 signature against your issuer’s JWKS, then iss, aud, exp and typ: at+jwt, and reject a token whose act is not null unless the route accepts AI agents. See verify a token on your server.
  2. Check the live session before a sensitive action. An access token stays valid until it expires, within 5 minutes. GET /session/ fails at once when the session was revoked, went idle or expired, when the person was blocked, or when the session no longer meets your MFA policy. See check the session.
  3. Ask for a step-up when the action is risky. Before a payout, a new bank account or an email or phone change, ask Didit whether the person has to verify again, and act only on an approved step-up that your backend read itself. See step-up before sensitive actions.
  4. Take vendor_data from the verified token, never from a field the browser sent, and use it for the person’s verifications and transactions.

Sessions

Change the lengths in Authentication > Security and sessions, or by API in application settings.
The Active sessions view in the Didit Business Console, listing signed-in sessions with device, location, start, last activity, end and a Revoke button

Authentication > Sign-ins > Active sessions, with Revoke on each session.

Native apps

Didit returns people to a native app through an HTTPS redirect only: it accepts no custom URL schemes.
  • iOS: make the redirect an associated domain, with webcredentials in your apple-app-site-association.
  • Android: make the redirect an App Link, with your assetlinks.json.
  • Register every redirect URL under Authentication > Security and sessions, like a web callback.
For passkeys in your app, register the apps that share your application’s passkeys with PUT native-apps/ on the Authentication management API. Didit then lists them in the apple-app-site-association and assetlinks.json it serves on your sign-in origin. MANAGEMENT_BASE is your application’s management API address, and an API key with the authentication scope at write can make the call. The call replaces both lists, so send both:
The iOS and Android quickstarts show the app side.

Connect identity verification and transaction monitoring

Every person has one vendor_data value, in their tokens and their session. Use it as vendor_data when you create a verification session or submit a transaction, and the console shows sign-ins, verifications and transactions on the same person.
  • To verify people at sign-up or again before a payout without building a verification flow, use verified identity.
  • Sign-in events reach event rules and the fraud views automatically. Do not post your own auth.login events for the same sign-ins.
  • A successful sign-in never approves a verification or a transaction: handle each product’s decision separately.
See keep one person across products.

Receive sign-in events

Subscribe a webhook destination to the auth.* types you need, such as auth.new_device or auth.account_locked. Deduplicate on auth_event.event_id, and verify the signature as for every Didit webhook. See events and webhooks for every type and its payload.

Move existing users

If your users already have accounts on another identity platform or in your own database, import them before you switch sign-in. Import their password hashes where the source gives them, keep their social links, and keep your own user IDs as external_id, which becomes their vendor_data. Nothing changes for them until you switch your app to Didit.

Go-live checklist

  1. Authentication is turned on for your Live application on the Products page.
  2. Your production https:// redirect URLs and allowed origins are registered on the Live application. A Live application accepts no http:// addresses.
  3. Each social sign-in method uses your own app’s client ID and secret: Didit’s test credentials work in Sandbox only.
  4. Your production configuration has the Live publishable key (pk_live_) and your Live issuer.
  5. Your MFA policy, session lifetime, idle timeout, password length and sign-up policy are what you want. See application settings.
  6. Bot protection is on, with the breached-password check.
  7. Your backend verifies every access token, and calls GET /session/ before sensitive actions.
  8. Your branding, page texts and terms and privacy links are set. If you plan a custom domain, activate it before people start adding passkeys.
  9. Your webhook destination is subscribed to the auth.* types you handle.
  10. You tested sign-up, returning sign-in, cancellation, forgot password, MFA, session expiry, sign-out and a revoked session on the Live application.

Troubleshooting

Last modified on November 22, 2026