> ## 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 d'authentification : inscription programmatique > Créez des organisations Didit par programmation via l'API d'authentification. Sans navigateur, natif pour agents. Paiement à l'appel, sans contrat. Prompt d'inscription programmatique Copier le prompt dans le presse-papiers \

\``Programmatically create a pending Didit account — step 1 of the two-step onboarding (no browser, no console).

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

Authentication:
None. This is a public endpoint. (Don't confuse the Auth API host `apx.didit.me/auth/v2` with the verification host `verification.didit.me/v3`.)

Request body:
\- email (string, required) — Any real, deliverable email (personal, work, alias). The verification code is mailed synchronously, so reserved test domains (`@example.com`, `@example.org`, `@*.test`, `@*.example`, `@*.invalid`) get rejected by mail delivery and the call returns `500` — substitute the placeholder with an inbox you can read.
\- password (string, required) — Must satisfy ALL of: minimum 8 characters, ≥1 uppercase letter (A-Z), ≥1 lowercase letter (a-z), ≥1 digit (0-9), ≥1 special character from !@#$%^&*()_+-=[]{}|;:,.<>?. Rules are validated one at a time and the first failure short-circuits.

curl example (replace `you@yourdomain.com` with a real inbox):
curl -X POST https://apx.didit.me/auth/v2/programmatic/register/ \
-H "Content-Type: application/json" \
-d '{
"email": "you@yourdomain.com",
"password": "MyStr0ng!Pass"
}'

Response (201 Created):
\- message (string) — "Registration successful. Check your email for the verification code."
\- email (string) — echoed back.

What happens server-side:
\- A pending account is created (NOT usable yet).
\- A 6-character alphanumeric code (e.g. "A3K9F2") is emailed to the supplied address.
\- The code is valid for 15 minutes. After expiry the registration must be redone.

Failure modes (all 400 unless noted):
\- Field-level: { "email": ["Enter a valid email address."] } or { "password": ["Ensure this field has at least 8 characters."] }.
\- Password-strength failures CURRENTLY return as a BARE ARRAY (no field key), one rule at a time: ["Password must contain at least one uppercase letter."] / lowercase / digit / special character. Known server-side inconsistency — treat as { "password": [...] } client-side.
\- Duplicate email: { "detail": "An account with this email already exists." }
\- 429 — { "detail": "Too many registration attempts. Please try again later.", "wait":  } when more than 5 registrations from the same IP within an hour.
\- 500 — returned (with an HTML body, not JSON) when mail delivery to the supplied address fails synchronously. Most commonly triggered by reserved test domains; use a real inbox.

Rate limits:
5 registrations per IP per hour.

