> ## 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 जैसे डिजिटल क्रेडेंशियल वॉलेट से मिला क्रेडेंशियल रिस्पॉन्स अपने पेज या ऐप से भेजें, और सत्यापन का निर्णय Didit करेगा।

उस वॉलेट के लिए इस ऑपरेशन का उपयोग करें जिसके स्टार्ट रिस्पॉन्स में `next_action.type = request_digital_credential` हो, जैसे Google Wallet।
अपने बैकएंड से, उस एप्लिकेशन API कुंजी से प्रमाणित करें जिससे सत्यापन शुरू हुआ था।

वही भेजें जो वॉलेट ने लौटाया: ब्राउज़र में `navigator.credentials.get` से मिला `{protocol, data}`, या Android Credential Manager से मिला पार्स किया हुआ `credentialJson`।
रिस्पॉन्स Didit के लिए एन्क्रिप्टेड है, इसलिए उसमें बदलाव न करें।
Didit जारीकर्ता के हस्ताक्षर की जाँच उसकी भरोसेमंद जारीकर्ता रूट सूची से करता है, लौटाए गए हर मान की जाँच उसके हस्ताक्षरित डाइजेस्ट से करता है, और आपके `origin` तथा इस अनुरोध पर डिवाइस हस्ताक्षर की जाँच करता है, फिर सत्यापन का निर्णय लेता है।

एक रिस्पॉन्स केवल एक बार सबमिट किया जा सकता है।
दूसरी बार सबमिट करने पर वह सत्यापन लौटता है जिसका निर्णय पहले ही हो चुका है।
जो सत्यापन वॉलेट रिस्पॉन्स नहीं लेता, उसके लिए `409` लौटता है, जिसमें `error: "not_a_digital_credentials_wallet"` होता है।

