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

# सत्र webhook डिलीवरी प्राप्त करें API

> Didit के साथ किसी सत्र की एक webhook डिलीवरी प्राप्त करें: URL, आपके endpoint का HTTP रिस्पॉन्स, और Didit द्वारा भेजे गए सटीक हस्ताक्षर हेडर और JSON बॉडी।



सत्र webhook डिलीवरी प्राप्त करने के लिए API प्रॉम्प्ट
        प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें



      
      

\<pre>

\`Retrieve one webhook delivery of a Didit verification session through the API.

Endpoint:
GET https://verification.didit.me/v3/session/{session_id}/webhook/{webhook_uuid}
(no trailing slash)

Authentication:
Send my Didit API key in the x-api-key header. A scoped key needs sessions: read and decisions: read.

Goal:
\- Read exactly what Didit sent to my webhook endpoint for one delivery and what my endpoint answered, to debug a rejected or missing event.

Behavior:
\- {webhook_uuid} is the uuid of an entry from GET /v3/session/{session_id}/webhooks/. It must belong to the session in the path; a delivery of another session returns 404.
\- request_header and request_body are JSON-encoded strings. Parse them with a JSON parser.
\- To check my signature code, recompute X-Signature-V2 from the parsed request_body with my destination's secret (the application-level secret for a delivery sent to the legacy webhook_url) and compare it with the header. A scoped key without media: read or sessions: write receives a redacted body, which no longer matches the signatures.

Example call:
curl -X GET "https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/webhook/9f8e7d6c-5b4a-4321-8fed-cba987654321" \
-H "x-api-key: YOUR_API_KEY"

What to read from the response:
\- response_status: the HTTP status my endpoint returned (null while queued, 504 timeout, 503 connection failure, 400 URL refused as unsafe).
\- request_url: where it was sent.
\- request_header: the X-Signature, X-Signature-V2, X-Signature-Simple and X-Timestamp values sent.
\- request_body: the webhook payload (event_id, webhook_type, session_id, status, decision when present).
\- status, webhook_type, created_at.

Failure modes:
\- 401: the API key has expired.
\- 403: missing key (a wrong, revoked or expired key gets 401), a key of another application, a scoped key without the permissions above, or a request from outside the key's IP allowlist.
\- 404: the session does not exist, was deleted, or is outside a scoped key's limits, or the delivery does not belong to this session ({ "detail": "No WebhookLog matches the given query." }).
\- 429: more than 600 reads per minute for this API key; honor Retry-After.

Side effects: none. This is a pure read.

For the full integration shape, see /integration/integration-prompt.`

\</pre>



      
      

यहाँ पेस्ट करें

