> ## 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 का रिस्पॉन्स पाएँ।



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



      
      

\<pre>

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

Endpoint:
POST https://verification.didit.me/v3/session/{session_id}/webhook/{webhook_uuid}/resend
(no trailing slash, no request body)

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

Goal:
\- Replay a webhook my endpoint missed or rejected, after I fixed the endpoint.

Behavior:
\- {webhook_uuid} is the uuid of an entry from GET /v3/session/{session_id}/webhooks/, and it must belong to the session in the path.
\- Didit sends the recorded payload again to the URL the delivery was first sent to. The payload keeps its event_id; Didit refreshes the timestamp field, the X-Timestamp header and the signatures, using the destination's current signing secret (the application-level secret for a delivery sent to the legacy webhook_url).
\- Synchronous: Didit waits up to 5 seconds for my endpoint, records the attempt as a new delivery and returns it. The original delivery is not changed.
\- The call returns 200 even when my endpoint answered with an error: read response_status in the returned delivery.
\- A failed resend is not retried automatically. Every call sends one more request to my endpoint, so my handler must be idempotent on event_id.

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

What to read from the response:
\- uuid: the new delivery id.
\- response_status: what my endpoint answered this time (504 timeout, 503 connection failure, 400 URL refused as unsafe).
\- request_header and request_body: the headers and body actually sent.

Failure modes:
\- 400 with code webhook_url_missing: the delivery has no recorded URL.
\- 400 with code webhook_resend_error: the recorded payload could not be re-signed or sent.
\- 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": "Webhook log not found" }).
\- 429: more than 300 writes per minute for this API key; honor Retry-After.

Side effects: sends one HTTP request to my webhook endpoint and adds one delivery to the session's webhook log.

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

\</pre>



      
      

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

