> ## 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 का रिस्पॉन्स, सटीक हेडर और payload शामिल हैं।



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



      
      

\<pre>

\`List every webhook delivery Didit recorded for one verification session through the API.

Endpoint:
GET https://verification.didit.me/v3/session/{session_id}/webhooks/

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

Goal:
\- See which webhooks Didit sent for a session, to which URL, and what my endpoint answered. Use it to debug a missing or rejected webhook, or to reconcile my records with Didit's.

Behavior:
\- Works for user (KYC) and business (KYB) session IDs.
\- Returns a JSON array, newest first. It is not paginated. An empty array means no webhook was sent for the session yet.
\- Each entry is one delivery attempt to one destination. The first delivery, each automatic retry and each manual resend are separate entries with their own uuid; retries and resends keep the payload's event_id.
\- request_header and request_body are JSON-encoded strings. Parse them with a JSON parser to read the headers and the payload.
\- A scoped key without media: read receives media URLs inside request_body as null; without sessions: write it receives session links and tokens as null. A redacted body no longer matches the recorded signatures.

Example call:
curl -X GET "https://verification.didit.me/v3/session/11111111-2222-3333-4444-555555555555/webhooks/" \
-H "x-api-key: YOUR_API_KEY"

What to read from the response:
\- uuid: the delivery id. Use it as {webhook_uuid} to get or resend one delivery.
\- webhook_type: status.updated or data.updated for session deliveries.
\- status: the session status when the event was generated.
\- response_status: the HTTP status my endpoint returned. null while the delivery is queued; 504 means a timeout (5 seconds), 503 a connection failure, 400 a URL refused as unsafe.
\- request_url and created_at: where and when it was sent.

Failure modes:
\- 401: the API key has expired.
\- 403: missing key (a wrong, revoked or expired key gets 401) ({ "detail": "Authentication credentials were not provided or are invalid." }), 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 or was deleted ({ "detail": "Not found." }), or is outside a scoped key's workflow or status limits ({ "detail": "Session not found." }).
\- 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>



      
      

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

हर प्रयास लॉग किया जाता है, जिसमें वे [स्वचालित पुनः प्रयास](https://docs.didit.me/hi/integration/webhooks.md#पुनः-प्रयास-नीति) भी शामिल हैं जो Didit `5xx` या `404` उत्तर के बाद करता है। इसलिए विफल डिलीवरी और उसके बाद का सफल पुनः प्रयास दो प्रविष्टियों के रूप में दिखाई देते हैं, जिनमें `request_body` के अंदर एक ही `event_id` होता है।किसी एक डिलीवरी की जाँच करने के लिए, [सत्र webhook डिलीवरी प्राप्त करें](https://docs.didit.me/hi/management-api/sessions/get-webhook.md) का उपयोग करें। अपना endpoint ठीक करने के बाद उसे दोबारा भेजने के लिए, [सत्र webhook डिलीवरी फिर से भेजें](https://docs.didit.me/hi/management-api/sessions/resend-webhook.md) का उपयोग करें।


## OpenAPI

````yaml hi/openapi-25.json GET /v3/session/{sessionId}/webhooks/
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}/webhooks/:
    get:
      tags:
        - Sessions
      summary: सत्र webhook डिलीवरी सूचीबद्ध करें
      description: >-
        एक सत्यापन सत्र, उपयोगकर्ता (KYC) या व्यवसाय (KYB) के लिए Didit द्वारा
        रिकॉर्ड की गई प्रत्येक webhook डिलीवरी को एक सामान्य JSON ऐरे
        (अनपेजिनेटेड) के रूप में सूचीबद्ध करें, नवीनतम पहले। प्रत्येक प्रविष्टि
        एक गंतव्य के लिए एक प्रयास है: पहला प्रेषण, प्रत्येक स्वचालित [पुनः
        प्रयास](https://docs.didit.me/hi/integration/webhooks#पुनः-प्रयास-नीति)
        और प्रत्येक पुनः प्रेषण अपनी स्वयं की `uuid` वाली अलग प्रविष्टियां हैं,
        और पुनः प्रयास व पुनः प्रेषण payload के `event_id` को बनाए रखते हैं।
        `request_header` और `request_body` JSON टेक्स्ट हैं; हस्ताक्षर और
        payload पढ़ने के लिए उन्हें पार्स करें। डिलीवरी रिकॉर्ड लगभग 30 दिनों के
        लिए उपलब्ध होते हैं, इसलिए एक खाली ऐरे का अर्थ है कि सत्र के लिए अभी तक
        कोई webhook नहीं भेजा गया है या प्रत्येक डिलीवरी उससे अधिक पुरानी है।
        स्कोप्ड API कुंजी के लिए `sessions: read` और `decisions: read` की
        आवश्यकता होती है।
      operationId: get_v3_session_webhooks
      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
      responses:
        '200':
          description: सत्र के लिए रिकॉर्ड की गई प्रत्येक डिलीवरी, सबसे नई पहले।
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/SessionWebhookDelivery'
              examples:
                Failed delivery and its successful retry:
                  value:
                    - uuid: 66666666-7777-8888-9999-000000000002
                      session_id: 22222222-3333-4444-5555-666666666666
                      request_url: https://yourapp.com/webhooks/didit
                      response_status: 200
                      status: In Progress
                      webhook_type: status.updated
                      request_header: >-
                        {"Content-Type": "application/json", "X-Signature":
                        "9188851d160b5b3aacfc946e4dde1f061b7e568662518942c927ddaf507f533d",
                        "X-Signature-V2":
                        "381236af514d3fb538579365ac5a24f2464ce1b8224c6e770c60d8201c43ecc5",
                        "X-Signature-Simple":
                        "4740131dc38f29e78a8508371979be74967d5307464494bd3148a03b4d6c8716",
                        "X-Timestamp": "1792056139", "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":1792056139,"vendor_data":"user-123","webhook_type":"status.updated","workflow_id":"44444444-5555-6666-7777-888888888888","workflow_version":3}
                      created_at: '2026-10-15T09:22:19.104233Z'
                    - 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'
                No webhook sent yet:
                  value: []
        '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.`)।
          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.
        '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/webhooks/'
            \
              -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.list(
                "22222222-3333-4444-5555-666666666666",
            )
            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.list("22222222-3333-4444-5555-666666666666");

            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.List(ctx, \"22222222-3333-4444-5555-666666666666\")\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().list("22222222-3333-4444-5555-666666666666");

            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->list('22222222-3333-4444-5555-666666666666');

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


            # Reads DIDIT_API_KEY.

            didit = Didit::Client.new


            didit.sessions.webhooks.list("22222222-3333-4444-5555-666666666666").each
            do |item|
              puts item.to_h
            end
        - 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.ListAsync("22222222-3333-4444-5555-666666666666");

            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.