> ## 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. # E-Mail-Verifizierung API: Didit API-Zugangsdaten abrufen > POST /programmatic/verify-email/ bestätigt die E-Mail und liefert bei Didit Zugriffstoken, client_id und api_key. Pay-per-Use-Preise. Prompt zur E-Mail-Verifizierung und zum Abrufen der Zugangsdaten Prompt in die Zwischenablage kopieren \

\`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.`

\
Einfügen in ## OpenAPI ````yaml de/openapi-auth.json POST /programmatic/verify-email/ openapi: 3.0.0 info: version: 1.0.0 title: Didit Auth API description: >- API für programmatische Registrierung und Authentifizierung für Entwickler und KI-Agenten. Registrierung in 2 API-Aufrufen – kein Browser erforderlich. Die agentenfreundlichste Plattform für Identitätsverifizierung. ## Basis-URL Alle Endpoints in dieser Spezifikation werden unter `https://apx.didit.me/auth/v2` gehostet. Dies ist ein anderer Host als die Verifizierungs-API (`https://verification.didit.me/v3`). Zur Unterscheidung: Dieser Auth-Host stellt Ihre **JWT-Access-Tokens** aus und ermöglicht Ihnen das Auflisten und Verwalten Ihrer **Organisationen** und **Anwendungen**. Auf dem Verifizierungs-Host rufen Sie Sitzungen, Workflows, AML usw. auf und authentifizieren sich mit dem von dieser API zurückgegebenen **`api_key`**. ## So funktioniert der Auth-Flow 1. `POST /programmatic/register/` — E-Mail + Passwort übermitteln. 2. Erhalten Sie einen 6-stelligen alphanumerischen Code per E-Mail. 3. `POST /programmatic/verify-email/` — Code übermitteln. Sie erhalten ein JWT-`access_token`, ein `refresh_token`, eine Organisation und eine Standardanwendung mit `client_id` + `api_key` zurück. 4. Speichern Sie den `api_key`. Verwenden Sie ihn als `x-api-key` für jeden Aufruf von `https://verification.didit.me/v3/...`. 5. Auf jedem zukünftigen Rechner tauscht `POST /programmatic/login/` Ihre E-Mail + Ihr Passwort gegen ein neues JWT aus; rufen Sie anschließend `GET /organizations/me/` und die Anwendungs-Endpoints auf, um Anmeldedaten wiederherzustellen oder zu rotieren. Das JWT wird nur für die **Kontoverwaltungs**-Endpoints in dieser Spezifikation benötigt; der Traffic der Verifizierungs-API verwendet den langlebigen `api_key`, nicht das JWT. ## Konventionen - Alle Request- und Response-Bodys sind JSON (`Content-Type: application/json`). - **Verwenden Sie beim Testen von `POST /programmatic/register/` eine echte, zustellbare E-Mail-Adresse.** Der Endpoint sendet den Verifizierungscode synchron. Daher werden Adressen auf reservierten Test-Domains (`@example.com`, `@example.org`, `@*.test`, `@*.example`, `@*.invalid`) bei der E-Mail-Zustellung abgewiesen und die Anfrage gibt einen `500` zurück. Ersetzen Sie den Platzhalter `you@yourdomain.com` in den Beispielen durch ein Postfach, auf das Sie tatsächlich zugreifen können. - Validierungsfehler geben HTTP `400` mit einem von zwei Envelopes zurück: `{"field": ["message", ...]}` für Probleme auf Feldebene oder `{"detail": "message"}` für Geschäftsregelfehler. Einige wenige Validatoren (Passwortstärke bei der Registrierung, Code-Ablauf bei verify-email) antworten derzeit mit einem einfachen Array `["message"]` anstelle der feldbezogenen Form – dies ist eine bekannte serverseitige Inkonsistenz, daher sollte Client-Code beide Formen akzeptieren. - Authentifizierungsfehler werden als `{"detail": "..."}` mit HTTP `401` (ungültiges Bearer-Token) oder `403` (fehlendes Bearer-Token / unzureichende Berechtigungen) zurückgegeben. - Rate-Limit-Antworten enthalten ein `wait`-Feld mit der Abklingzeit in Sekunden. servers: - url: https://apx.didit.me/auth/v2 description: Produktions-Authentifizierungsserver security: [] tags: - name: Programmatic Auth description: >- Konto-Lebenszyklus mit E-Mail und Passwort: Registrieren, Verifizieren, Anmelden. Gibt das JWT-`access_token` zurück, das Sie für die Account-Management-Endpoints verwenden, sowie (bei Verifizierung) `client_id` und `api_key` Ihrer ersten Anwendung. - name: Account Management description: >- Authentifizierte Endpoints (JWT Bearer), die Organisationen auflisten und Anwendungen erstellen, abrufen oder aktualisieren. Verwenden Sie diese, um den `api_key` wiederherzustellen oder zu rotieren, mit dem Sie Verifizierungs-API-Aufrufe authentifizieren. paths: /programmatic/verify-email/: post: tags: - Programmatic Auth summary: E-Mail verifizieren und Anmeldedaten ausstellen description: >- Schritt 2 des Onboardings. Tauscht den 6-stelligen Code gegen ein verifiziertes Konto, eine Standard-Organisation+Anwendung und ein JWT-Paar ein. Speichern Sie den zurückgegebenen `api_key` dauerhaft. operationId: programmatic_verify_email requestBody: required: true content: application/json: schema: $ref: '#/components/schemas/VerifyEmailRequest' examples: Default: summary: Code aus der Registrierungs-E-Mail übermitteln value: email: you@yourdomain.com code: A3K9F2 responses: '200': description: >- E-Mail verifiziert. Die Antwort enthält Tokens für diese Auth-API sowie `client_id` und `api_key` der brandneuen Anwendung. Speichern Sie den `api_key` sicher ab — er ist der langlebige Berechtigungsnachweis, der von jedem Verifizierungs-API-Aufruf verwendet wird. 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: >- Validierungsfehler. Die vorgesehene Envelope ist `{"field": ["..."]}` für Probleme auf Feldebene und `{"detail": "..."}` für Geschäftsregelfehler (z. B. Benutzer nicht gefunden). Fehler wegen falschem oder abgelaufenem Code antworten derzeit mit einem einfachen Array `["Invalid or expired verification code."]` – eine bekannte serverseitige Inkonsistenz; behandeln Sie dies bis zur Behebung als `{"code": ["..."]}`. content: application/json: schema: $ref: '#/components/schemas/ValidationError' examples: MissingFields: summary: Leerer Body value: email: - This field is required. code: - This field is required. CodeTooShort: summary: Code unter 6 Zeichen value: code: - Ensure this field has at least 6 characters. InvalidEmail: summary: Ungültige E-Mail value: email: - Enter a valid email address. InvalidCode: summary: Falscher oder abgelaufener Code value: - Invalid or expired verification code. UserNotFound: summary: Kein ausstehendes Konto für diese E-Mail value: detail: User not found. '429': description: >- Der Dienst prüft vorübergehend so viele Passwörter oder Codes wie möglich gleichzeitig. Wird mit einem Header `Retry-After: 5` gesendet; wiederholen Sie die Anfrage nach der angegebenen Anzahl von Sekunden. content: application/json: schema: $ref: '#/components/schemas/RateLimitError' examples: PasswordChecksBusy: summary: Zu viele Passwortüberprüfungen werden derzeit ausgeführt 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: Bei `POST /programmatic/register/` verwendete E-Mail-Adresse. example: you@yourdomain.com code: type: string minLength: 6 maxLength: 6 description: >- 6-stelliger alphanumerischer Code aus der Verifizierungs-E-Mail. Codes laufen 10 Minuten nach dem Versand des letzten Codes ab. example: A3K9F2 VerifyEmailResponse: type: object properties: access_token: type: string description: >- RS256-signiertes JWT. Als `Authorization: Bearer ` für Account-Management-Endpoints auf `apx.didit.me/auth/v2` verwenden. refresh_token: type: string description: Refresh-Token, das mit dem Access-Token verknüpft ist. expires_in: type: integer description: Gültigkeitsdauer des Zugriffstokens in Sekunden (Standard 86400). example: 86400 organization: $ref: '#/components/schemas/OrganizationSummary' application: $ref: '#/components/schemas/ApplicationCredentialsSummary' ValidationError: description: >- Validierungsfehler-Body. Der vorgesehene Envelope ist eine `{field: ["message", ...]}`-Map für Fehler auf Feldebene oder ein Single-Key-Envelope `{detail: "..."}` für Geschäftsregel-Fehler. Einige wenige Validatoren (Passwortstärke bei der Registrierung, Code-Gültigkeit bei verify-email) antworten derzeit mit einem einfachen Array `["message"]` – eine bekannte serverseitige Inkonsistenz. Das untenstehende Schema behält diesen Zweig mit einfachem Array bei, damit aus dieser Spezifikation generierter Client-Code heutige Antworten deserialisiert. Neuer Client-Code sollte dies jedoch als die relevante feldbezogene Form (`{password: [...]}` oder `{code: [...]}`) behandeln, und der Serververtrag wird sich an diese Struktur anpassen. 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: >- Antwort bei Rate-Limit oder progressiver Sperrung. `wait` ist die Abklingzeit in Sekunden. properties: detail: type: string example: >- Too many login attempts from this IP address. Please wait before trying again. OrganizationSummary: type: object description: >- Minimales Organisationsobjekt, das inline von `POST /programmatic/verify-email/` zurückgegeben wird. properties: uuid: type: string format: uuid example: a1b2c3d4-5678-90ab-cdef-111111111111 name: type: string example: developer ApplicationCredentialsSummary: type: object description: >- Minimales Anwendungsobjekt, das inline von `POST /programmatic/verify-email/` zurückgegeben wird. Speichern Sie den `api_key` sofort dauerhaft. 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: >- Verwenden Sie dies als `x-api-key` bei jedem Verifizierungs-API-Aufruf. Neue Schlüssel beginnen mit `sk_live_` (Live-Anwendung) oder `sk_test_` (Sandbox-Anwendung), gefolgt von 43 URL-sicheren Zeichen (Buchstaben, Ziffern, `-` und `_`). Schlüssel, die vor diesem Format erstellt wurden, haben kein Präfix und funktionieren unverändert weiter. example: sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx data_location: $ref: '#/components/schemas/ApplicationDataLocation' ApplicationDataLocation: type: string enum: - eu - au - mx description: >- Wo die Verifizierungsdaten der Anwendung gespeichert und verarbeitet werden, ausgewählt bei der Erstellung der Anwendung. `eu` ist die Europäische Union (Irland), die Standardeinstellung. `au` (Australien, Sydney) und `mx` (Mexiko) folgen in Kürze: Eine Anfrage, die diese angibt, führt zu einer 400-Antwort `This data location is not available yet.`. Die Sandbox-Anwendung einer Organisation befindet sich immer in der Europäischen Union. example: eu ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.