पूरा क्रम देखने के लिए, जिसमें ब्राउज़र और Android के स्निपेट भी शामिल हैं, [डिजिटल ID वॉलेट API](https://docs.didit.me/hi/standalone-apis/digital-id-wallets.md#digital-credentials-वॉलेट-google-wallet) देखें।


## OpenAPI

````yaml hi/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। 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: एक वॉलेट रिस्पॉन्स सबमिट करें
      description: >-
        Digital Credentials API वॉलेट्स (Google Wallet): ऐसे सत्यापन के लिए
        जिसका next_action request_digital_credential है, वॉलेट द्वारा आपके पेज
        या ऐप पर लौटाया गया डेटा भेजें। Didit इसे डिक्रिप्ट करता है, विश्वसनीय
        जारीकर्ता रूट्स के विरुद्ध जारीकर्ता के हस्ताक्षर की जाँच करता है,
        प्रत्येक लौटाए गए मान की उसके हस्ताक्षरित डाइजेस्ट के विरुद्ध जाँच करता
        है, और आपके मूल (origin) और इस अनुरोध पर डिवाइस हस्ताक्षर की जाँच करता
        है, फिर सत्यापन का निर्णय लेता है: सत्यापित (एक बार बिल किया गया) या
        त्रुटि कोड के साथ अस्वीकृत। एकल उपयोग: दूसरा सबमिशन निर्णय लिए गए
        सत्यापन को लौटाता है।
      operationId: submit_wallet_verification_response
      parameters:
        - in: path
          name: request_id
          schema:
            type: string
            format: uuid
          description: वह request_id जो start endpoint ने लौटाया था।
          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: 'फ़ील्ड सत्यापन त्रुटियाँ ({field: [messages]})।'
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiClientCredentialsForbiddenErrorMessage
          description: 'क्रेडेंशियल मौजूद नहीं हैं (x-api-key या Authorization: Bearer)।'
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            त्रुटि not_found: इस एप्लिकेशन के किसी भी वॉलेट सत्यापन में यह
            request_id नहीं है।
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            त्रुटि not_a_digital_credentials_wallet: यह सत्यापन वॉलेट रिस्पॉन्स
            नहीं लेता है।
        '503':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            त्रुटि wallet_not_configured: यह एनवायरनमेंट वॉलेट को सत्यापित नहीं
            कर सकता।
      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: >-
        `request_digital_credential` सत्यापन के लिए, वॉलेट ने आपके पेज या ऐप को
        क्या उत्तर दिया।
      properties:
        response:
          type: object
          additionalProperties: {}
          description: >-
            वॉलेट द्वारा ठीक वही लौटाया गया: navigator.credentials.get से
            DigitalCredential का {protocol, data}, या Android के
            DigitalCredential का पार्स किया गया credentialJson। Didit के लिए
            एन्क्रिप्ट किया गया; इसे न बदलें।
      required:
        - response
    DigitalIdWalletApiWalletVerificationResponse:
      type: object
      description: >-
        एक स्टैंडअलोन वॉलेट सत्यापन, जैसा कि प्रत्येक वॉलेट endpoint उत्तर देता
        है।
      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: शुरुआत में भेजा गया मेटाडेटा ऑब्जेक्ट, या 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: मशीन द्वारा पठनीय स्थिर कोड, उदाहरण के लिए 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: >-
            लंबित रहने के दौरान समाप्त नहीं हुआ (Not Finished), फिर स्वीकृत
            (सत्यापित) या अस्वीकृत।
        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; सिम्युलेटेड के
            लिए null।
        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: 'अनुरोध सत्यापन त्रुटियाँ: प्रत्येक अस्वीकृत फ़ील्ड अपने संदेशों के साथ।'
      additionalProperties:
        type: array
        items:
          type: string
    DigitalIdWalletApiWallet:
      type: object
      properties:
        id:
          type: string
          description: वॉलेट का कैटलॉग id, उदा. 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` - लंबित
        * `verified` - सत्यापित
        * `cancelled` - उपयोगकर्ता द्वारा रद्द किया गया
        * `timeout` - टाइम आउट
        * `failed` - विफल
    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: उपयोगकर्ता के ब्राउज़र को url पर भेजें। confirm_in_app:
            उपयोगकर्ता को verification_code दिखाएं, जो जांचता है कि यह उनके
            वॉलेट ऐप के कोड से मेल खाता है और वहां पुष्टि करता है; फिर पोल करें।
            request_digital_credential: जिस ऑरिजिन से आपने शुरुआत की थी, उस पर
            उपयोगकर्ता जेस्चर में, digital_credentials.request के साथ वॉलेट से
            अनुरोध करें, फिर जो यह लौटाता है उसे 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: जहां उपयोगकर्ता वॉलेट से साइन इन करता है।'
        digital_credentials:
          allOf:
            - $ref: >-
                #/components/schemas/DigitalIdWalletApiWalletDigitalCredentialsRequest
          description: 'केवल request_digital_credential: वॉलेट को सौंपने का अनुरोध।'
        verification_code:
          type: string
          description: 'केवल confirm_in_app: 4-अंकीय तुलना कोड जिसे वॉलेट ऐप भी दिखाता है।'
        poll_interval_seconds:
          type: integer
          description: >-
            केवल confirm_in_app: त्वरित फ़ीडबैक के लिए कितनी बार POST
            .../verifications/{request_id}/poll/ को कॉल करना है। Didit पृष्ठभूमि
            में लंबित साइन-इन को भी पोल करता है, इसलिए यदि आप पोल नहीं करते हैं
            तब भी webhook परिणाम की रिपोर्ट करता है।
      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 राष्ट्रीयता, केवल तभी जब वॉलेट किसी राष्ट्रीयता का दावा करता है
            (कभी अनुमान नहीं लगाया जाता)।
        issuing_state:
          type: string
          description: ISO3 देश जिसकी प्रणाली के अंतर्गत पहचान जारी की गई है।
      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: >-
            यथावत पास करें: ब्राउज़र में navigator.credentials.get({digital:
            request}), या Android पर GetDigitalCredentialOption के requestJson
            के रूप में JSON.stringify(request)। आपके एप्लिकेशन के लिए Didit
            द्वारा हस्ताक्षरित।
      required:
        - protocol
        - request
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        आपकी एप्लिकेशन की API कुंजी, Business Console में Developers -> API keys
        से। प्राथमिक कुंजी के पास पूर्ण एक्सेस होता है। एक नामित कुंजी को स्कोप
        किया जा सकता है: प्रति संसाधन none, read या write, कुछ वर्कफ़्लो या
        स्वीकृत सत्रों तक सीमित, IP पतों की सूची तक सीमित, और समाप्ति तिथि तक
        सीमित। 401 का अर्थ है कि कुंजी गलत है, निरस्त कर दी गई है या उसकी
        समय-सीमा समाप्त हो गई है; 403 का अर्थ है कि कोई कुंजी नहीं भेजी गई थी,
        कुंजी के पास इस संसाधन या कार्रवाई का एक्सेस नहीं है, या अनुरोध उसकी IP
        सूची से बाहर के पते से आया था; सत्र रूट पर 404 का अर्थ है कि सत्र कुंजी
        के वर्कफ़्लो या स्थितियों से बाहर है। मीडिया एक्सेस के बिना एक कुंजी को
        छवि, वीडियो और PDF URL null के रूप में प्राप्त होते हैं, और सत्र write
        के बिना एक कुंजी को सत्र लिंक और token null के रूप में प्राप्त होते हैं।
        देखें https://docs.didit.me/console/api-keys।
    BearerAuth:
      type: http
      scheme: bearer
      description: एप्लिकेशन का क्लाइंट-क्रेडेंशियल एक्सेस टोकन।

````

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