> ## Documentation Index > Fetch the complete documentation index at: https://docs.didit.me/llms.txt > Use this file to discover all available pages before exploring further. # API de connexion programmatique : jetons d'accès headless > Didit : POST /programmatic/login/ renvoie directement les jetons d'accès, sans 2FA. Pour agents IA et MCP, tarification à l'usage. Invite de connexion programmatique Copier le prompt dans le presse-papiers \

\`Exchange a verified Didit account's email + password for a fresh JWT access token (headless, no browser).

Endpoint:
POST https://apx.didit.me/auth/v2/programmatic/login/

Authentication:
None. Email + password is the credential.

Request body:
\- email (string, required) — Same email used at /programmatic/register/.
\- password (string, required) — Plain password (HTTPS only).

Account requirements:
The account must have a verified email and password. Accounts created through POST /programmatic/register/ work immediately after email verification. Console-created email/password accounts can also use this endpoint. OAuth-only console accounts must set a password first.

curl example:
curl -X POST https://apx.didit.me/auth/v2/programmatic/login/ \
-H "Content-Type: application/json" \
-d '{
"email": "you@yourdomain.com",
"password": "MyStr0ng!Pass"
}'

Response (200 OK):
\- access_token (string) — RS256 JWT. Pass as "Authorization: Bearer " on every Account Management endpoint at apx.didit.me/auth/v2. DO NOT use against verification.didit.me — that host uses x-api-key.
\- refresh_token (string) — RS256 JWT for refresh flows.
\- expires_in (integer) — Default 86400 (24 hours).

Token shape:
\- 24-hour default lifetime.
\- RS256-signed.
\- No browser session is required.

Brute-force protection:
\- Progressive account lockout per email: 5 consecutive failures = 15 min lockout, 10 = 1 hour, 20 = 24 hours.
\- Per-IP rate limit: 20 attempts/minute and 100 attempts/hour.

Failure modes:
\- 400 — { "email": ["..."] } / { "password": ["..."] } field-level errors.
\- 401 — { "detail": "Invalid email or password." }
\- 403 — { "detail": "..." } when SSO policy blocks password login for the account.
\- 429 — { "detail": "Too many login attempts.", "wait":  } on lockout or per-IP limit. Honour the wait value before retrying.

Recovering your api_key:
After a successful login, call GET /organizations/me/ to enumerate organizations and applications, then GET /organizations/me/{org_id}/applications/{app_id}/ to read the api_key — see /auth-api/get-credentials.

Where to use access_token vs api_key:
\- access_token (Bearer) → https://apx.didit.me/auth/v2/... (org / app management).
\- api_key (x-api-key) → https://verification.didit.me/v3/... (sessions, workflows, billing).

For end-to-end Didit integration, paste in the full prompt at /integration/integration-prompt.`

