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

# Digital Credentials Wallet-Antwort senden

> Sende die Credential-Antwort der Wallet, etwa Google Wallet, an deine Seite oder App. Didit entscheidet anschließend über die Verifizierung.

Verwenden Sie diesen Vorgang für eine Wallet, deren Start-Antwort `next_action.type = request_digital_credential` enthält, etwa Google Wallet.
Authentifizieren Sie sich von Ihrem Backend aus mit dem Anwendungs-API-Schlüssel, mit dem die Verifizierung gestartet wurde.

Senden Sie genau das, was die Wallet zurückgegeben hat: `{protocol, data}` aus `navigator.credentials.get` im Browser oder das geparste `credentialJson` aus dem Android Credential Manager.
Die Antwort ist für Didit verschlüsselt. Verändern Sie sie daher nicht.
Didit prüft die Signatur des Ausstellers anhand seiner vertrauenswürdigen Root-Zertifikate, jeden zurückgegebenen Wert anhand seines signierten Digests sowie die Gerätesignatur über Ihren `origin` und diese Anfrage und entscheidet anschließend über die Verifizierung.

Eine Antwort kann nur einmal eingereicht werden.
Ein erneuter Einreichungsversuch liefert die bereits entschiedene Verifizierung zurück.
Eine Verifizierung, die keine Wallet-Antwort entgegennimmt, antwortet mit `409` und `error: "not_a_digital_credentials_wallet"`.

Die vollständige Abfolge, einschließlich der Snippets für Browser und Android, finden Sie unter [Digital-ID-Wallet-APIs](https://docs.didit.me/de/standalone-apis/digital-id-wallets.md#digital-credentials-wallets-google-wallet).


## OpenAPI

````yaml de/openapi-25.json POST /v3/id-verification/wallets/verifications/{request_id}/response/
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/verifications/{request_id}/response/:
    post:
      tags:
        - Digital ID wallets
      summary: Wallet-Antwort übermitteln
      description: >-
        Wallets der Digital Credentials API (Google Wallet): Senden Sie das, was
        die Wallet an Ihre Seite oder App zurückgegeben hat, für eine
        Verifizierung, deren next_action request_digital_credential ist. Didit
        entschlüsselt es, prüft die Signatur des Ausstellers anhand der
        vertrauenswürdigen Root-Zertifikate der Aussteller, jeden
        zurückgegebenen Wert anhand seines signierten Digests und die
        Gerätesignatur über Ihren Origin und diese Anfrage und entscheidet dann
        über die Verifizierung: verifiziert (einmalig abgerechnet) oder
        abgelehnt mit dem Fehlercode. Einmalige Verwendung: Eine zweite
        Übermittlung gibt die entschiedene Verifizierung zurück.
      operationId: submit_wallet_verification_response
      parameters:
        - in: path
          name: request_id
          schema:
            type: string
            format: uuid
          description: Die vom Start-Endpoint zurückgegebene request_id.
          required: true
      requestBody:
        content:
          application/json:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiWalletDigitalCredentialResponseRequest
            example:
              response:
                protocol: openid4vp-v1-signed
                data:
                  response: <compact JWE returned by the wallet>
          application/x-www-form-urlencoded:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiWalletDigitalCredentialResponseRequest
            example:
              response:
                protocol: openid4vp-v1-signed
                data:
                  response: <compact JWE returned by the wallet>
          multipart/form-data:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiWalletDigitalCredentialResponseRequest
            example:
              response:
                protocol: openid4vp-v1-signed
                data:
                  response: <compact JWE returned by the wallet>
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationResponse
              example:
                request_id: 00000000-0000-4000-8000-000000000001
                wallet_verification:
                  wallet:
                    id: google_wallet
                    name: Google Wallet
                    issuing_authority: >-
                      Google Wallet (ID pass) and US state issuers (mobile
                      driving licence)
                  country: USA
                  status: Approved
                  outcome: verified
                  error: null
                  interaction: digital_credentials
                  simulated: false
                  expires_at: '2026-01-01T10:10:00Z'
                  next_action: null
                  identity:
                    full_name: Alex Example
                    first_name: Alex
                    last_name: Example
                    date_of_birth: '1990-01-31'
                    nationality: USA
                    issuing_state: USA
                  attributes:
                    document_number: X0000000
                    document_expiry_date: '2030-01-31'
                  level_of_assurance: substantial
                  verified_at: '2026-01-01T10:01:00Z'
                  signature_valid: true
                  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]}).'
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiClientCredentialsForbiddenErrorMessage
          description: 'Fehlende Anmeldedaten (x-api-key oder Authorization: Bearer).'
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            Fehler not_found: Keine Wallet-Verifizierung dieser Anwendung hat
            diese request_id.
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            Fehler not_a_digital_credentials_wallet: Diese Verifizierung
            akzeptiert keine Wallet-Antwort.
        '503':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            Fehler wallet_not_configured: Diese Umgebung kann die Wallet nicht
            verifizieren.
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl --request POST \
              --url https://verification.didit.me/v3/id-verification/wallets/verifications/REQUEST_ID/response/ \
              --header 'x-api-key: YOUR_API_KEY' \
              --header 'Content-Type: application/json' \
              --data '{
              "response": {
                "protocol": "openid4vp-v1-signed",
                "data": {
                  "response": "<compact JWE returned by the wallet>"
                }
              }
            }'
components:
  schemas:
    DigitalIdWalletApiWalletDigitalCredentialResponseRequest:
      type: object
      description: >-
        Was die Wallet Ihrer Seite oder App für eine
        ``request_digital_credential``-Verifizierung geantwortet hat.
      properties:
        response:
          type: object
          additionalProperties: {}
          description: >-
            Genau das, was die Wallet zurückgegeben hat: {protocol, data} des
            DigitalCredential aus navigator.credentials.get oder das geparste
            credentialJson des DigitalCredential von Android. Für Didit
            verschlüsselt; verändern Sie es nicht.
      required:
        - response
    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'
    DigitalIdWalletApiClientCredentialsForbiddenErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Forbidden - User doesn't have permission
    DigitalIdWalletApiWalletVerificationError:
      type: object
      properties:
        error:
          type: string
          description: Stabiler maschinenlesbarer Code, z. B. wallet_unavailable.
        detail:
          type: string
      required:
        - detail
        - error
    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
    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.