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

# Soumettre une réponse de portefeuille Digital Credentials

> Envoyez à Didit la réponse d'identifiant du portefeuille Digital Credentials API (ex. Google Wallet) et laissez Didit statuer sur la vérification.

Utilisez cette opération pour un portefeuille dont la réponse de démarrage contient `next_action.type = request_digital_credential`, par exemple Google Wallet.
Authentifiez-vous depuis votre backend avec la clé API de l'application qui a démarré la vérification.

Envoyez exactement ce que le portefeuille a renvoyé : `{protocol, data}` issu de `navigator.credentials.get` dans le navigateur, ou le `credentialJson` analysé provenant d'Android Credential Manager.
La réponse est chiffrée à destination de Didit, ne la modifiez donc pas.
Didit vérifie la signature de l'émetteur par rapport à ses racines de confiance des émetteurs, chaque valeur renvoyée par rapport à son empreinte signée, et la signature de l'appareil sur votre `origin` et sur cette requête, puis statue sur la vérification.

Une réponse du portefeuille ne peut être soumise qu'une seule fois.
Une seconde soumission renvoie la vérification déjà décidée.
Une vérification qui n'accepte pas de réponse de portefeuille renvoie une réponse `409` avec `error: "not_a_digital_credentials_wallet"`.

Consultez [Digital ID wallet APIs](https://docs.didit.me/fr/standalone-apis/digital-id-wallets.md#portefeuilles-digital-credentials-google-wallet) pour la séquence complète, y compris les extraits pour le navigateur et Android.


## OpenAPI

````yaml fr/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 de vérification d'identité. Authentifiez-vous avec l'en-tête x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/id-verification/wallets/verifications/{request_id}/response/:
    post:
      tags:
        - Digital ID wallets
      summary: Soumettre une réponse de portefeuille
      description: >-
        Portefeuilles de l'API Digital Credentials (Google Wallet) : envoyez ce
        que le portefeuille a renvoyé à votre page ou application pour une
        vérification dont la next_action est request_digital_credential. Didit
        le déchiffre, vérifie la signature de l'émetteur par rapport aux racines
        d'émetteurs de confiance, chaque valeur renvoyée par rapport à son
        empreinte signée, ainsi que la signature de l'appareil sur votre origine
        et cette requête, puis statue sur la vérification : vérifiée (facturée
        une fois) ou refusée avec le code d'erreur. Usage unique : une deuxième
        soumission renvoie la vérification décidée.
      operationId: submit_wallet_verification_response
      parameters:
        - in: path
          name: request_id
          schema:
            type: string
            format: uuid
          description: Le request_id renvoyé par l'endpoint de démarrage.
          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: 'Erreurs de validation de champ ({field: [messages]}).'
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiClientCredentialsForbiddenErrorMessage
          description: 'Identifiants manquants (x-api-key ou Authorization: Bearer).'
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: "erreur not_found\_: aucune vérification de portefeuille de cette application ne possède ce request_id."
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: "erreur not_a_digital_credentials_wallet\_: cette vérification n'accepte pas de réponse de portefeuille."
        '503':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: "erreur wallet_not_configured\_: cet environnement ne peut pas vérifier le portefeuille."
      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: >-
        Ce que le portefeuille a répondu à votre page ou application, pour une
        vérification ``request_digital_credential``.
      properties:
        response:
          type: object
          additionalProperties: {}
          description: >-
            Exactement ce que le portefeuille a renvoyé : {protocol, data} du
            DigitalCredential issu de navigator.credentials.get, ou le
            credentialJson analysé du DigitalCredential d'Android. Chiffré pour
            Didit ; ne le modifiez pas.
      required:
        - response
    DigitalIdWalletApiWalletVerificationResponse:
      type: object
      description: >-
        Une vérification de portefeuille autonome, telle que renvoyée par chaque
        endpoint de portefeuille.
      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: L'objet de métadonnées envoyé au démarrage, ou 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: Code stable lisible par machine, par exemple 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: >-
            Non terminé tant qu'il est en attente, puis Approuvé (vérifié) ou
            Refusé.
        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: >-
            Vrai dès que la signature de l'attestation a été vérifiée ; null
            pour une attestation simulée.
        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: >-
        Erreurs de validation de la requête : chaque champ rejeté avec ses
        messages.
      additionalProperties:
        type: array
        items:
          type: string
    DigitalIdWalletApiWallet:
      type: object
      properties:
        id:
          type: string
          description: Identifiant de catalogue du portefeuille, par exemple 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` - En attente
        * `verified` - Vérifié
        * `cancelled` - Annulé par l'utilisateur
        * `timeout` - Délai d'attente dépassé
        * `failed` - Échoué
    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 : redirigez le navigateur de l'utilisateur vers url.
            confirm_in_app : affichez verification_code à l'utilisateur, qui
            vérifie qu'il correspond au code dans son application de
            portefeuille et confirme là-bas ; puis interrogez.
            request_digital_credential : lors d'un geste utilisateur sur
            l'origine initiale, interrogez le portefeuille avec
            digital_credentials.request, puis envoyez ce qu'il renvoie à POST
            .../verifications/{request_id}/response/.


            * `redirect` - redirect

            * `confirm_in_app` - confirm_in_app

            * `request_digital_credential` - request_digital_credential
        url:
          type: string
          format: uri
          description: >-
            redirect uniquement : là où l'utilisateur se connecte avec le
            portefeuille.
        digital_credentials:
          allOf:
            - $ref: >-
                #/components/schemas/DigitalIdWalletApiWalletDigitalCredentialsRequest
          description: >-
            request_digital_credential uniquement : la requête à transmettre au
            portefeuille.
        verification_code:
          type: string
          description: "confirm_in_app uniquement\_: le code de comparaison à 4 chiffres que l'application de portefeuille affiche également."
        poll_interval_seconds:
          type: integer
          description: "confirm_in_app uniquement\_: fréquence d'appel de POST .../verifications/{request_id}/poll/ pour un retour rapide. Didit interroge également les connexions en attente en arrière-plan, de sorte que le webhook signale le résultat même si vous n'effectuez pas de scrutation."
      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: >-
            Nationalité ISO3, uniquement lorsque le portefeuille en atteste une
            (jamais déduite).
        issuing_state:
          type: string
          description: Pays ISO3 dont le système a délivré l'identité.
      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: "Transmettez tel quel\_: navigator.credentials.get({digital: request}) dans le navigateur, ou JSON.stringify(request) comme requestJson de GetDigitalCredentialOption sur Android. Signé par Didit pour votre application."
      required:
        - protocol
        - request
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clé API de votre application, issue de Développeurs -> Clés API dans
        la Business Console. La clé principale dispose d'un accès complet. Une
        clé nommée peut être restreinte : aucun, lecture ou écriture par
        ressource, limitée à certains workflows ou aux sessions approuvées, à
        une liste d'adresses IP et à une date d'expiration. 401 signifie que la
        clé est incorrecte, révoquée ou expirée ; 403 signifie qu'aucune clé n'a
        été envoyée, que la clé n'a pas accès à cette ressource ou action, ou
        que la requête provient d'une adresse hors de sa liste d'IP ; 404 sur
        une route de session signifie que la session est hors des workflows ou
        des statuts de la clé. Une clé sans accès aux médias reçoit les URL
        d'images, de vidéos et de PDF à null, et une clé sans accès en écriture
        aux sessions reçoit les liens et tokens de session à null. Voir
        https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: Le token d'accès client-credentials de l'application.

````

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