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

# gov.br पहचान सत्यापन API

> Didit के साथ gov.br पहचान सत्यापन को अपने एप्लिकेशन में इंटीग्रेट करें। देश कवरेज, प्रमाणीकरण चरण, परिणाम और मूल्य निर्धारण देखें।

अपने बैकएंड से अपनी एप्लिकेशन की API कुंजी का उपयोग करके gov.br सत्यापन शुरू करें।
आपको वर्कफ़्लो या `workflow_id` की आवश्यकता नहीं है।
प्रारंभिक रिस्पॉन्स अगली प्रमाणीकरण कार्रवाई का वर्णन करता है; यह स्वीकृत पहचान परिणाम नहीं है।

## कवरेज और सक्रियण

| गुण | मान |
| - | - |
| वॉलेट | gov.br |
| वॉलेट ID | `govbr` |
| देश | ![](https://didit-public-assets.s3.eu-west-1.amazonaws.com/flags/br.svg)ब्राज़ील |
| प्रोडक्शन वॉलेट सक्रियण | ⏳ जल्द आ रहा है |
| प्रकाशित वॉलेट कीमत | जल्द आ रहा है |

वॉलेट सक्रियण API डिप्लॉयमेंट और आपके एप्लिकेशन की पात्रता से अलग है।
कोई प्रलेखित endpoint उस वॉलेट को सक्रिय नहीं करता जिसे “जल्द उपलब्ध होगा” के रूप में चिह्नित किया गया है।
वर्तमान प्रकाशित दरों के लिए, [डिजिटल ID वॉलेट मूल्य निर्धारण](https://docs.didit.me/hi/getting-started/pricing.md#डिजिटल-id-वॉलेट-मूल्य-निर्धारण) देखें।

## व्यक्ति क्या करता है

प्रारंभिक अनुरोध द्वारा लौटाई गई अगली कार्रवाई का पालन करें।
यह वॉलेट के प्रमाणीकरण अनुभव पर निर्भर करता है कि व्यक्ति ब्राउज़र, किसी दूसरे डिवाइस या ऐप का उपयोग करेगा।

## परिणाम प्राप्त करें

सत्यापन को ट्रैक करने और उसका परिणाम प्राप्त करने के लिए [डिजिटल ID वॉलेट API गाइड](https://docs.didit.me/hi/standalone-apis/digital-id-wallets.md) का पालन करें।
केवल पूर्ण और सत्यापित परिणाम को ही इस बात का प्रमाण मानें कि वॉलेट ने व्यक्ति का प्रमाणीकरण किया है।
लौटाई गई पहचान विशेषताएँ वॉलेट के अनुसार अलग होती हैं; यह न मानें कि पता, चेहरे की तस्वीर या अनुरोध की गई हर विशेषता मौजूद है।

## संबंधित

* [डिजिटल ID वॉलेट APIs](https://docs.didit.me/hi/standalone-apis/digital-id-wallets.md)
* [वॉलेट कवरेज और विशेषताएँ](https://docs.didit.me/hi/core-technology/id-verification/digital-id-wallets.md)
* [मूल्य निर्धारण](https://docs.didit.me/hi/getting-started/pricing.md#डिजिटल-id-वॉलेट-मूल्य-निर्धारण)


## OpenAPI

````yaml hi/openapi-25.json POST /v3/id-verification/wallets/govbr/
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/govbr/:
    post:
      tags:
        - Digital ID wallets
      summary: gov.br सत्यापन शुरू करें
      description: >-
        किसी भी वर्कफ़्लो के बिना gov.br साइन-इन (Governo Federal do Brasil;
        BRA) शुरू करें। बिलिंग केवल एक बार की जाती है, केवल तब जब पहचान सत्यापित
        हो जाती है। रिस्पॉन्स में next_action.type=redirect के साथ वह URL होता
        है जिस पर उपयोगकर्ता के ब्राउज़र को भेजना है; उपयोगकर्ता return_url पर
        request_id और result जुड़ने के बाद वापस लौटता है। परिणाम को GET
        /v3/id-verification/wallets/verifications/{request_id}/ से या webhook से
        पढ़ें, URL से कभी नहीं। सैंडबॉक्स एप्लिकेशन को एक नियतात्मक सिमुलेशन
        (simulated: true) मिलता है जो प्रदाता से कभी संपर्क नहीं करता है।
      operationId: start_govbr_wallet_verification
      parameters:
        - in: header
          name: Idempotency-Key
          schema:
            type: string
          description: >-
            वैकल्पिक पुनः प्रयास-सुरक्षा कुंजी (अधिकतम 255 वर्ण)। समान कुंजी,
            वॉलेट और बॉडी के साथ पुनः प्रयास करने पर दूसरा साइन-इन शुरू किए बिना
            मूल सत्यापन वापस मिलता है; किसी अन्य वॉलेट या बॉडी के साथ समान कुंजी
            409 idempotency_key_reused लौटाती है।
      requestBody:
        content:
          application/json:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiGovbrWalletVerificationStartRequest
            example:
              country: BRA
              vendor_data: your-customer-reference
              metadata:
                reference: example
              return_url: https://app.example.com/identity/complete
          application/x-www-form-urlencoded:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiGovbrWalletVerificationStartRequest
          multipart/form-data:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiGovbrWalletVerificationStartRequest
        required: true
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationResponse
              example:
                request_id: 00000000-0000-4000-8000-000000000001
                wallet_verification:
                  wallet:
                    id: govbr
                    name: gov.br
                    issuing_authority: Governo Federal do Brasil
                  country: BRA
                  status: Not Finished
                  outcome: pending
                  error: null
                  interaction: redirect
                  simulated: false
                  expires_at: '2026-01-01T10:10:00Z'
                  next_action:
                    type: redirect
                    url: https://wallet.example.com/authorize
                  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: >-
            फ़ील्ड सत्यापन त्रुटियाँ ({field: [messages]}), या त्रुटि
            return_url_invalid, return_url_not_allowed, invalid_personal_code,
            invalid_phone_number या idempotency_key_invalid।
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationStartForbidden
          description: >-
            क्रेडेंशियल मौजूद नहीं हैं ({detail}), या त्रुटि wallet_unavailable,
            insufficient_credits या contract_rate_missing।
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            त्रुटि idempotency_key_reused या idempotency_key_in_progress
            (Retry-After के साथ)।
        '502':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            त्रुटि wallet_provider_unavailable: प्रदाता प्रारंभ नहीं हो सका; कुछ
            भी नहीं बनाया गया था।
        '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/govbr/ \
              --header 'x-api-key: YOUR_API_KEY' \
              --header 'Idempotency-Key: your-unique-attempt-key' \
              --header 'Content-Type: application/json' \
              --data '{
              "country": "BRA",
              "vendor_data": "your-customer-reference",
              "metadata": {
                "reference": "example"
              },
              "return_url": "https://app.example.com/identity/complete"
            }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.id_wallets.start_govbr(
                vendor_data="your-customer-reference",
                metadata={"reference": "example"},
                country="BRA",
                return_url="https://app.example.com/identity/complete",
            )
            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.startGovbr({
              vendor_data: "your-customer-reference",
              metadata: { reference: "example" },
              country: "BRA",
              return_url: "https://app.example.com/identity/complete",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.IDWallets.StartGovbr(ctx, didit.IDWalletsStartGovbrParams{\n\tBody: didit.DigitalIDWalletAPIGovbrWalletVerificationStartRequest{\n\t\tVendorData: didit.String(\"your-customer-reference\"),\n\t\tMetadata:   didit.Some(map[string]any{\"reference\": \"example\"}),\n\t\tCountry:    didit.Some(didit.DigitalIDWalletAPIGovbrWalletVerificationStartCountryEnum(\"BRA\")),\n\t\tReturnURL:  \"https://app.example.com/identity/complete\",\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.Map;

            import me.didit.Didit;

            import
            me.didit.types.DigitalIdWalletApiGovbrWalletVerificationStartCountryEnum;

            import
            me.didit.types.DigitalIdWalletApiGovbrWalletVerificationStartRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.idWallets().startGovbr(DigitalIdWalletApiGovbrWalletVerificationStartRequest.builder()
                    .vendorData("your-customer-reference")
                    .metadata(Map.of("reference", "example"))
                    .country(DigitalIdWalletApiGovbrWalletVerificationStartCountryEnum.of("BRA"))
                    .returnUrl("https://app.example.com/identity/complete")
                    .build());
            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->startGovbr([
                'vendor_data' => 'your-customer-reference',
                'metadata' => ['reference' => 'example'],
                'country' => 'BRA',
                'return_url' => 'https://app.example.com/identity/complete',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.id_wallets.start_govbr(
              vendor_data: "your-customer-reference",
              metadata: { reference: "example" },
              country: "BRA",
              return_url: "https://app.example.com/identity/complete"
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Collections.Generic;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await client.IdWallets.StartGovbrAsync(new
            DigitalIdWalletApiGovbrWalletVerificationStartRequest

            {
                VendorData = "your-customer-reference",
                Metadata = new Dictionary<string, object> { ["reference"] = "example" },
                Country = new DigitalIdWalletApiGovbrWalletVerificationStartCountryEnum("BRA"),
                ReturnUrl = "https://app.example.com/identity/complete",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    DigitalIdWalletApiGovbrWalletVerificationStartRequest:
      type: object
      description: gov.br सत्यापन (BRA) शुरू करें।
      properties:
        vendor_data:
          type: string
          nullable: true
          description: >-
            इस सत्यापन के लिए आपका अपना संदर्भ (उदा. आपका उपयोगकर्ता id)।
            परिणामों और webhooks में वापस किया जाता है।
        metadata:
          type: object
          additionalProperties: {}
          nullable: true
          description: >-
            सत्यापन के साथ संग्रहीत और परिणामों तथा webhook में लौटाया गया
            वैकल्पिक JSON ऑब्जेक्ट।
        sandbox_scenario:
          type: string
          minLength: 1
          description: >-
            केवल सैंडबॉक्स एप्लिकेशन्स: सिम्युलेटेड परिणाम - 'wallet_cancelled',
            'wallet_timeout' या 'wallet_provider_error'; कोई अन्य परिदृश्य (या
            कोई नहीं) सत्यापित करता है। लाइव एप्लिकेशन्स पर अस्वीकृत। पूरा
            कैटलॉग GET /v1/sandbox/scenarios/ पर उपलब्ध है।
        country:
          allOf:
            - $ref: >-
                #/components/schemas/DigitalIdWalletApiGovbrWalletVerificationStartCountryEnum
          default: BRA
          description: >-
            gov.br पहचान का ISO 3166-1 alpha-3 देश। डिफ़ॉल्ट रूप से BRA होता है,
            जो एकमात्र ऐसा देश है जिसे यह सेवा प्रदान करता है।


            * `BRA` - BRA
        return_url:
          type: string
          format: uri
          minLength: 1
          description: >-
            https URL जिस पर वॉलेट के बाद उपयोगकर्ता का ब्राउज़र वापस आता है,
            जिसमें request_id और result जुड़े होते हैं। इसका होस्ट एप्लिकेशन के
            allowed_return_hosts में पंजीकृत होना चाहिए (या इसका व्हाइट लेबल
            डोमेन होना चाहिए)। कभी भी केवल result पर भरोसा न करें: GET
            .../verifications/{request_id}/ या webhook से परिणाम पढ़ें।
          maxLength: 2048
        device:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiDeviceEnum'
          default: same_device
          description: >-
            same_device जब उपयोगकर्ता आपका पेज दिखाने वाले डिवाइस पर साइन इन
            करता है, cross_device जब वे किसी अन्य डिवाइस का उपयोग करते हैं (जैसे
            BankID का QR कोड)।


            * `same_device` - same_device

            * `cross_device` - cross_device
      required:
        - return_url
    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'
    DigitalIdWalletApiWalletVerificationStartForbidden:
      oneOf:
        - $ref: >-
            #/components/schemas/DigitalIdWalletApiClientCredentialsForbiddenErrorMessage
        - $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
    DigitalIdWalletApiWalletVerificationError:
      type: object
      properties:
        error:
          type: string
          description: मशीन द्वारा पठनीय स्थिर कोड, उदाहरण के लिए wallet_unavailable।
        detail:
          type: string
      required:
        - detail
        - error
    DigitalIdWalletApiGovbrWalletVerificationStartCountryEnum:
      enum:
        - BRA
      type: string
      description: '* `BRA` - BRA'
    DigitalIdWalletApiDeviceEnum:
      enum:
        - same_device
        - cross_device
      type: string
      description: |-
        * `same_device` - same_device
        * `cross_device` - cross_device
    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
    DigitalIdWalletApiClientCredentialsForbiddenErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Forbidden - User doesn't have permission
    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.