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

# डिजिटल ID वॉलेट API कैटलॉग

> Didit के डिजिटल ID वॉलेट endpoints खोजें, जिनमें आपके एप्लिकेशन के लिए देश-वार कवरेज, आवश्यक इनपुट और उपलब्धता शामिल हैं।

इस प्रमाणीकृत कैटलॉग का उपयोग करके हर वॉलेट का शुरुआती endpoint, समर्थित देश और आवश्यक इनपुट खोजें।
`available` फ़ील्ड उस एप्लिकेशन पर लागू होता है जिसकी पहचान आपकी API कुंजी से होती है, और उस एनवायरनमेंट पर जिसे आप कॉल कर रहे हैं।
केवल वही वॉलेट दिखाएँ जो उस एप्लिकेशन के लिए उपलब्ध हैं और व्यक्ति द्वारा चुने गए देश का समर्थन करते हैं।
सत्यापन शुरू करते समय इनपुट वैलिडेशन, क्रेडिट आवश्यकताएँ और लागू अनुबंध दरों की जाँच अब भी की जाती है।

कोई वॉलेट तब भी सूची में हो सकता है जब उसका `available` मान `false` हो।
कैटलॉग उसे सक्रिय नहीं करता और उसकी प्रोडक्शन आवश्यकताओं को अधिभावी नहीं करता।
सैंडबॉक्स एप्लिकेशन ऐसे वॉलेट का सिमुलेशन कर सकते हैं जो अभी लाइव प्रमाणीकरण के लिए उपलब्ध नहीं हैं।

सत्यापन शुरू करने और परिणाम प्राप्त करने के लिए [वॉलेट API इंटीग्रेशन गाइड](https://docs.didit.me/hi/standalone-apis/digital-id-wallets.md) देखें।


## OpenAPI

````yaml hi/openapi-25.json GET /v3/id-verification/wallets/
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/:
    get:
      tags:
        - Digital ID wallets
      summary: डिजिटल ID वॉलेट सूचीबद्ध करें
      description: >-
        प्रत्येक Digital ID वॉलेट अपने स्टार्ट endpoint, देशों, आवश्यक फ़ील्ड और
        क्या यह एप्लिकेशन अभी इस एनवायरनमेंट में इसे शुरू कर सकता है, के साथ।
        सूचीबद्ध होने का अर्थ लाइव होना नहीं है।
      operationId: list_wallets
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletCatalogResponse'
          description: ''
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiClientCredentialsForbiddenErrorMessage
          description: 'क्रेडेंशियल मौजूद नहीं हैं (x-api-key या Authorization: Bearer)।'
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl --request GET \
              --url https://verification.didit.me/v3/id-verification/wallets/ \
              --header 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.id_wallets.list()
            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.list();
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.IDWallets.List(ctx)\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: |-
            import me.didit.Didit;

            // Reads DIDIT_API_KEY.
            Didit client = new Didit();

            var result = client.idWallets().list();
            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->list();
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.id_wallets.list
            puts result.to_h
        - lang: csharp
          label: .NET
          source: |-
            using System;
            using System.Text.Json;
            using Didit;

            // Reads DIDIT_API_KEY.
            using var client = new DiditClient();

            var result = await client.IdWallets.ListAsync();
            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    DigitalIdWalletApiWalletCatalogResponse:
      type: object
      properties:
        wallets:
          type: array
          items:
            $ref: '#/components/schemas/DigitalIdWalletApiWalletCatalogEntry'
      required:
        - wallets
    DigitalIdWalletApiClientCredentialsForbiddenErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Forbidden - User doesn't have permission
    DigitalIdWalletApiWalletCatalogEntry:
      type: object
      properties:
        id:
          type: string
        name:
          type: string
        path:
          type: string
          description: वॉलेट का अपना आरंभिक endpoint।
        countries:
          type: array
          items:
            type: string
        issuing_authority:
          type: string
        level_of_assurance:
          type: string
          nullable: true
        interaction:
          $ref: '#/components/schemas/DigitalIdWalletApiInteractionEnum'
        required_fields:
          type: array
          items:
            type: string
        available:
          type: boolean
          description: >-
            क्या यह एप्लिकेशन इसे इस एनवायरनमेंट में अभी शुरू कर सकता है।
            लिस्टेड होने का मतलब लाइव होना नहीं है।
      required:
        - available
        - countries
        - id
        - interaction
        - issuing_authority
        - level_of_assurance
        - name
        - path
        - required_fields
    DigitalIdWalletApiInteractionEnum:
      enum:
        - redirect
        - in_app
        - digital_credentials
      type: string
      description: |-
        * `redirect` - redirect
        * `in_app` - in_app
        * `digital_credentials` - digital_credentials
  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.