> ## Documentation Index
> Fetch the complete documentation index at: https://widgetic.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Send a webhook delivery again

> Sends one earlier **webhook** delivery again to your **current** webhook address, with the same event `id`
(`webhook-id`) as the original notification so a receiver that remembers ids can ignore a duplicate, and a
new `createdAt` and signature made with your current secret. The attempt is recorded in the delivery log as a
new row that points at the delivery you replayed.

Set a webhook address (and secret) under notification settings before you replay. Changing the settings needs
an API key with full access. The caller must be the person who administers the partner, or a Widgetic
administrator.




## OpenAPI

````yaml /openapi/widgetic-api-public.json post /partners/{partnerId}/notifications/deliveries/{deliveryId}/replay
openapi: 3.0.0
info:
  title: Widgetic API Gateway
  version: 1.0.0
  description: API documentation for the Widgetic API Gateway
  license:
    name: Widgetic Integration License
    url: https://docs.widgetic.com/resources/license
servers:
  - url: https://api.widgetic.com/v1
    description: Production server
    variables:
      env:
        default: production
        description: Environment
      apiUrl:
        default: https://api.widgetic.com
        description: API URL
      apiVersion:
        default: /v1
        description: API Version path prefix
security: []
tags: []
paths:
  /partners/{partnerId}/notifications/deliveries/{deliveryId}/replay:
    post:
      tags:
        - Partners
      summary: Send a webhook delivery again
      description: >
        Sends one earlier **webhook** delivery again to your **current** webhook
        address, with the same event `id`

        (`webhook-id`) as the original notification so a receiver that remembers
        ids can ignore a duplicate, and a

        new `createdAt` and signature made with your current secret. The attempt
        is recorded in the delivery log as a

        new row that points at the delivery you replayed.


        Set a webhook address (and secret) under notification settings before
        you replay. Changing the settings needs

        an API key with full access. The caller must be the person who
        administers the partner, or a Widgetic

        administrator.
      operationId: replayPartnerNotificationDelivery
      parameters:
        - in: path
          name: partnerId
          required: true
          schema:
            type: string
            format: uuid
          description: The partner whose delivery to replay
        - in: path
          name: deliveryId
          required: true
          schema:
            type: string
            format: uuid
          description: >-
            The delivery to send again (must be a webhook delivery of this
            partner)
        - $ref: '#/components/parameters/IdempotencyKeyRequired'
      responses:
        '200':
          description: The replay was attempted; the new delivery row
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PartnerNotificationDeliveryResponse'
              example:
                success: true
                data:
                  deliveryId: a1a1a1a1-1111-4111-8111-111111111111
                  notificationId: b2b2b2b2-2222-4222-8222-222222222222
                  eventType: composition.created
                  title: Composition created
                  channel: webhook
                  target: hooks.example.com
                  status: delivered
                  attemptCount: 1
                  nextAttemptAt: null
                  lastAttemptAt: '2026-10-09T12:00:00.000Z'
                  deliveredAt: '2026-10-09T12:00:00.000Z'
                  lastStatusCode: 200
                  lastError: null
                  createdAt: '2026-10-09T12:00:00.000Z'
                  replayOfDeliveryId: c3c3c3c3-3333-4333-8333-333333333333
        '401':
          description: The API key is missing or invalid
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: >-
            The caller does not administer this partner, or the API key has not
            full access
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: There is no such partner or delivery (NOT_FOUND)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '409':
          description: >-
            The replay cannot be sent now (BUSINESS_STATE_CONFLICT), for example
            because no webhook address is set
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: >-
            Too many replays in a short time. Try again after the Retry-After
            seconds.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - apiKeyAuth: []
      x-code-samples:
        - lang: TypeScript
          label: TypeScript SDK
          source: >
            import { randomUUID } from 'node:crypto';

            import { Configuration, PartnersApi } from '@widgetic/api-sdk-ts';


            const partnersApi = new PartnersApi(new Configuration({ apiKey:
            'YOUR_API_KEY' }));


            const { data: delivery } = await
            partnersApi.replayPartnerNotificationDelivery({
              partnerId,
              deliveryId: 'c3c3c3c3-3333-4333-8333-333333333333',
              idempotencyKey: randomUUID(),
            });
