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

# Google Wallet Ausweisverifizierung API

> Google Wallet Ausweisverifizierung mit Didit in Ihre Anwendung integrieren. Länder, Authentifizierungsschritte, Ergebnisse und Preise.

Starten Sie die Google-Wallet-ID-Verifizierung von Ihrem Backend aus mit dem API-Schlüssel Ihrer Anwendung.
Sie benötigen weder einen Workflow noch eine `workflow_id`.
Die Antwort beim Start beschreibt die nächste Authentifizierungsaktion; sie ist kein genehmigtes Identitätsergebnis.

## Abdeckung und Aktivierung

| Eigenschaft | Wert |
| - | - |
| Wallet | Google Wallet ID |
| Wallet-ID | `google_wallet` |
| Länder | ![](https://didit-public-assets.s3.eu-west-1.amazonaws.com/flags/us.svg)Vereinigte Staaten, ![](https://didit-public-assets.s3.eu-west-1.amazonaws.com/flags/gb.svg)Vereinigtes Königreich, ![](https://didit-public-assets.s3.eu-west-1.amazonaws.com/flags/br.svg)Brasilien, ![](https://didit-public-assets.s3.eu-west-1.amazonaws.com/flags/sg.svg)Singapur, ![](https://didit-public-assets.s3.eu-west-1.amazonaws.com/flags/tw.svg)Taiwan |
| Aktivierung der Wallet in der Produktion | ✅ Verfügbar |
| Veröffentlichter Wallet-Preis | \$0.20 pro abgeschlossene Verifizierung |

Die Aktivierung der Wallet ist unabhängig von der API-Bereitstellung und der Berechtigung Ihrer Anwendung.
Ein dokumentierter Endpoint aktiviert keine Wallet, die als Demnächst verfügbar gekennzeichnet ist.
Aktuelle veröffentlichte 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

Ihre Seite oder App fragt Google Wallet direkt ab: Es gibt keine Weiterleitung und keine von Didit gehostete Seite.
Übergeben Sie `next_action.digital_credentials.request` in einer Benutzeraktion auf dem `origin`, mit dem Sie gestartet haben, an `navigator.credentials.get({digital: request})`, oder an den Android Credential Manager als `GetDigitalCredentialOption`.
Senden Sie anschließend die Antwort der Wallet an [Wallet-Antwort übermitteln](https://docs.didit.me/de/standalone-apis/digital-id-wallet-response.md).
Der Browser bietet einen eigenen QR-Code an, wenn sich die Wallet auf einem anderen Gerät befindet.

## Ergebnis empfangen

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 nachzuverfolgen und ihr Ergebnis abzurufen.
Betrachten Sie nur ein abgeschlossenes, verifiziertes Ergebnis als Nachweis dafür, dass die 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/google-wallet/
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/google-wallet/:
    post:
      tags:
        - Digital ID wallets
      summary: Google Wallet-Verifizierung starten
      description: >-
        Starten Sie eine Google-Wallet-Anmeldung (Google Wallet (ID-Pass) und
        Aussteller in US-Bundesstaaten (mobiler Führerschein); USA, GBR, BRA,
        SGP, TWN) ohne Workflow. Die Abrechnung erfolgt einmalig, nur wenn die
        Identität verifiziert wurde. Die Antwort enthält
        next_action.type=request_digital_credential mit einer Anfrage, die Didit
        für Ihre Anwendung signiert hat und die nur von origin aus verwendet
        werden kann. Übergeben Sie dort bei einer Benutzeraktion
        next_action.digital_credentials.request an
        navigator.credentials.get({digital: ...}) (oder an den Android
        Credential Manager als GetDigitalCredentialOption requestJson) und
        senden Sie anschließend die Rückgabe der Wallet per POST an
        /v3/id-verification/wallets/verifications/{request_id}/response/. Der
        Browser bietet einen eigenen QR-Code an, wenn sich die Wallet auf einem
        anderen Gerät befindet. Sandbox-Anwendungen erhalten eine
        deterministische Simulation (simulated: true), die niemals den Anbieter
        kontaktiert.
      operationId: start_google_wallet_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/DigitalIdWalletApiGoogleWalletWalletVerificationStartRequest
            example:
              country: USA
              vendor_data: your-customer-reference
              metadata:
                reference: example
              origin: https://app.example.com
          application/x-www-form-urlencoded:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiGoogleWalletWalletVerificationStartRequest
          multipart/form-data:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiGoogleWalletWalletVerificationStartRequest
        required: true
      responses:
        '201':
          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: Not Finished
                  outcome: pending
                  error: null
                  interaction: digital_credentials
                  simulated: false
                  expires_at: '2026-01-01T10:10:00Z'
                  next_action:
                    type: request_digital_credential
                    digital_credentials:
                      protocol: openid4vp-v1-signed
                      request:
                        requests:
                          - protocol: openid4vp-v1-signed
                            data:
                              request: <compact JWS signed by Didit>
                  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, origin_invalid,
            origin_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/google-wallet/ \
              --header 'x-api-key: YOUR_API_KEY' \
              --header 'Idempotency-Key: your-unique-attempt-key' \
              --header 'Content-Type: application/json' \
              --data '{
              "country": "USA",
              "vendor_data": "your-customer-reference",
              "metadata": {
                "reference": "example"
              },
              "origin": "https://app.example.com"
            }'
components:
  schemas:
    DigitalIdWalletApiGoogleWalletWalletVerificationStartRequest:
      type: object
      description: Starten Sie eine Google-Wallet-Verifizierung (USA, GBR, BRA, SGP, TWN).
      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/DigitalIdWalletApiGoogleWalletWalletVerificationStartCountryEnum
          description: |-
            ISO 3166-1-Alpha-3-Land der Google Wallet-Identität.

            * `USA` - USA
            * `GBR` - GBR
            * `BRA` - BRA
            * `SGP` - SGP
            * `TWN` - TWN
        origin:
          type: string
          minLength: 1
          description: >-
            Wo Ihre Seite oder App die Wallet anfragt: der https-Origin Ihrer
            Seite (sein Host muss in den allowed_return_hosts der Anwendung
            enthalten sein oder deren White-Label-Domain sein), z. B.
            https://app.example.com, oder android:apk-key-hash:<base64 SHA-256
            des Signaturzertifikats Ihrer App, ohne Padding>. Die Wallet lehnt
            die Anfrage überall sonst ab.
          maxLength: 256
      required:
        - country
        - origin
    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
    DigitalIdWalletApiGoogleWalletWalletVerificationStartCountryEnum:
      enum:
        - USA
        - GBR
        - BRA
        - SGP
        - TWN
      type: string
      description: |-
        * `USA` - USA
        * `GBR` - GBR
        * `BRA` - BRA
        * `SGP` - SGP
        * `TWN` - TWN
    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.