`request_body` के अंदर का payload वही है जिसका वर्णन [Webhooks](https://docs.didit.me/hi/integration/webhooks.md#payload-संरचना) में किया गया है, और हेडर वही हैं जो [हस्ताक्षर सत्यापन](https://docs.didit.me/hi/integration/webhooks.md#हस्ताक्षर-सत्यापन) में बताए गए हैं। डिलीवरी दोबारा भेजने के लिए [सत्र webhook डिलीवरी दोबारा भेजें](https://docs.didit.me/hi/management-api/sessions/resend-webhook.md) का उपयोग करें।


## OpenAPI

````yaml hi/openapi-25.json GET /v3/session/{sessionId}/webhook/{webhook_uuid}
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/session/{sessionId}/webhook/{webhook_uuid}:
    get:
      tags:
        - Sessions
      summary: सत्र webhook डिलीवरी प्राप्त करें
      description: >-
        सत्यापन सत्र की एक webhook डिलीवरी प्राप्त करें: जिस URL पर यह भेजी गई
        थी, आपके endpoint द्वारा लौटाया गया HTTP स्टेटस, और Didit द्वारा भेजे गए
        सटीक हेडर और JSON बॉडी। `request_header` और `request_body` JSON टेक्स्ट
        हैं; अपने [हस्ताक्षर
        सत्यापन](https://docs.didit.me/hi/integration/webhooks#हस्ताक्षर-सत्यापन)
        की जांच करने के लिए, पार्स किए गए बॉडी से उस गंतव्य के सीक्रेट के साथ
        `X-Signature-V2` की पुनर्गणना करें जिस पर इसे भेजा गया था (या लीगेसी
        webhook URL पर डिलीवरी के लिए एप्लिकेशन-स्तरीय सीक्रेट के साथ)। पाथ में
        कोई ट्रेलिंग स्लैश नहीं है: ट्रेलिंग स्लैश होने पर यह `404` लौटाता है।
        स्कोप्ड API कुंजी के लिए `sessions: read` और `decisions: read` आवश्यक
        हैं।
      operationId: get_v3_session_webhook
      parameters:
        - name: sessionId
          in: path
          required: true
          description: >-
            सत्यापन सत्र का UUID, उपयोगकर्ता (KYC) या व्यवसाय (KYB): `POST
            /v3/session/` द्वारा लौटाया गया `session_id`। सर्वर इसे दोनों सत्र
            प्रकारों में रिज़ॉल्व करता है।


            **एक मान्य UUID होना चाहिए।** यह रूट केवल सही प्रारूप वाले UUID से
            मेल खाता है, इसलिए किसी भी एप्लिकेशन कोड के चलने से पहले URL राउटर
            द्वारा गलत प्रारूप वाले मान को अस्वीकार कर दिया जाता है और रिस्पॉन्स
            नीचे दिखाए गए JSON `{"detail": ...}` एनवलप के बजाय `404` **HTML**
            पेज होता है।
          schema:
            type: string
            format: uuid
          example: 22222222-3333-4444-5555-666666666666
        - name: webhook_uuid
          in: path
          required: true
          description: >-
            डिलीवरी का UUID: `GET /v3/session/{sessionId}/webhooks/` द्वारा
            लौटाई गई किसी प्रविष्टि का `uuid`। यह पाथ के सत्र से संबंधित होना
            चाहिए।
          schema:
            type: string
            format: uuid
          example: 66666666-7777-8888-9999-000000000001
      responses:
        '200':
          description: डिलीवरी, उसके अनुरोध हेडर और बॉडी के साथ।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SessionWebhookDelivery'
              examples:
                Connection failure:
                  value:
                    uuid: 66666666-7777-8888-9999-000000000001
                    session_id: 22222222-3333-4444-5555-666666666666
                    request_url: https://yourapp.com/webhooks/didit
                    response_status: 503
                    status: In Progress
                    webhook_type: status.updated
                    request_header: >-
                      {"Content-Type": "application/json", "X-Signature":
                      "a5e02a03404e1337a0198e6be15d34abbd053c658a0e51e5d0e78554213ef29b",
                      "X-Signature-V2":
                      "927e7cb770c94ce745939bff73f04aa200015f3bc64795ba46c2aaf78a6cedc5",
                      "X-Signature-Simple":
                      "e37b0d4c716c72bb5ae7127b9cc455d28ab4686e9e22312b4ec2327409a73302",
                      "X-Timestamp": "1792056078", "User-Agent":
                      "DiditWebhook/2.0 +https://didit.me"}
                    request_body: >-
                      {"application_id":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","created_at":1792056057,"environment":"live","event_id":"33333333-4444-5555-6666-777777777777","sandbox_scenario":null,"session_id":"22222222-3333-4444-5555-666666666666","status":"In
                      Progress","timestamp":1792056078,"vendor_data":"user-123","webhook_type":"status.updated","workflow_id":"44444444-5555-6666-7777-888888888888","workflow_version":3}
                    created_at: '2026-10-15T09:21:18.412345Z'
        '401':
          description: >-
            API कुंजी की समय-सीमा समाप्त हो गई है: इसे एक समाप्ति तिथि के साथ
            बनाया गया था जो बीत चुकी है। किसी गलत या निरस्त की गई कुंजी पर भी
            `401` मिलता है; अनुपलब्ध कुंजी पर `403` मिलता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Expired key:
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            अनुरोध की अनुमति नहीं है। कोई `x-api-key` न होने, या अमान्य अथवा
            निरस्त कुंजी होने पर `Authentication credentials were not provided
            or are invalid.` मिलता है। किसी अन्य एप्लिकेशन की कुंजी पर `You do
            not have permission to perform this action.` मिलता है। इस endpoint
            के लिए आवश्यक एक्सेस के बिना स्कोप्ड कुंजी होने पर अनुपलब्ध एक्सेस
            का नाम बताते हुए एक संदेश मिलता है, और इसकी IP allowlist के बाहर से
            उपयोग की गई कुंजी पर `This API key can't be used from this IP
            address.` मिलता है। क्रेडेंशियल जाँचे जाने से पहले एक अज्ञात
            `sessionId` पर `404` वापस आता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Missing or invalid key:
                  value:
                    detail: >-
                      Authentication credentials were not provided or are
                      invalid.
                Key of another application:
                  value:
                    detail: You do not have permission to perform this action.
                Scoped key without sessions read:
                  value:
                    detail: This API key has no read access to sessions.
                Scoped key without decisions read:
                  value:
                    detail: This API key has no read access to decisions.
                Outside the IP allowlist:
                  value:
                    detail: This API key can't be used from this IP address.
        '404':
          description: >-
            सत्र मौजूद नहीं है या हटा दिया गया है (क्रेडेंशियल की जांच से पहले
            `Not found.` लौटाया जाता है), या यह स्कोप्ड कुंजी की वर्कफ़्लो या
            स्थिति सीमाओं से बाहर है (`Session not found.`)। ऐसी डिलीवरी जो
            मौजूद नहीं है, किसी अन्य सत्र से संबंधित है या अब उपलब्ध नहीं है,
            `No WebhookLog matches the given query.` लौटाती है
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Unknown session:
                  value:
                    detail: Not found.
                Outside the key's limits:
                  value:
                    detail: Session not found.
                Delivery not in this session:
                  value:
                    detail: No WebhookLog matches the given query.
        '429':
          description: >-
            रेट लिमिट पार हो गई: इस API कुंजी के लिए वर्तमान एक मिनट की विंडो
            में 600 से अधिक GET अनुरोध। पुनः प्रयास करने से पहले `Retry-After`
            सेकंड प्रतीक्षा करें।
          headers:
            Retry-After:
              description: पुनः प्रयास करने से पहले प्रतीक्षा करने के सेकंड।
              schema:
                type: integer
                minimum: 1
                example: 30
            X-RateLimit-Limit:
              description: एक मिनट की विंडो में अनुमत अनुरोध (600)।
              schema:
                type: integer
                example: 600
            X-RateLimit-Remaining:
              description: वर्तमान विंडो में शेष अनुरोध।
              schema:
                type: integer
                example: 0
            X-RateLimit-Reset:
              description: Unix समय (सेकंड) जब वर्तमान विंडो रीसेट होती है।
              schema:
                type: integer
                example: 1792056120
            X-RateLimit-Scope:
              description: उस बजट का नाम जो पार हो गया था।
              schema:
                type: string
                example: generic-get
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Throttled:
                  value:
                    detail: >-
                      GET request rate limit exceeded. You can make up to 600
                      requests per minute.
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X GET
            'https://verification.didit.me/v3/session/22222222-3333-4444-5555-666666666666/webhook/66666666-7777-8888-9999-000000000001'
            \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.sessions.webhooks.retrieve(
                "22222222-3333-4444-5555-666666666666",
                "66666666-7777-8888-9999-000000000001",
            )
            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.sessions.webhooks.retrieve(
              "22222222-3333-4444-5555-666666666666",
              "66666666-7777-8888-9999-000000000001",
            );
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Sessions.Webhooks.Retrieve(ctx, \"22222222-3333-4444-5555-666666666666\", \"66666666-7777-8888-9999-000000000001\")\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.sessions().webhooks().retrieve("22222222-3333-4444-5555-666666666666",
            "66666666-7777-8888-9999-000000000001");

            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->sessions->webhooks->retrieve('22222222-3333-4444-5555-666666666666',
            '66666666-7777-8888-9999-000000000001');

            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.sessions.webhooks.retrieve(
              "22222222-3333-4444-5555-666666666666",
              "66666666-7777-8888-9999-000000000001"
            )
            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.Sessions.Webhooks.RetrieveAsync("22222222-3333-4444-5555-666666666666",
            "66666666-7777-8888-9999-000000000001");

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    SessionWebhookDelivery:
      type: object
      description: >-
        सत्यापन सत्र के लिए रिकॉर्ड किया गया एक webhook डिलीवरी प्रयास, जिसमें
        Didit द्वारा भेजे गए सटीक अनुरोध हेडर और बॉडी शामिल हैं।
      required:
        - uuid
        - session_id
        - request_url
        - response_status
        - status
        - webhook_type
        - request_header
        - request_body
        - created_at
      properties:
        uuid:
          type: string
          format: uuid
          description: >-
            डिलीवरी ID। इस डिलीवरी को प्राप्त करने या पुनः भेजने के लिए इसे
            `{webhook_uuid}` के रूप में उपयोग करें।
        session_id:
          type: string
          format: uuid
          description: वह सत्र जिससे डिलीवरी संबंधित है (पाथ में दिया गया सत्र)।
        request_url:
          type: string
          format: uri
          nullable: true
          description: वह URL जिस पर डिलीवरी भेजी गई थी।
        response_status:
          type: integer
          nullable: true
          description: >-
            आपके endpoint द्वारा लौटाया गया HTTP स्टेटस। जब डिलीवरी कतार में हो
            और अभी तक प्रयास न किया गया हो तो `null`। जब कोई HTTP उत्तर प्राप्त
            नहीं हुआ, तो Didit अपनी स्वयं की स्थिति दर्ज करता है: जब आपके
            endpoint ने 5 सेकंड के भीतर उत्तर नहीं दिया तो `504`, कनेक्शन विफलता
            के लिए `503`, जब URL को असुरक्षित (उदाहरण के लिए एक निजी या आंतरिक
            पता) के रूप में अस्वीकार कर दिया गया था तो `400`, और किसी भी अन्य
            अनुरोध त्रुटि के लिए `404`। `400` या उससे अधिक को विफल डिलीवरी माना
            जाता है।
        status:
          type: string
          nullable: true
          description: >-
            इवेंट जनरेट होने पर सत्र की स्थिति, उदाहरण के लिए `In Progress`,
            `Approved` या `Declined`।
        webhook_type:
          $ref: '#/components/schemas/WebhookEvent'
        request_header:
          type: string
          description: >-
            Didit द्वारा भेजे गए अनुरोध हेडर का JSON टेक्स्ट (एक स्ट्रिंग):
            `Content-Type`, `X-Signature`, `X-Signature-V2`,
            `X-Signature-Simple`, `X-Timestamp` और `User-Agent`। इसे JSON पार्सर
            से पार्स करें। इसमें हस्ताक्षर होते हैं, लेकिन साइनिंग सीक्रेट कभी
            नहीं होता।
        request_body:
          type: string
          description: >-
            Didit द्वारा भेजे गए सटीक payload का JSON टेक्स्ट (एक स्ट्रिंग),
            कुंजियाँ सॉर्ट की गई हैं, जिसमें `event_id` और `timestamp` शामिल
            हैं। इसे JSON पार्सर से पार्स करें; [Payload
            shape](https://docs.didit.me/hi/integration/webhooks#payload-संरचना)
            देखें। बिना `media: read` वाली स्कोप्ड कुंजी के लिए, इसके अंदर
            मीडिया URL `null` होते हैं; बिना `sessions: write` के, सत्र token और
            होस्टेड सत्यापन लिंक `null` होते हैं। इस तरह बदली गई बॉडी अब अपने
            हस्ताक्षरों से मेल नहीं खाती है। Didit आपके endpoint द्वारा लौटाए गए
            रिस्पॉन्स बॉडी को रिकॉर्ड नहीं करता है।
        created_at:
          type: string
          format: date-time
          description: जब डिलीवरी बनाई गई थी।
    WebhookEvent:
      type: string
      description: >-
        समर्थित webhook इवेंट का नाम। `subscribed_events` में इन सटीक स्ट्रिंग्स
        का उपयोग करें; असमर्थित मान अस्वीकृत कर दिए जाते हैं।
      enum:
        - status.updated
        - data.updated
        - user.status.updated
        - user.data.updated
        - business.status.updated
        - business.data.updated
        - activity.created
        - transaction.created
        - transaction.status.updated
        - travel_rule.status.updated
        - workflow.compliance_changed
        - transaction_rule_suggestions.created
        - auth.signup
        - auth.login
        - auth.login_failed
        - auth.password_reset_requested
        - auth.password_reset_completed
        - auth.mfa_changed
        - auth.new_device
        - auth.account_locked
        - investigator.report.ready
        - investigator.decision.automated
        - investigator.decision.overridden
        - investigator.decision.contested
        - investigator.question.raised
        - investigator.automation.paused
        - investigator.rfi.answered
        - investigator.rfi.overdue
        - investigator.drift.detected
        - investigator.sla.breached
        - investigator.qa.failed
        - investigator.external.report.ready
  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।

````

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