Next step:
After receiving the email, call POST https://apx.didit.me/auth/v2/programmatic/verify-email/ with { "email", "code" } to get your access_token and api_key — see /auth-api/verify-email.

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/register/ 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/register/: post: tags: - Programmatic Auth summary: Créer un compte description: >- Étape 1 de l'onboarding programmatique. Crée un compte en attente et envoie par e-mail un code à 6 caractères (durée de validité de 10 min). L'adresse est vérifiée avant la création du compte : une adresse incapable de recevoir le code renvoie une erreur 400 `email_undeliverable`. Limites de débit : 5/IP/heure, plus un quota horaire partagé par réseau (/24 pour IPv4, /64 pour IPv6). operationId: programmatic_register requestBody: required: true content: application/json: schema: $ref: '#/components/schemas/RegisterRequest' examples: Gmail: summary: S'inscrire avec un compte Gmail personnel value: email: you@yourdomain.com password: MyStr0ng!Pass Work: summary: S'inscrire avec une adresse e-mail professionnelle value: email: you@yourcompany.com password: C0mplex#Pass1 responses: '201': description: >- Inscription réussie. Un code de vérification alphanumérique à 6 caractères (par ex. `A3K9F2`) a été envoyé par e-mail à l'adresse fournie et est valide pendant 10 minutes. Appelez ensuite `POST /programmatic/verify-email/`. content: application/json: schema: $ref: '#/components/schemas/RegisterResponse' examples: Success: value: message: >- Registration successful. Check your email for the verification code. email: you@yourdomain.com '400': description: >- Erreur de validation. L'enveloppe prévue est `{"field": ["..."]}` pour les erreurs au niveau des champs et `{"detail": "..."}` pour les erreurs de règles métier (par exemple, un e-mail en double). Les règles de robustesse des mots de passe répondent actuellement avec un tableau brut `["..."]`, une règle à la fois -- incohérence connue côté serveur ; traitez-le comme `{"password": ["..."]}` jusqu'à ce que ce soit corrigé. Lorsque l'adresse ne peut pas recevoir le code (domaine jetable, réservé ou de test, absence de serveur de messagerie, faute de frappe probable, ou adresse ayant déjà généré un rebond), le corps est `EmailUndeliverableError` avec `code: "email_undeliverable"` ; aucun compte n'est créé ou modifié. content: application/json: schema: oneOf: - $ref: '#/components/schemas/ValidationError' - $ref: '#/components/schemas/EmailUndeliverableError' 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. PasswordTooShort: summary: Mot de passe de moins de 8 caractères value: password: - Ensure this field has at least 8 characters. PasswordMissingUppercase: summary: Mot de passe sans lettre majuscule value: - Password must contain at least one uppercase letter. PasswordMissingLowercase: summary: Mot de passe sans lettre minuscule value: - Password must contain at least one lowercase letter. PasswordMissingDigit: summary: Mot de passe sans chiffre value: - Password must contain at least one digit. PasswordMissingSpecial: summary: Mot de passe sans caractère spécial value: - >- Password must contain at least one special character (!@#$%^&*()_+-=[]{}|;:,.<>?). Duplicate: summary: Un compte existe déjà avec cet e-mail value: detail: An account with this email already exists. EmailUndeliverable: summary: L'adresse ne peut pas recevoir d'e-mails (domaine jetable) value: detail: >- This email can't receive messages. Please use a different email address. code: email_undeliverable reason: disposable_domain EmailLikelyTypo: summary: Faute de frappe probable dans le domaine value: detail: >- This email can't receive messages. Please use a different email address. code: email_undeliverable reason: possible_typo suggestion: gmail.com '429': description: >- Limite de débit atteinte. Plus de 5 tentatives d'enregistrement depuis la même IP au cours de la dernière heure, ou le quota horaire pour le réseau de l'appelant (/24 pour IPv4, /64 pour IPv6, partagé entre l'enregistrement et les renvois de code) est épuisé. Les deux renvoient `Retry-After: 3600`. Renvoyé également, avec un en-tête `Retry-After: 5`, lorsque le service vérifie temporairement autant de mots de passe ou de codes qu'il peut simultanément ; réessayez après le nombre de secondes indiqué. content: application/json: schema: $ref: '#/components/schemas/RateLimitError' examples: RateLimited: value: detail: Too many registration attempts. Please try again later. 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/register/ \ -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.register( 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.register({ 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.Register(ctx, didit.RegisterRequest{\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.RegisterRequest; // This call needs no API key. Didit client = new Didit(); var result = client.account().register(RegisterRequest.builder() .email("you@yourdomain.com") .password("MyStr0ng!Pass") .build()); System.out.println(result); - lang: php label: PHP source: |- account->register([ '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.register( 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.RegisterAsync(new RegisterRequest { Email = "you@yourdomain.com", Password = "MyStr0ng!Pass", }); Console.WriteLine(JsonSerializer.Serialize(result)); components: schemas: RegisterRequest: type: object required: - email - password properties: email: type: string format: email description: >- Toute adresse e-mail valide (personnelle, professionnelle, alias). Utilisée comme identifiant de compte unique. example: you@yourdomain.com password: type: string minLength: 8 description: >- 8 caractères minimum. Doit contenir au moins une lettre majuscule (`A-Z`), une lettre minuscule (`a-z`), un chiffre (`0-9`) et un caractère spécial parmi `!@#$%^&*()_+-=[]{}|;:,.<>?`. La validation signale une seule règle non respectée à la fois. example: MyStr0ng!Pass RegisterResponse: type: object properties: message: type: string description: >- Confirmation lisible par l'humain indiquant que le code de vérification a été envoyé. example: Registration successful. Check your email for the verification code. email: type: string format: email description: L'adresse e-mail à laquelle le code de vérification a été envoyé. example: you@yourdomain.com 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. EmailUndeliverableError: type: object description: >- Renvoyé par `POST /programmatic/register/` lorsque l'adresse ne peut pas recevoir le code de vérification. La vérification s'exécute avant qu'aucun compte ne soit créé ou modifié, ne laissant ainsi aucune trace. required: - detail - code - reason properties: detail: type: string description: Message lisible par l'humain. example: >- This email can't receive messages. Please use a different email address. code: type: string enum: - email_undeliverable description: Toujours `email_undeliverable`. reason: type: string enum: - invalid_address - reserved_domain - no_mail_records - disposable_domain - possible_typo - suppressed description: "Raison pour laquelle l'adresse a été refusée\_: `invalid_address` (adresse non valide), `reserved_domain` (domaine réservé ou de test tel que `example.com`), `no_mail_records` (le domaine n'a pas de serveur de messagerie), `disposable_domain` (fournisseur d'adresses temporaires), `possible_typo` (faute de frappe probable dans le nom d'un fournisseur courant\_; voir `suggestion`), `suppressed` (l'adresse a précédemment généré un rejet ou une plainte)." suggestion: type: string description: >- Le domaine probablement visé, présent uniquement lorsque le domaine ressemble à une faute de frappe (par exemple `gmail.com` pour `gmial.com`). L'API n'accepte pas de confirmation : inscrivez-vous à nouveau avec l'adresse corrigée. example: gmail.com 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.