> [!NOTE]
>
> पुनः भेजने का अनुरोध डिलीवरी पर संग्रहीत URL पर जाता है, भले ही आपने उसके बाद गंतव्य का URL बदल दिया हो। चूँकि payload अपना `event_id` बनाए रखता है, इसलिए जो प्राप्तकर्ता [`event_id` पर डुप्लिकेट हटाता है](https://docs.didit.me/hi/integration/webhooks#एन्वेलप), वह पुनः भेजे गए इवेंट को उस इवेंट के रूप में लेता है जिसे वह पहले से जानता है।पुनः भेजने के लिए डिलीवरी खोजने हेतु [सत्र webhook डिलीवरी की सूची](https://docs.didit.me/hi/management-api/sessions/list-webhooks.md) का उपयोग करें।


## OpenAPI

````yaml hi/openapi-25.json POST /v3/session/{sessionId}/webhook/{webhook_uuid}/resend
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}/resend:
    post:
      tags:
        - Sessions
      summary: सत्र webhook डिलीवरी पुनः भेजें
      description: >-
        एक रिकॉर्ड किए गए सत्र webhook को उसी URL पर फिर से भेजें जहाँ वह पहली
        बार गया था, उसी payload और `event_id` के साथ और एक नए `timestamp`,
        `X-Timestamp` हेडर और हस्ताक्षर के साथ। Didit इस पर उस गंतव्य के वर्तमान
        सीक्रेट से हस्ताक्षर करता है जिससे यह डिलीवरी संबंधित है (या लेगेसी
        webhook URL पर डिलीवरी के लिए एप्लिकेशन-स्तरीय सीक्रेट से), आपके
        endpoint के लिए 5 सेकंड तक प्रतीक्षा करता है, प्रयास को एक नई डिलीवरी के
        रूप में रिकॉर्ड करता है और आपके endpoint द्वारा दिए गए उत्तर की परवाह
        किए बिना इसे `200` के साथ लौटाता है: `response_status` पढ़ें। पुनः भेजे
        गए अनुरोध का स्वचालित रूप से पुनः प्रयास नहीं किया जाता है, और प्रत्येक
        कॉल फिर से भेजती है, इसलिए अपने endpoint को `event_id` पर आइडेम्पोटेंट
        बनाएं। पाथ में कोई ट्रेलिंग स्लैश नहीं है और अनुरोध में कोई बॉडी नहीं
        है। एक स्कोप्ड API कुंजी को `webhooks: write` और `decisions: read` की
        आवश्यकता होती है।
      operationId: post_v3_session_webhook_resend
      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: >-
            नई डिलीवरी, जिसका पहले ही प्रयास किया जा चुका है। `response_status`
            वह है जो आपके endpoint ने इस बार उत्तर दिया। मूल डिलीवरी अपरिवर्तित
            रहती है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SessionWebhookDelivery'
              examples:
                Accepted on resend:
                  value:
                    uuid: 66666666-7777-8888-9999-000000000004
                    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":
                      "b8eb1e376517ee0cad8ba98ff7f8fd35fc72eca231000963a96a335f82328835",
                      "X-Signature-V2":
                      "9efd2ce9ed1303e1d05273ef9608a59363ed9789a05253db4748b3e8e50cb109",
                      "X-Signature-Simple":
                      "bf3a9dc04b2c20ab539203b0cd5cca2a10f630bf62d8feb6d68d82af80f64774",
                      "X-Timestamp": "1792159542", "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":1792159542,"vendor_data":"user-123","webhook_type":"status.updated","workflow_id":"44444444-5555-6666-7777-888888888888","workflow_version":3}
                    created_at: '2026-10-16T14:05:42.330981Z'
        '400':
          description: >-
            डिलीवरी पुनः नहीं भेजी जा सकी। `code` पर शाखा बनाएं:
            `webhook_url_missing` का अर्थ है कि डिलीवरी का कोई रिकॉर्ड किया गया
            URL नहीं है और कुछ भी नहीं भेजा गया है; `webhook_resend_error` का
            अर्थ है कि संग्रहीत डिलीवरी पर फिर से हस्ताक्षर नहीं किए जा सके या
            प्रयास पूरा नहीं किया जा सका। `webhook_resend_error` के बाद,
            `detail` की शुरुआत `Error processing webhook resend:` से होती है
            जिसके बाद एक नैदानिक टेक्स्ट होता है जो बदल सकता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
                  code:
                    type: string
                    description: >-
                      मशीन द्वारा पठनीय स्थिर त्रुटि कोड। इस पर ब्रांच करें,
                      `detail` पर नहीं।
              examples:
                No recorded URL:
                  value:
                    detail: >-
                      The webhook delivery does not have a request URL
                      configured
                    code: webhook_url_missing
                Resend failed:
                  value:
                    detail: >-
                      Error processing webhook resend: Invalid webhook data
                      format
                    code: webhook_resend_error
        '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 webhooks write:
                  value:
                    detail: This API key has no write access to webhooks.
                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.`)। ऐसी डिलीवरी जो
            मौजूद नहीं है, किसी अन्य सत्र से संबंधित है या अब उपलब्ध नहीं है,
            `Webhook log 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.
                Delivery not in this session:
                  value:
                    detail: Webhook log not found
        '429':
          description: >-
            रेट लिमिट पार हो गई: इस API कुंजी के लिए वर्तमान एक मिनट की विंडो
            में 300 से अधिक राइट (write) अनुरोध (POST, PATCH, PUT, DELETE)। पुनः
            प्रयास करने से पहले `Retry-After` सेकंड प्रतीक्षा करें।
          headers:
            Retry-After:
              description: पुनः प्रयास करने से पहले प्रतीक्षा करने के सेकंड।
              schema:
                type: integer
                minimum: 1
                example: 30
            X-RateLimit-Limit:
              description: एक मिनट की विंडो में अनुमत अनुरोध (300)।
              schema:
                type: integer
                example: 300
            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-write
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Throttled:
                  value:
                    detail: >-
                      Write request rate limit exceeded. You can make up to 300
                      requests per minute.
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/session/22222222-3333-4444-5555-666666666666/webhook/66666666-7777-8888-9999-000000000001/resend'
            \
              -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.resend(
                "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.resend(
              "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.Resend(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().resend("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->resend('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.resend(
              "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.ResendAsync("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.