> ## 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.

# Diia-Verifizierungs-API

> Integrieren Sie Diia-Identitätsverifizierung mit Didit in Ihre App. Mit Länderabdeckung, Authentifizierungsschritten, Ergebnissen und Preisen.

Starten Sie die Diia-Verifizierung über Ihr Backend mit Ihrem API-Schlüssel für die Anwendung.
Sie benötigen keinen Workflow und keine `workflow_id`.
Die Antwort auf den Start beschreibt die nächste Authentifizierungsaktion; sie ist kein genehmigtes Identitätsergebnis.

## Abdeckung und Aktivierung

| Eigenschaft | Wert |
| - | - |
| Wallet | Diia |
| Wallet-ID | `diia` |
| Länder | ![](https://didit-public-assets.s3.eu-west-1.amazonaws.com/flags/ua.svg)Ukraine |
| Aktivierung des Produktions-Wallets | ⏳ Demnächst verfügbar |
| Veröffentlichter Wallet-Preis | Demnächst verfügbar |

Die Aktivierung des Wallets ist unabhängig von der API-Bereitstellung und der Berechtigung Ihrer Anwendung.
Ein dokumentierter Endpoint aktiviert kein Wallet, das als Demnächst verfügbar gekennzeichnet ist.
Die aktuellen veröffentlichten Preise finden Sie unter [Preise für digitale ID-Wallets](https://docs.didit.me/de/getting-started/pricing.md#preise-für-digital-id-wallets).

## Was die Person tut

Folgen Sie der nächsten Aktion, die die Startanfrage zurückgibt.
Der Authentifizierungsablauf des Wallets legt fest, ob die Person einen Browser, ein anderes Gerät oder eine App verwendet.

## Ergebnis erhalten

Folgen Sie dem [Leitfaden zur API für digitale ID-Wallets](https://docs.didit.me/de/standalone-apis/digital-id-wallets.md), um die Verifizierung zu verfolgen und ihr Ergebnis abzurufen.
Betrachten Sie nur ein abgeschlossenes, verifiziertes Ergebnis als Nachweis dafür, dass das Wallet die Person authentifiziert hat.
Die zurückgegebenen Identitätsattribute variieren je nach Wallet; gehen Sie nicht davon aus, dass eine Adresse, ein Porträt oder alle angefragten Attribute vorhanden sind.

## Verwandte Themen

* [APIs für digitale ID-Wallets](https://docs.didit.me/de/standalone-apis/digital-id-wallets.md)
* [Wallet-Abdeckung und Attribute](https://docs.didit.me/de/core-technology/id-verification/digital-id-wallets.md)
* [Preise](https://docs.didit.me/de/getting-started/pricing.md#preise-für-digital-id-wallets)


## OpenAPI

````yaml de/openapi-25.json POST /v3/id-verification/wallets/diia/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API für Ausweisverifizierung. Authentifizierung über den x-api-key-Header.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/id-verification/wallets/diia/:
    post:
      tags:
        - Digital ID wallets
      summary: Diia-Verifizierung starten
      description: >-
        Starten Sie eine Diia-Anmeldung (Ministry of Digital Transformation of
        Ukraine; UKR) ohne einen Workflow. Wird einmalig abgerechnet, nur wenn
        die Identität verifiziert ist. Die Antwort enthält
        next_action.type=redirect mit der URL, an die der Browser des Benutzers
        weitergeleitet werden soll; der Benutzer kehrt mit angehängtem
        request_id und result zu return_url zurück. Lesen Sie das Ergebnis mit
        GET /v3/id-verification/wallets/verifications/{request_id}/ oder aus dem
        Webhook aus, niemals aus der URL. Sandbox-Anwendungen erhalten eine
        deterministische Simulation (simulated: true), die den Anbieter niemals
        kontaktiert.
      operationId: start_diia_wallet_verification
      parameters:
        - in: header
          name: Idempotency-Key
          schema:
            type: string
          description: >-
            Optionaler Schlüssel zur Wiederholungssicherheit (max. 255 Zeichen).
            Ein erneuter Versuch mit demselben Schlüssel, derselben Wallet und
            demselben Body gibt die ursprüngliche Verifizierung zurück, ohne
            eine zweite Anmeldung zu starten; derselbe Schlüssel mit einer
            anderen Wallet oder einem anderen Body gibt 409
            idempotency_key_reused zurück.
      requestBody:
        content:
          application/json:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiDiiaWalletVerificationStartRequest
            example:
              country: UKR
              vendor_data: your-customer-reference
              metadata:
                reference: example
              return_url: https://app.example.com/identity/complete
          application/x-www-form-urlencoded:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiDiiaWalletVerificationStartRequest
          multipart/form-data:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiDiiaWalletVerificationStartRequest
        required: true
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationResponse
              example:
                request_id: 00000000-0000-4000-8000-000000000001
                wallet_verification:
                  wallet:
                    id: diia
                    name: Diia
                    issuing_authority: Ministry of Digital Transformation of Ukraine
                  country: UKR
                  status: Not Finished
                  outcome: pending
                  error: null
                  interaction: redirect
                  simulated: false
                  expires_at: '2026-01-01T10:10:00Z'
                  next_action:
                    type: redirect
                    url: https://wallet.example.com/authorize
                  identity: null
                  attributes: null
                  level_of_assurance: null
                  verified_at: null
                  signature_valid: null
                  credential_type: person_identification
                vendor_data: your-customer-reference
                metadata:
                  reference: example
                created_at: '2026-01-01T10:00:00Z'
          description: ''
        '400':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationStartBadRequest
          description: >-
            Feldvalidierungsfehler ({field: [messages]}) oder Fehler
            return_url_invalid, return_url_not_allowed, invalid_personal_code,
            invalid_phone_number oder idempotency_key_invalid.
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationStartForbidden
          description: >-
            Fehlende Anmeldedaten ({detail}) oder Fehler wallet_unavailable,
            insufficient_credits oder contract_rate_missing.
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            Fehler idempotency_key_reused oder idempotency_key_in_progress (mit
            Retry-After).
        '502':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            Fehler wallet_provider_unavailable: Der Anbieter konnte nicht
            gestartet werden; es wurde nichts erstellt.
        '503':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            Fehler wallet_not_configured: Diese Umgebung kann die Wallet nicht
            erreichen.
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl --request POST \
              --url https://verification.didit.me/v3/id-verification/wallets/diia/ \
              --header 'x-api-key: YOUR_API_KEY' \
              --header 'Idempotency-Key: your-unique-attempt-key' \
              --header 'Content-Type: application/json' \
              --data '{
              "country": "UKR",
              "vendor_data": "your-customer-reference",
              "metadata": {
                "reference": "example"
              },
              "return_url": "https://app.example.com/identity/complete"
            }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.id_wallets.start_diia(
                vendor_data="your-customer-reference",
                metadata={"reference": "example"},
                country="UKR",
                return_url="https://app.example.com/identity/complete",
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY.
            const didit = new Didit();

            const result = await didit.idWallets.startDiia({
              vendor_data: "your-customer-reference",
              metadata: { reference: "example" },
              country: "UKR",
              return_url: "https://app.example.com/identity/complete",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.IDWallets.StartDiia(ctx, didit.IDWalletsStartDiiaParams{\n\tBody: didit.DigitalIDWalletAPIDiiaWalletVerificationStartRequest{\n\t\tVendorData: didit.String(\"your-customer-reference\"),\n\t\tMetadata:   didit.Some(map[string]any{\"reference\": \"example\"}),\n\t\tCountry:    didit.Some(didit.DigitalIDWalletAPIDiiaWalletVerificationStartCountryEnum(\"UKR\")),\n\t\tReturnURL:  \"https://app.example.com/identity/complete\",\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.Map;

            import me.didit.Didit;

            import
            me.didit.types.DigitalIdWalletApiDiiaWalletVerificationStartCountryEnum;

            import
            me.didit.types.DigitalIdWalletApiDiiaWalletVerificationStartRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.idWallets().startDiia(DigitalIdWalletApiDiiaWalletVerificationStartRequest.builder()
                    .vendorData("your-customer-reference")
                    .metadata(Map.of("reference", "example"))
                    .country(DigitalIdWalletApiDiiaWalletVerificationStartCountryEnum.of("UKR"))
                    .returnUrl("https://app.example.com/identity/complete")
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

            // Reads DIDIT_API_KEY.
            $didit = new DiditClient();

            $result = $didit->idWallets->startDiia([
                'vendor_data' => 'your-customer-reference',
                'metadata' => ['reference' => 'example'],
                'country' => 'UKR',
                'return_url' => 'https://app.example.com/identity/complete',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY.
            didit = Didit::Client.new

            result = didit.id_wallets.start_diia(
              vendor_data: "your-customer-reference",
              metadata: { reference: "example" },
              country: "UKR",
              return_url: "https://app.example.com/identity/complete"
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Collections.Generic;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await client.IdWallets.StartDiiaAsync(new
            DigitalIdWalletApiDiiaWalletVerificationStartRequest

            {
                VendorData = "your-customer-reference",
                Metadata = new Dictionary<string, object> { ["reference"] = "example" },
                Country = new DigitalIdWalletApiDiiaWalletVerificationStartCountryEnum("UKR"),
                ReturnUrl = "https://app.example.com/identity/complete",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    DigitalIdWalletApiDiiaWalletVerificationStartRequest:
      type: object
      description: Starten Sie eine Diia-Verifizierung (UKR).
      properties:
        vendor_data:
          type: string
          nullable: true
          description: >-
            Ihre eigene Referenz für diese Verifizierung (z. B. Ihre
            Benutzer-ID). Wird in Ergebnissen und Webhooks zurückgegeben.
        metadata:
          type: object
          additionalProperties: {}
          nullable: true
          description: >-
            Optionales JSON-Objekt, das mit der Verifizierung gespeichert und in
            Ergebnissen sowie Webhooks zurückgegeben wird.
        sandbox_scenario:
          type: string
          minLength: 1
          description: >-
            Nur für Sandbox-Anwendungen: Das simulierte Ergebnis –
            'wallet_cancelled', 'wallet_timeout' oder 'wallet_provider_error';
            jedes andere Szenario (oder keines) verifiziert erfolgreich. Bei
            Live-Anwendungen abgelehnt. Der vollständige Katalog ist unter GET
            /v1/sandbox/scenarios/ verfügbar.
        country:
          allOf:
            - $ref: >-
                #/components/schemas/DigitalIdWalletApiDiiaWalletVerificationStartCountryEnum
          default: UKR
          description: >-
            ISO 3166-1-Alpha-3-Land der Diia-Identität. Standardmäßig UKR, das
            einzige Land, das unterstützt wird.


            * `UKR` - UKR
        return_url:
          type: string
          format: uri
          minLength: 1
          description: >-
            HTTPS-URL, zu der der Browser des Benutzers nach der Wallet
            zurückkehrt, wobei request_id und result angehängt werden. Ihr Host
            muss in den allowed_return_hosts der Anwendung registriert sein
            (oder deren White-Label-Domain sein). Vertrauen Sie result niemals
            allein: Rufen Sie das Ergebnis mit GET
            .../verifications/{request_id}/ oder über den Webhook ab.
          maxLength: 2048
        device:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiDeviceEnum'
          default: same_device
          description: >-
            same_device, wenn sich der Benutzer auf dem Gerät anmeldet, das Ihre
            Seite anzeigt; cross_device, wenn er ein anderes Gerät verwendet (z.
            B. den QR-Code von BankID).


            * `same_device` - same_device

            * `cross_device` - cross_device
      required:
        - return_url
    DigitalIdWalletApiWalletVerificationResponse:
      type: object
      description: >-
        Eine eigenständige Wallet-Verifizierung, wie sie von jedem
        Wallet-Endpoint beantwortet wird.
      properties:
        request_id:
          type: string
          format: uuid
        wallet_verification:
          $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationResult'
        vendor_data:
          type: string
          nullable: true
        metadata:
          type: object
          additionalProperties: {}
          nullable: true
          description: Das beim Start gesendete Metadaten-Objekt oder null.
        created_at:
          type: string
          format: date-time
      required:
        - created_at
        - metadata
        - request_id
        - vendor_data
        - wallet_verification
    DigitalIdWalletApiWalletVerificationStartBadRequest:
      oneOf:
        - $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
        - $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationFieldErrors'
    DigitalIdWalletApiWalletVerificationStartForbidden:
      oneOf:
        - $ref: >-
            #/components/schemas/DigitalIdWalletApiClientCredentialsForbiddenErrorMessage
        - $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
    DigitalIdWalletApiWalletVerificationError:
      type: object
      properties:
        error:
          type: string
          description: Stabiler maschinenlesbarer Code, z. B. wallet_unavailable.
        detail:
          type: string
      required:
        - detail
        - error
    DigitalIdWalletApiDiiaWalletVerificationStartCountryEnum:
      enum:
        - UKR
      type: string
      description: '* `UKR` - UKR'
    DigitalIdWalletApiDeviceEnum:
      enum:
        - same_device
        - cross_device
      type: string
      description: |-
        * `same_device` - same_device
        * `cross_device` - cross_device
    DigitalIdWalletApiWalletVerificationResult:
      type: object
      properties:
        wallet:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWallet'
          readOnly: true
        country:
          type: string
        status:
          type: string
          description: >-
            Nicht abgeschlossen, solange ausstehend, dann genehmigt
            (verifiziert) oder abgelehnt.
        outcome:
          $ref: >-
            #/components/schemas/DigitalIdWalletApiWalletVerificationResultOutcomeEnum
        error:
          type: string
          nullable: true
          readOnly: true
        interaction:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiInteractionEnum'
          readOnly: true
        simulated:
          type: boolean
          readOnly: true
        expires_at:
          type: string
          format: date-time
        next_action:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWalletNextAction'
          nullable: true
          readOnly: true
        identity:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWalletIdentity'
          nullable: true
          readOnly: true
        attributes:
          type: object
          additionalProperties: {}
          nullable: true
          readOnly: true
        level_of_assurance:
          type: string
          nullable: true
        verified_at:
          type: string
          format: date-time
          nullable: true
        signature_valid:
          type: boolean
          nullable: true
          description: >-
            True, sobald die Signatur der Zugangsdaten verifiziert wurde; null
            bei simulierten Zugangsdaten.
        credential_type:
          type: string
          nullable: true
      required:
        - attributes
        - country
        - credential_type
        - error
        - expires_at
        - identity
        - interaction
        - level_of_assurance
        - next_action
        - outcome
        - signature_valid
        - simulated
        - status
        - verified_at
        - wallet
    DigitalIdWalletApiWalletVerificationFieldErrors:
      type: object
      description: >-
        Validierungsfehler der Anfrage: jedes abgelehnte Feld mit seinen
        Meldungen.
      additionalProperties:
        type: array
        items:
          type: string
    DigitalIdWalletApiClientCredentialsForbiddenErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Forbidden - User doesn't have permission
    DigitalIdWalletApiWallet:
      type: object
      properties:
        id:
          type: string
          description: Katalog-ID der Wallet, z. B. bankid_se.
        name:
          type: string
        issuing_authority:
          type: string
          nullable: true
      required:
        - id
        - issuing_authority
        - name
    DigitalIdWalletApiWalletVerificationResultOutcomeEnum:
      enum:
        - pending
        - verified
        - cancelled
        - timeout
        - failed
      type: string
      description: |-
        * `pending` - Ausstehend
        * `verified` - Verifiziert
        * `cancelled` - Vom Benutzer abgebrochen
        * `timeout` - Zeitüberschreitung
        * `failed` - Fehlgeschlagen
    DigitalIdWalletApiInteractionEnum:
      enum:
        - redirect
        - in_app
        - digital_credentials
      type: string
      description: |-
        * `redirect` - redirect
        * `in_app` - in_app
        * `digital_credentials` - digital_credentials
    DigitalIdWalletApiWalletNextAction:
      type: object
      properties:
        type:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWalletNextActionTypeEnum'
          description: >-
            redirect: Leiten Sie den Browser des Benutzers an url weiter.
            confirm_in_app: Zeigen Sie dem Benutzer verification_code an, der
            prüft, ob er mit dem Code in seiner Wallet-App übereinstimmt, und
            dort bestätigt; dann per Polling abfragen.
            request_digital_credential: Bei einer Benutzeraktion auf dem
            Ursprung, mit dem Sie begonnen haben, die Wallet mit
            digital_credentials.request abfragen und das Ergebnis an POST
            .../verifications/{request_id}/response/ senden.


            * `redirect` - redirect

            * `confirm_in_app` - confirm_in_app

            * `request_digital_credential` - request_digital_credential
        url:
          type: string
          format: uri
          description: 'Nur redirect: wo sich der Benutzer mit der Wallet anmeldet.'
        digital_credentials:
          allOf:
            - $ref: >-
                #/components/schemas/DigitalIdWalletApiWalletDigitalCredentialsRequest
          description: >-
            Nur request_digital_credential: die an die Wallet zu übergebende
            Anfrage.
        verification_code:
          type: string
          description: >-
            Nur confirm_in_app: Der 4-stellige Vergleichscode, den auch die
            Wallet-App anzeigt.
        poll_interval_seconds:
          type: integer
          description: >-
            Nur confirm_in_app: Wie oft POST
            .../verifications/{request_id}/poll/ für zeitnahes Feedback
            aufgerufen werden soll. Didit fragt ausstehende Anmeldungen auch im
            Hintergrund ab, sodass der Webhook das Ergebnis auch dann meldet,
            wenn Sie keine Abfragen durchführen.
      required:
        - type
    DigitalIdWalletApiWalletIdentity:
      type: object
      properties:
        full_name:
          type: string
          nullable: true
        first_name:
          type: string
          nullable: true
        last_name:
          type: string
          nullable: true
        date_of_birth:
          type: string
          format: date
          nullable: true
        nationality:
          type: string
          nullable: true
          description: >-
            ISO3-Staatsangehörigkeit, nur wenn die Wallet eine angibt (wird
            niemals abgeleitet).
        issuing_state:
          type: string
          description: ISO3-Land, dessen Schema die Identität ausgestellt hat.
      required:
        - date_of_birth
        - first_name
        - full_name
        - issuing_state
        - last_name
        - nationality
    DigitalIdWalletApiWalletNextActionTypeEnum:
      enum:
        - redirect
        - confirm_in_app
        - request_digital_credential
      type: string
      description: |-
        * `redirect` - redirect
        * `confirm_in_app` - confirm_in_app
        * `request_digital_credential` - request_digital_credential
    DigitalIdWalletApiWalletDigitalCredentialsRequest:
      type: object
      properties:
        protocol:
          type: string
          description: openid4vp-v1-signed.
        request:
          type: object
          additionalProperties: {}
          description: >-
            Unverändert übergeben: navigator.credentials.get({digital: request})
            im Browser oder JSON.stringify(request) als requestJson von
            GetDigitalCredentialOption auf Android. Von Didit für Ihre Anwendung
            signiert.
      required:
        - protocol
        - request
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        Der API-Schlüssel Ihrer Anwendung, aus Entwickler -> API-Schlüssel in
        der Business Console. Der Primärschlüssel hat Vollzugriff. Ein benannter
        Schlüssel kann im Geltungsbereich eingeschränkt werden: keine, Lese-
        oder Schreibberechtigung pro Ressource, beschränkt auf bestimmte
        Workflows oder genehmigte Sitzungen, auf eine Liste von IP-Adressen und
        auf ein Ablaufdatum. 401 bedeutet, dass der Schlüssel falsch, widerrufen
        oder abgelaufen ist; 403 bedeutet, dass kein Schlüssel gesendet wurde,
        der Schlüssel keinen Zugriff auf diese Ressource oder Aktion hat oder
        die Anfrage von einer Adresse außerhalb seiner IP-Liste stammte; 404 bei
        einer Sitzungsroute bedeutet, dass die Sitzung außerhalb der Workflows
        oder Status des Schlüssels liegt. Ein Schlüssel ohne Medienzugriff
        erhält Bild-, Video- und PDF-URLs als null, und ein Schlüssel ohne
        Schreibberechtigung für Sitzungen erhält Sitzungslinks und Token als
        null. Siehe https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: Das Client-Credentials-Zugriffstoken der Anwendung.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.