\
Coller dans ## OpenAPI ````yaml fr/openapi-auth.json POST /programmatic/login/ openapi: 3.0.0 info: version: 1.0.0 title: Didit Auth API description: "API d'inscription et d'authentification programmatiques pour les développeurs et les agents IA. Inscrivez-vous en 2 appels d'API -- aucun navigateur requis. La plateforme de vérification d'identité la plus adaptée aux agents.\n\n## URL de base\n\nTous les endpoints de cette spécification sont hébergés sur `https://apx.didit.me/auth/v2`. Il s'agit d'un hôte différent de celui de l'API de vérification (`https://verification.didit.me/v3`). Distinguez-les bien\_: cet hôte d'authentification délivre vos **tokens d'accès JWT** et vous permet de lister et gérer vos **organisations** et **applications**. L'hôte de vérification est celui sur lequel vous appelez les sessions, les workflows, l'AML, etc., en vous authentifiant avec la **`api_key`** renvoyée par cette API.\n\n## Fonctionnement du flux d'authentification\n\n1. `POST /programmatic/register/` — soumettez e-mail + mot de passe.\n2. Recevez un code alphanumérique de 6 caractères par e-mail.\n3. `POST /programmatic/verify-email/` — soumettez le code. Vous recevez en retour un `access_token` JWT, un `refresh_token`, une organisation et une application par défaut avec `client_id` + `api_key`.\n4. Enregistrez la `api_key`. Utilisez-la comme `x-api-key` pour chaque appel vers `https://verification.didit.me/v3/...`.\n5. Depuis n'importe quelle machine ultérieure, `POST /programmatic/login/` échange votre e-mail + mot de passe contre un nouveau JWT, puis appelez `GET /organizations/me/` et les endpoints d'application pour récupérer ou renouveler les identifiants.\n\nLe JWT n'est requis que pour les endpoints de **Gestion de compte** de cette spécification\_; le trafic de l'API de vérification utilise la `api_key` de longue durée, pas le JWT.\n\n## Conventions\n\n- Tous les corps de requête et de réponse sont en JSON (`Content-Type: application/json`).\n- **Utilisez une véritable adresse e-mail distribuable lors du test de `POST /programmatic/register/`.** L'endpoint envoie le code de vérification de manière synchrone\_; les adresses sur des domaines de test réservés (`@example.com`, `@example.org`, `@*.test`, `@*.example`, `@*.invalid`) sont donc refusées par le service de distribution des e-mails et la requête renvoie une erreur `500`. Remplacez l'espace réservé `you@yourdomain.com` dans les exemples par une boîte de réception que vous pouvez réellement consulter.\n- Les erreurs de validation renvoient un code HTTP `400` avec l'une des deux structures\_: `{\"field\": [\"message\", ...]}` pour les problèmes au niveau des champs, ou `{\"detail\": \"message\"}` pour les erreurs de règles métier. Quelques validateurs (force du mot de passe lors de l'inscription, expiration du code lors de la vérification de l'e-mail) répondent actuellement avec un simple tableau `[\"message\"]` au lieu du format avec des clés correspondant aux champs -- il s'agit d'une incohérence connue côté serveur\_; le code client doit donc accepter les deux formats.\n- Les erreurs d'authentification renvoient `{\"detail\": \"...\"}` avec un code HTTP `401` (token porteur non valide) ou `403` (token porteur manquant / privilèges insuffisants).\n- Les réponses de limite de débit incluent un champ `wait` indiquant le délai d'attente en secondes." servers: - url: https://apx.didit.me/auth/v2 description: Serveur d'authentification de production security: [] tags: - name: Programmatic Auth description: >- Cycle de vie d'un compte avec e-mail et mot de passe : inscription, vérification, connexion. Renvoie le `access_token` JWT que vous utilisez sur les endpoints de gestion de compte, plus (lors de la vérification) le `client_id` et la `api_key` de votre première application. - name: Account Management description: >- Endpoints authentifiés (Bearer JWT) qui listent les organisations et créent, récupèrent ou mettent à jour des applications. Utilisez-les pour récupérer ou remplacer la clé `api_key` avec laquelle vous authentifiez les appels à l'API de vérification. paths: /programmatic/login/: post: tags: - Programmatic Auth summary: Connexion programmatique description: "Authentifiez tout compte Didit vérifié par e-mail et mot de passe et recevez une paire de JWT RS256 (durée de vie par défaut\_: 86400s). Les comptes e-mail/mot de passe créés dans la console peuvent utiliser cet endpoint\_; les comptes de la console utilisant uniquement OAuth doivent d'abord définir un mot de passe." operationId: programmatic_login requestBody: required: true content: application/json: schema: $ref: '#/components/schemas/LoginRequest' examples: Default: summary: Connexion programmatique value: email: you@yourdomain.com password: MyStr0ng!Pass responses: '200': description: >- Connexion réussie. Renvoie une nouvelle paire de JWT. Utilisez l'`access_token` comme `Authorization: Bearer ` sur `/organizations/me/...` pour récupérer l'`org_id`, l'`app_id` et l'`api_key`. Lorsque le compte dispose d'une application d'authentification ou d'une clé d'accès (passkey), la réponse contient `2fa_required: true` et un `temp_token` au lieu des tokens. content: application/json: schema: $ref: '#/components/schemas/LoginResponse' examples: Success: value: access_token: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9... refresh_token: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9... expires_in: 86400 message: Login successful '400': description: >- Erreur de validation. Problèmes au niveau des champs dans le corps de la requête. content: application/json: schema: $ref: '#/components/schemas/ValidationError' examples: MissingFields: summary: Corps vide value: email: - This field is required. password: - This field is required. InvalidEmail: summary: E-mail mal formé value: email: - Enter a valid email address. '401': description: Authentification refusée. content: application/json: schema: $ref: '#/components/schemas/AuthError' examples: InvalidCredentials: summary: >- L'e-mail et le mot de passe ne correspondent pas (également renvoyé lorsque le compte n'existe pas, pour éviter l'énumération des utilisateurs) value: detail: Invalid email or password. NotVerified: summary: Le compte existe mais l'e-mail n'est pas encore vérifié value: detail: Please verify your email address before logging in. SSORequired: summary: Le compte appartient à une organisation qui requiert le SSO value: detail: error: sso_required message: Your organization 'Acme Corp' requires SSO login. organization_name: Acme Corp organization_slug: acme-corp sso_url: /sso/acme-corp '403': description: >- Le compte a été récupéré et doit configurer une nouvelle méthode de connexion avant de pouvoir se connecter. Un lien pour ce faire a été envoyé par e-mail à l'adresse du compte. Un compte dont l'organisation impose le SSO reçoit une réponse `403` avec `error: sso_required`, `organization_name`, `organization_slug` et `sso_url`. content: application/json: schema: $ref: '#/components/schemas/RecoverySetupRequiredError' examples: RecoverySetupRequired: summary: Compte récupéré sans méthode de connexion pour le moment value: recovery_setup_required: true setup_link_sent: true message: >- You recovered your account. Open the link we emailed you to set up a new sign-in method. code: recovery_setup_required '429': description: >- Compte verrouillé (trop d'échecs récents pour cet e-mail) ou IP soumise à une limite de débit (trop de tentatives depuis cette adresse). Également renvoyé, avec un en-tête `Retry-After: 5`, lorsque le service vérifie momentanément autant de mots de passe ou de codes qu'il le peut à la fois ; réessayez après le nombre de secondes indiqué. content: application/json: schema: $ref: '#/components/schemas/RateLimitError' examples: AccountLocked: summary: Verrouillage progressif déclenché value: detail: >- Account temporarily locked due to too many failed login attempts. Please try again later. IPRateLimited: summary: Plus de 20/min ou 100/heure depuis cette adresse IP value: detail: >- Too many login attempts from this IP address. Please wait before trying again. PasswordChecksBusy: summary: Trop de vérifications de mot de passe en cours value: detail: >- Too many sign-in attempts are being processed right now. Please try again in a few seconds. security: - {} x-codeSamples: - lang: curl label: cURL source: |- curl -X POST https://apx.didit.me/auth/v2/programmatic/login/ \ -H "Content-Type: application/json" \ -d '{ "email": "you@yourdomain.com", "password": "MyStr0ng!Pass" }' - lang: python label: Python source: |- from didit import Didit # This call needs no API key. client = Didit() result = client.account.login( email="you@yourdomain.com", password="MyStr0ng!Pass", ) print(result) - lang: javascript label: Node.js source: |- import Didit from "@didit-protocol/sdk-node"; // This call needs no API key. const didit = new Didit(); const result = await didit.account.login({ email: "you@yourdomain.com", password: "MyStr0ng!Pass", }); console.log(result); - lang: go label: Go source: "ctx := context.Background()\n// This call needs no API key.\nclient := didit.NewClient()\n\nresult, err := client.Account.Login(ctx, didit.LoginRequest{\n\tEmail: \"you@yourdomain.com\",\n\tPassword: \"MyStr0ng!Pass\",\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)" - lang: java label: Java source: |- import me.didit.Didit; import me.didit.types.LoginRequest; // This call needs no API key. Didit client = new Didit(); var result = client.account().login(LoginRequest.builder() .email("you@yourdomain.com") .password("MyStr0ng!Pass") .build()); System.out.println(result); - lang: php label: PHP source: |- account->login([ 'email' => 'you@yourdomain.com', 'password' => 'MyStr0ng!Pass', ]); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # This call needs no API key. didit = Didit::Client.new result = didit.account.login( email: "you@yourdomain.com", password: "MyStr0ng!Pass" ) puts result.to_h - lang: csharp label: .NET source: |- using System; using System.Text.Json; using Didit; // This call needs no API key. using var client = new DiditClient(); var result = await client.Account.LoginAsync(new LoginRequest { Email = "you@yourdomain.com", Password = "MyStr0ng!Pass", }); Console.WriteLine(JsonSerializer.Serialize(result)); components: schemas: LoginRequest: type: object required: - email - password properties: email: type: string format: email example: you@yourdomain.com password: type: string example: MyStr0ng!Pass LoginResponse: type: object properties: access_token: type: string description: >- JWT signé en RS256. À utiliser sous la forme `Authorization: Bearer ` pour les endpoints de gestion de compte. refresh_token: type: string expires_in: type: integer description: Durée de vie du token d'accès en secondes (86400 par défaut). example: 86400 message: type: string example: Login successful ValidationError: description: >- Corps de l'erreur de validation. L'enveloppe prévue est une structure `{field: ["message", ...]}` pour les erreurs au niveau des champs ou une enveloppe à clé unique `{detail: "..."}` pour les erreurs de règles métier. Quelques validateurs (robustesse du mot de passe lors de l'inscription, validité du code lors de verify-email) répondent actuellement avec un simple tableau `["message"]`, une incohérence connue côté serveur. Le schéma ci-dessous conserve cette branche avec tableau simple afin que le code client généré à partir de cette spécification désérialise les réponses actuelles, mais le nouveau code client devrait le traiter sous la forme indexée par champ appropriée (`{password: [...]}` ou `{code: [...]}`) et le contrat serveur convergera vers cette structure. oneOf: - type: object additionalProperties: type: array items: type: string example: email: - Enter a valid email address. - type: object properties: detail: type: string example: detail: An account with this email already exists. - type: array items: type: string example: - Invalid or expired verification code. AuthError: type: object description: >- Enveloppe d'erreur d'authentification / d'autorisation / d'élément introuvable. properties: detail: type: string example: Invalid access token RecoverySetupRequiredError: type: object description: >- Le compte a été récupéré et n'a pas encore de méthode de connexion configurée. Aucun token n'est délivré ; un lien à usage unique pour configurer une nouvelle méthode a été envoyé par e-mail à l'adresse du compte. Ouvrez-le, configurez la méthode, puis reconnectez-vous. required: - recovery_setup_required - setup_link_sent - message - code properties: recovery_setup_required: type: boolean example: true setup_link_sent: type: boolean example: true message: type: string example: >- You recovered your account. Open the link we emailed you to set up a new sign-in method. code: type: string enum: - recovery_setup_required example: recovery_setup_required RateLimitError: type: object description: >- Réponse de limite de débit ou de verrouillage progressif. `wait` est le délai d'attente en secondes. properties: detail: type: string example: >- Too many login attempts from this IP address. Please wait before trying again. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.