components:
  parameters:
    IdempotencyKeyRequired:
      in: header
      name: Idempotency-Key
      required: true
      description: >-
        Required: a call without it is refused with `400`. A key of your own
        that names this one request; a UUID is ideal. It is 8 to 50 characters
        of letters, digits, `-` and `_`. Send the same key again when you retry
        (after a timeout, a dropped connection or a `5xx`) and the call is
        carried out once: the retry gets the first answer back, marked
        `X-Idempotency-Cached: true`. The same key with a different body is
        refused with `422`, and a retry that arrives while the first call is
        still running with `409` (see `Retry-After`).
      schema:
        type: string
        minLength: 8
        maxLength: 50
        pattern: ^[a-zA-Z0-9_-]{8,50}$
        example: 9b2d6f0a-3c41-4e5a-8d77-1f2e3a4b5c6d
  schemas:
    PartnerNotificationDeliveryResponse:
      type: object
      required:
        - success
        - data
      properties:
        success:
          type: boolean
          description: Always `true` on a success.
          example: true
        data:
          $ref: '#/components/schemas/PartnerNotificationDelivery'
        meta:
          $ref: '#/components/schemas/ResponseMeta'
    ErrorResponse:
      type: object
      required:
        - success
        - message
        - error
      additionalProperties: true
      properties:
        success:
          type: boolean
          description: Always `false` on a failure.
          example: false
        message:
          type: string
          description: The same text as `error.message`, for a caller that reads one line.
        error:
          $ref: '#/components/schemas/ErrorDetail'
    PartnerNotificationDelivery:
      type: object
      description: >-
        One send of one notification, to one email address or to your webhook.
        It stays `pending` while it is being tried again, and ends `delivered`,
        `failed` (given up on) or `cancelled` (nobody wanted it any more, for
        example because the webhook was switched off).
      required:
        - deliveryId
        - notificationId
        - eventType
        - title
        - channel
        - target
        - status
        - attemptCount
        - nextAttemptAt
        - lastAttemptAt
        - deliveredAt
        - lastStatusCode
        - lastError
        - createdAt
        - replayOfDeliveryId
      properties:
        deliveryId:
          type: string
          format: uuid
        notificationId:
          type: string
          format: uuid
        eventType:
          type: string
          nullable: true
          description: >-
            What the notification was about. Null when the notification has been
            removed.
        title:
          type: string
          nullable: true
        channel:
          type: string
          enum:
            - email
            - webhook
        target:
          type: string
          description: >-
            The email address, or the host of your webhook (never the whole
            address, which may hold a token)
        status:
          type: string
          enum:
            - pending
            - delivered
            - failed
            - cancelled
        attemptCount:
          type: integer
        nextAttemptAt:
          type: string
          format: date-time
          nullable: true
          description: When the next attempt is made. Null once the delivery has ended.
        lastAttemptAt:
          type: string
          format: date-time
          nullable: true
        deliveredAt:
          type: string
          format: date-time
          nullable: true
        lastStatusCode:
          type: integer
          nullable: true
          description: >-
            The HTTP status your webhook answered with at the last attempt, when
            it answered
        lastError:
          type: string
          nullable: true
          description: >-
            Why the last attempt failed, in a few words. Never what your
            endpoint replied.
        createdAt:
          type: string
          format: date-time
        replayOfDeliveryId:
          type: string
          format: uuid
          nullable: true
          description: When this row is a manual replay, the earlier delivery it sent again
      example:
        deliveryId: 3fa85f64-5717-4562-b3fc-2c963f66afa6
        notificationId: 3fa85f64-5717-4562-b3fc-2c963f66afa6
        eventType: Example eventType
        title: Example title
        channel: Example channel
        target: Example target
        status: Example status
        attemptCount: 42
        nextAttemptAt: '2026-01-15T09:30:00.000Z'
        lastAttemptAt: '2026-01-15T09:30:00.000Z'
        deliveredAt: '2026-01-15T09:30:00.000Z'
        lastStatusCode: 42
        lastError: Example lastError
        createdAt: '2026-01-15T09:30:00.000Z'
        replayOfDeliveryId: 3fa85f64-5717-4562-b3fc-2c963f66afa6
    ResponseMeta:
      type: object
      description: >-
        Extra information about the answer: where a page sits in a list, the
        cursor of the next page, or warnings about a call that succeeded with a
        caveat.
      additionalProperties: true
      properties:
        page:
          type: integer
          description: The page that was read, counting from 1.
          example: 1
        size:
          type: integer
          description: How many items one page holds.
          example: 20
        total:
          type: integer
          description: How many items the whole list has.
          example: 135
        limit:
          type: integer
          description: The same as `size`.
          example: 20
        offset:
          type: integer
          description: How many items come before this page.
          example: 0
        hasNextPage:
          type: boolean
          example: true
        hasPreviousPage:
          type: boolean
          example: false
        nextCursor:
          type: string
          nullable: true
          description: >-
            Pass this as `cursor` to read the next page of a list that is read
            by cursor. `null` on the last page.
        warnings:
          type: array
          items:
            type: string
          description: >-
            Things the call did not do, though it succeeded (for example a table
            that could not be created just now).
    ErrorDetail:
      type: object
      required:
        - code
        - message
        - timestamp
      properties:
        code:
          type: string
          description: Machine-readable error code.
          example: RESOURCE_NOT_FOUND
        message:
          type: string
          description: Human-readable explanation.
          example: Composition not found
        param:
          type: string
          description: The field that caused the error, when one did.
          example: name
        docUrl:
          type: string
          description: Where this error is explained.
        suggestedAction:
          type: string
          description: What to do about it.
        retryAfter:
          type: integer
          description: >-
            Seconds to wait before trying again (rate limits). The same number
            is in the `Retry-After` header.
          example: 60
        details:
          type: object
          additionalProperties: true
          description: >-
            More about the error: the fields that failed, a limit that was
            reached.
        correlationId:
          type: string
          description: Quote this when you ask support about the call.
          example: req_123e4567-e89b-12d3-a456-426614174000
        timestamp:
          type: string
          format: date-time
          example: '2026-10-15T10:00:00.000Z'
  securitySchemes:
    apiKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

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