> ## 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 vérification de l'e-mail : obtenir clés API Didit > POST /programmatic/verify-email/ pour confirmer l'e-mail et recevoir des jetons d'accès, client_id et api_key. Onboarding agentique, tarification à l'usage. Prompt de vérification de l'e-mail et d'obtention des identifiants Copier le prompt dans le presse-papiers \

\`Exchange the email verification code for usable Didit credentials — step 2 of programmatic onboarding.

Endpoint:
POST https://apx.didit.me/auth/v2/programmatic/verify-email/

Authentication:
None. The email + code pair is the credential.

Request body:
\- email (string, required) — Same email used in /programmatic/register/.
\- code (string, required) — 6-character alphanumeric code from the registration email (e.g. "A3K9F2"). Valid for 15 minutes.

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

Response (200 OK):
\{
"access_token": "eyJ...RS256 JWT",
"refresh_token": "eyJ...RS256 JWT",
"expires_in": 86400,
"organization": {
"uuid": "a1b2c3d4-5678-...",
"name": "you"
},
"application": {
"uuid": "b2c3d4e5-6789-...",
"name": "you",
"client_id": "S9LIYGSoWNuGMLHsvEt9dQ",
"api_key": "sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
"data_location": "eu"
}
}

What happens server-side:
1\. The pending account is marked email-verified.
2\. A default organization is created (named after the local part of the email, e.g. "you" from "you@yourdomain.com").
3\. A default application is created inside the organization with a fresh client_id and api_key, in the European Union (data_location "eu"). Its location can be chosen once with PATCH /organizations/me/{org_id}/applications/{app_id}/ before the application is used; see /auth-api/update-application.
4\. JWTs are issued (RS256, default 24h / 86400 seconds lifetime).

How to use the response:
\- application.api_key → set as the x-api-key header on EVERY call to https://verification.didit.me/v3/... (sessions, workflows, questionnaires, billing, etc.). PERSIST IT SECURELY. You can read it again later with GET /organizations/me/{org_id}/applications/{app_id}/.
\- access_token → use as "Authorization: Bearer " against Account Management endpoints on https://apx.didit.me/auth/v2 (e.g. to create more applications).
\- refresh_token → exchange for a new access_token after expiry.

Save the api_key, the organization.uuid (org_id), and the application.uuid (app_id) — you will need all three to manage applications later.

Failure modes (400 unless noted):
\- Field-level: { "email": ["Enter a valid email address."] } or { "code": ["Ensure this field has at least 6 characters."] }.
\- Wrong or expired code CURRENTLY returns a BARE ARRAY ["Invalid or expired verification code."] — known server-side inconsistency; treat as { "code": [...] } client-side.
\- Unknown email: { "detail": "User not found." }

Recovery if you lose the api_key later:
Call POST /programmatic/login/ with email + password to get a fresh access_token, then GET /organizations/me/{org_id}/applications/{app_id}/ to read the api_key back. See /auth-api/login and /auth-api/get-credentials.

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/verify-email/ 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/verify-email/: post: tags: - Programmatic Auth summary: Vérifier l'e-mail et émettre des identifiants description: >- Étape 2 de l'onboarding. Échange le code à 6 caractères contre un compte vérifié, une organisation et une application par défaut, et une paire de jetons JWT. Conservez la clé `api_key` renvoyée. operationId: programmatic_verify_email requestBody: required: true content: application/json: schema: $ref: '#/components/schemas/VerifyEmailRequest' examples: Default: summary: Soumettre le code de l'e-mail d'inscription value: email: you@yourdomain.com code: A3K9F2 responses: '200': description: >- E-mail vérifié. La réponse contient des tokens pour cette API d'authentification ainsi que le `client_id` et la `api_key` de la toute nouvelle application. Conservez la `api_key` en toute sécurité — c'est l'identifiant à longue durée de vie utilisé par chaque appel d'API de vérification. content: application/json: schema: $ref: '#/components/schemas/VerifyEmailResponse' examples: Success: value: access_token: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9... refresh_token: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9... expires_in: 86400 organization: uuid: a1b2c3d4-5678-90ab-cdef-111111111111 name: developer application: uuid: b2c3d4e5-6789-01bc-defg-222222222222 name: developer client_id: S9LIYGSoWNuGMLHsvEt9dQ api_key: sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx data_location: eu '400': description: >- Erreur de validation. L'enveloppe prévue est `{"field": ["..."]}` pour les problèmes au niveau des champs et `{"detail": "..."}` pour les erreurs de règles métier (par exemple, utilisateur introuvable). Les erreurs de code incorrect ou expiré répondent actuellement avec un tableau brut `["Invalid or expired verification code."]` -- incohérence connue côté serveur ; traitez-le comme `{"code": ["..."]}` jusqu'à ce que ce soit corrigé. content: application/json: schema: $ref: '#/components/schemas/ValidationError' examples: MissingFields: summary: Corps vide value: email: - This field is required. code: - This field is required. CodeTooShort: summary: Code de moins de 6 caractères value: code: - Ensure this field has at least 6 characters. InvalidEmail: summary: E-mail mal formé value: email: - Enter a valid email address. InvalidCode: summary: Code erroné ou expiré value: - Invalid or expired verification code. UserNotFound: summary: Aucun compte en attente pour cet e-mail value: detail: User not found. '429': description: >- Le service vérifie momentanément autant de mots de passe ou de codes qu'il le peut à la fois. Envoyé avec un en-tête `Retry-After: 5` ; réessayez après le nombre de secondes indiqué. content: application/json: schema: $ref: '#/components/schemas/RateLimitError' examples: 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/verify-email/ \ -H "Content-Type: application/json" \ -d '{ "email": "you@yourdomain.com", "code": "A3K9F2" }' - lang: python label: Python source: |- from didit import Didit # This call needs no API key. client = Didit() result = client.account.verify_email( email="you@yourdomain.com", code="A3K9F2", ) 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.verifyEmail({ email: "you@yourdomain.com", code: "A3K9F2", }); 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.VerifyEmail(ctx, didit.VerifyEmailRequest{\n\tEmail: \"you@yourdomain.com\",\n\tCode: \"A3K9F2\",\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.VerifyEmailRequest; // This call needs no API key. Didit client = new Didit(); var result = client.account().verifyEmail(VerifyEmailRequest.builder() .email("you@yourdomain.com") .code("A3K9F2") .build()); System.out.println(result); - lang: php label: PHP source: |- account->verifyEmail([ 'email' => 'you@yourdomain.com', 'code' => 'A3K9F2', ]); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # This call needs no API key. didit = Didit::Client.new result = didit.account.verify_email( email: "you@yourdomain.com", code: "A3K9F2" ) 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.VerifyEmailAsync(new VerifyEmailRequest { Email = "you@yourdomain.com", Code = "A3K9F2", }); Console.WriteLine(JsonSerializer.Serialize(result)); components: schemas: VerifyEmailRequest: type: object required: - email - code properties: email: type: string format: email description: E-mail utilisé lors de `POST /programmatic/register/`. example: you@yourdomain.com code: type: string minLength: 6 maxLength: 6 description: >- Code alphanumérique de 6 caractères provenant de l'e-mail de vérification. Les codes expirent 10 minutes après l'envoi du code le plus récent. example: A3K9F2 VerifyEmailResponse: 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 sur `apx.didit.me/auth/v2`. refresh_token: type: string description: Token d'actualisation associé au token d'accès. expires_in: type: integer description: Durée de vie du token d'accès en secondes (86400 par défaut). example: 86400 organization: $ref: '#/components/schemas/OrganizationSummary' application: $ref: '#/components/schemas/ApplicationCredentialsSummary' 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. 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. OrganizationSummary: type: object description: >- Structure minimale d'organisation renvoyée directement dans la réponse par `POST /programmatic/verify-email/`. properties: uuid: type: string format: uuid example: a1b2c3d4-5678-90ab-cdef-111111111111 name: type: string example: developer ApplicationCredentialsSummary: type: object description: >- Structure minimale d'application renvoyée directement dans la réponse par `POST /programmatic/verify-email/`. Enregistrez immédiatement l'`api_key` de manière persistante. properties: uuid: type: string format: uuid example: b2c3d4e5-6789-01bc-defg-222222222222 name: type: string example: developer client_id: type: string example: S9LIYGSoWNuGMLHsvEt9dQ api_key: type: string description: >- À utiliser comme `x-api-key` sur chaque appel API de vérification. Les nouvelles clés commencent par `sk_live_` (application de production) ou `sk_test_` (application sandbox), suivies de 43 caractères compatibles avec les URL (lettres, chiffres, `-` et `_`). Les clés créées avant ce format n'ont pas de préfixe et continuent de fonctionner sans modification. example: sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx data_location: $ref: '#/components/schemas/ApplicationDataLocation' ApplicationDataLocation: type: string enum: - eu - au - mx description: >- Emplacement où les données de vérification de l'application sont stockées et traitées, choisi lors de la création de l'application. `eu` correspond à l'Union européenne (Irlande), la valeur par défaut. `au` (Australie, Sydney) et `mx` (Mexique) seront bientôt disponibles : une requête les mentionnant renvoie une erreur 400 `This data location is not available yet.` L'application Sandbox d'une organisation se trouve toujours dans l'Union européenne. example: eu ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.