> ## 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 डिलीवरी को नए हस्ताक्षर के साथ endpoint पर दोबारा भेजें और आपके endpoint का HTTP स्टेटस पाएँ।



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



      
      

\<pre>

\`Resend a past Didit webhook delivery to my endpoint through the Management API.

Endpoint:
POST https://verification.didit.me/v3/webhook/destinations/{destination_uuid}/deliveries/{delivery_uuid}/resend/

Authentication:
Use the x-api-key header with my Didit API key. A scoped API key needs webhooks: write and decisions: read. A key limited to some workflows or to approved sessions cannot use this endpoint.

Goal:
\- Recover webhooks my endpoint missed (for example during an outage) by sending them again once the endpoint is fixed.

Path parameters:
\- destination_uuid: the destination uuid from GET /v3/webhook/destinations/.
\- delivery_uuid: the uuid of the delivery to resend, from GET /v3/webhook/destinations/{destination_uuid}/deliveries/.

Behavior:
\- No request body.
\- Didit takes the stored payload, sets a fresh timestamp, signs it again with the destination's current secret_shared_key (X-Signature, X-Signature-V2, X-Signature-Simple and X-Timestamp) and POSTs it to the URL the original delivery went to (request_url), even if the destination URL changed since or the destination is disabled.
\- event_id and the rest of the payload are unchanged, so deduplicate on event_id in my endpoint.
\- The call waits for my endpoint (up to 5 seconds) and returns 200 with the new delivery whatever my endpoint answered. Check response_status in the response: 2xx means accepted, 504 a timeout, 503 a connection failure.
\- One attempt only: a resend is not retried automatically. Every call sends again and creates a new delivery with its own uuid; the original delivery is unchanged.
\- The response is redacted like GET delivery for scoped keys (media URLs, session tokens and hosted links as null); my endpoint still receives the full payload.

Example call:
curl -X POST "https://verification.didit.me/v3/webhook/destinations/{destination_uuid}/deliveries/{delivery_uuid}/resend/" \
-H "x-api-key: YOUR_API_KEY"

Failure modes:
\- 400: { "detail": "Invalid webhook data format", "code": "invalid_webhook_payload" } when the stored delivery cannot be signed again. Nothing is sent.
\- 401: { "detail": "This API key has expired." }
\- 403: { "detail": "You do not have permission to perform this action." }, { "detail": "This API key has no write access to webhooks." }, { "detail": "This API key has no read access to decisions." }, or the limited-key message.
\- 404: { "detail": "Webhook destination not found." } or { "detail": "Webhook delivery not found." }
\- 429: more than 300 write requests per minute with this key; wait for Retry-After.

Side effects:
\- My endpoint receives the webhook again, and a new delivery appears in the destination's deliveries and analytics.

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

\</pre>



      
      

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

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


## OpenAPI

````yaml hi/openapi-25.json POST /v3/webhook/destinations/{destination_uuid}/deliveries/{delivery_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/webhook/destinations/{destination_uuid}/deliveries/{delivery_uuid}/resend/:
    post:
      tags:
        - Webhook
      summary: webhook गंतव्य डिलीवरी पुनः भेजें
      description: >-
        पिछली डिलीवरी को दोबारा भेजें, उदाहरण के लिए जब आपका endpoint डाउन था।
        Didit संग्रहीत payload लेता है, एक नया `timestamp` सेट करता है, गंतव्य
        की वर्तमान `secret_shared_key` (`X-Signature`, `X-Signature-V2`,
        `X-Signature-Simple` और `X-Timestamp`) के साथ इसे फिर से हस्ताक्षरित
        करता है और डिलीवरी के `request_url` पर पोस्ट करता है, भले ही गंतव्य का
        URL तब से बदल गया हो या गंतव्य अक्षम हो गया हो। `event_id` और शेष
        payload अपरिवर्तित रहते हैं, इसलिए `event_id` के आधार पर डिडुप्लिकेट
        करें। कॉल आपके endpoint के लिए 5 सेकंड तक प्रतीक्षा करती है और आपके
        endpoint ने जो भी उत्तर दिया हो, उसके बावजूद `200` के साथ नई डिलीवरी
        लौटाती है: `response_status` पढ़ें। रीसेंड का स्वचालित रूप से पुनः
        प्रयास नहीं किया जाता है, प्रत्येक कॉल फिर से भेजती है और एक नई डिलीवरी
        बनाती है, और अनुरोध में कोई बॉडी नहीं होती है। स्कोप्ड API कुंजी के लिए
        `webhooks: write` और `decisions: read` आवश्यक हैं; कुछ वर्कफ़्लो या
        स्वीकृत सत्रों तक सीमित कुंजी इस endpoint का उपयोग नहीं कर सकती है।
      operationId: resend_webhook_destination_delivery
      parameters:
        - name: destination_uuid
          in: path
          required: true
          description: उस गंतव्य का UUID जिस पर डिलीवरी भेजी गई थी।
          schema:
            type: string
            format: uuid
          example: 11111111-2222-3333-4444-555555555555
        - name: delivery_uuid
          in: path
          required: true
          description: >-
            पुनः भेजी जाने वाली डिलीवरी का UUID: `GET
            /v3/webhook/destinations/{destination_uuid}/deliveries/` द्वारा
            लौटाई गई किसी प्रविष्टि का `uuid`।
          schema:
            type: string
            format: uuid
          example: 66666666-7777-8888-9999-000000000001
      responses:
        '200':
          description: >-
            नई डिलीवरी, जिसका पहले ही प्रयास किया जा चुका है। `response_status`
            वह है जो आपके endpoint ने इस बार उत्तर दिया (`504` टाइमआउट, `503`
            कनेक्शन विफलता)। मूल डिलीवरी अपरिवर्तित रहती है।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WebhookDestinationDeliveryDetail'
              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
                    response_time_ms: 151
                    status: In Progress
                    webhook_type: status.updated
                    created_at: '2026-10-16T14:05:42.330981Z'
                    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}
        '400':
          description: >-
            संग्रहीत डिलीवरी पर दोबारा हस्ताक्षर नहीं किए जा सके। कुछ भी नहीं
            भेजा गया है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
                  code:
                    type: string
                    description: >-
                      मशीन द्वारा पठनीय स्थिर त्रुटि कोड। इस पर ब्रांच करें,
                      `detail` पर नहीं।
              examples:
                Unsignable delivery:
                  value:
                    detail: Invalid webhook data format
                    code: invalid_webhook_payload
        '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` पर
            `You do not have permission to perform this action.` मिलता है। इस
            endpoint के लिए आवश्यक एक्सेस के बिना स्कोप्ड कुंजी होने पर अनुपलब्ध
            एक्सेस का नाम बताते हुए एक संदेश मिलता है, और इसकी IP allowlist के
            बाहर से उपयोग की गई कुंजी पर `This API key can't be used from this
            IP address.` मिलता है। कुछ वर्कफ़्लो या स्वीकृत सत्रों तक सीमित
            कुंजी पर `This API key only reaches sessions inside its workflow or
            status limits, so it can't use this endpoint.` मिलता है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Missing or invalid key:
                  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.
                Key limited to workflows or approved sessions:
                  value:
                    detail: >-
                      This API key only reaches sessions inside its workflow or
                      status limits, so it can't use this endpoint.
                Outside the IP allowlist:
                  value:
                    detail: This API key can't be used from this IP address.
        '404':
          description: >-
            गंतव्य एप्लिकेशन के लिए मौजूद नहीं है या हटा दिया गया है, या डिलीवरी
            मौजूद नहीं है, किसी अन्य गंतव्य से संबंधित है, या अब उपलब्ध नहीं है।
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: मानव-पठनीय त्रुटि संदेश।
              examples:
                Destination not found:
                  value:
                    detail: Webhook destination not found.
                Delivery not found:
                  value:
                    detail: Webhook delivery 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/webhook/destinations/11111111-2222-3333-4444-555555555555/deliveries/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.webhooks.destinations.resend_delivery(
                "11111111-2222-3333-4444-555555555555",
                "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.webhooks.destinations.resendDelivery(
              "11111111-2222-3333-4444-555555555555",
              "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.Webhooks.Destinations.ResendDelivery(ctx, \"11111111-2222-3333-4444-555555555555\", \"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.webhooks().destinations().resendDelivery("11111111-2222-3333-4444-555555555555",
            "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->webhooks->destinations->resendDelivery('11111111-2222-3333-4444-555555555555',
            '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.webhooks.destinations.resend_delivery(
              "11111111-2222-3333-4444-555555555555",
              "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.Webhooks.Destinations.ResendDeliveryAsync("11111111-2222-3333-4444-555555555555",
            "66666666-7777-8888-9999-000000000001");

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    WebhookDestinationDeliveryDetail:
      type: object
      description: >-
        एक webhook गंतव्य पर एक डिलीवरी प्रयास, सटीक अनुरोध हेडर और मुख्य भाग के
        साथ जो Didit ने भेजा था।
      required:
        - uuid
        - session_id
        - request_url
        - response_status
        - response_time_ms
        - status
        - webhook_type
        - created_at
        - request_header
        - request_body
      properties:
        uuid:
          type: string
          format: uuid
          description: डिलीवरी ID, विवरण और पुनः भेजने के कॉल के लिए।
        session_id:
          type: string
          format: uuid
          nullable: true
          description: >-
            उपयोगकर्ता सत्यापन सत्र जिससे यह इवेंट संबंधित है। व्यवसाय सत्र,
            उपयोगकर्ता, व्यवसाय, लेन-देन, Travel Rule और वर्कफ़्लो इवेंट के लिए
            `null`।
        request_url:
          type: string
          format: uri
          nullable: true
          description: >-
            वह URL जिस पर डिलीवरी भेजी गई थी: इवेंट जनरेट होने के समय गंतव्य का
            URL।
        response_status:
          type: integer
          nullable: true
          description: >-
            आपके endpoint द्वारा लौटाया गया HTTP स्टेटस। जब डिलीवरी कतार में हो
            और अभी तक प्रयास न किया गया हो तो `null`। जब कोई HTTP उत्तर प्राप्त
            नहीं हुआ, तो Didit अपनी स्वयं की स्थिति दर्ज करता है: जब आपके
            endpoint ने 5 सेकंड के भीतर उत्तर नहीं दिया तो `504`, कनेक्शन विफलता
            के लिए `503`, जब URL को असुरक्षित (उदाहरण के लिए एक निजी या आंतरिक
            पता) के रूप में अस्वीकार कर दिया गया था तो `400`, और किसी भी अन्य
            अनुरोध त्रुटि के लिए `404`। `400` या उससे अधिक को विफल डिलीवरी माना
            जाता है।
        response_time_ms:
          type: integer
          nullable: true
          minimum: 0
          description: >-
            प्रयास में लगा समय, मिलीसेकंड में। जब तक डिलीवरी कतार में है तब तक
            `null`।
        status:
          type: string
          nullable: true
          description: >-
            इवेंट जनरेट होने पर उसके द्वारा रिपोर्ट किया गया स्टेटस: सत्र इवेंट
            के लिए सत्र स्टेटस (उदाहरण के लिए `Approved` या `In Review`),
            उपयोगकर्ता और व्यवसाय इवेंट के लिए व्यक्ति या कंपनी का स्टेटस, और
            लेन-देन इवेंट के लिए लेन-देन का स्टेटस। बिना किसी स्टेटस वाले इवेंट
            के लिए `null`।
        webhook_type:
          $ref: '#/components/schemas/WebhookEvent'
        created_at:
          type: string
          format: date-time
          description: जब डिलीवरी बनाई गई थी।
        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 द्वारा लौटाए गए
            रिस्पॉन्स बॉडी को रिकॉर्ड नहीं करता है।
    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.