# POST /api/notifications/events/{id}/replay

Sends one webhook delivery to your endpoint again.

This is the other half of recovering from an outage: list what you missed, then ask for the ones
that did not land to be sent again. The platform resets the delivery and attempts it on its own
delivery path, so the payload, the signature and the headers are the ones your endpoint would
have received.



<b>What replay can recover, and what it cannot.</b> Only a delivery this platform raised and that
ended `Failed`, `DeadLettered` or `Skipped`. An event that never became a delivery
cannot be replayed, because there is nothing to send; neither can one that already succeeded.



<b>It answers with what happened, so it runs while you wait.</b> One attempt is bounded by the
platform's own attempt deadline of two minutes; in practice your endpoint's own timeout ends it
far sooner.



<b>Three separate limits apply, and none of them needs an idempotency key.</b> Your API key's
request limit bounds how often you may ask. A per-endpoint replay budget bounds how much the
platform will send to one address in a window, and a request over it is refused without touching
the delivery. And asking twice for a delivery that has since succeeded is refused, because a
delivered replay is no longer replayable.

**Operation ID:** `notificationsReplayWebhookEvent`

## Authorization

Requires: Notifications.Events.Replay, merchant scope.

Required permissions:
- `Notifications.Events.Replay`

## Parameters

| Name | In | Required | Type | Description |
| --- | --- | --- | --- | --- |
| id | path | yes | string(uuid) | The delivery to replay. |
| suppressNulls | query | no | boolean | If true, omit properties with null values. |

## Responses

### 200

The delivery was reset and attempted. The outcome says whether your endpoint accepted it, refused
it, or was never contacted.

**Content type:** `application/json`

Schema: `WebhookEventReplayResultDto`

Properties:
- `id` (string(uuid)): The delivery that was replayed.
- `outcome` (object): What the platform did about it.

### 403

The credential resolves no single merchant.

### 404

No such delivery for this merchant. A mistyped id, another merchant's id and a delivery on a
channel this surface does not publish are deliberately indistinguishable.

**Content type:** `application/json`

Schema: `RemoteServiceErrorResponse`

Properties:
- `error` (RemoteServiceErrorInfo)

### 409

The delivery is not replayable, or its destination endpoint is currently suppressed. Nothing was
changed either way.

**Content type:** `application/json`

Schema: `RemoteServiceErrorResponse`

Properties:
- `error` (RemoteServiceErrorInfo)

### 429

This endpoint's replay budget for the current window is spent. Nothing was changed; try again
after the window rolls over.

A rate limit refusal carries an `application/problem+json` body instead: wait at least the interval `Retry-After` names before retrying, then back off.

**Content type:** `application/problem+json`

Schema: `RateLimitProblemDetails`

Properties:
- `type` (string) required: The problem type identifier. Always the same value: the failure is the status code itself,  so there is no sub-type for a caller to branch on.
- `title` (string) required: A short, human-readable summary of the problem type.
- `status` (integer(int32)) required: The HTTP status code, repeated in the body as the problem-details format defines.
- `detail` (string) required: A human-readable explanation of this occurrence of the problem.
- `retryAfterSeconds` (integer(int32)) required: How long to wait before retrying, in whole seconds, carrying the same figure as the  `Retry-After` header. Always at least one: a value of zero would invite an immediate  retry that is certain to be rejected again.

**Content type:** `application/json`

Schema: `RemoteServiceErrorResponse`

Properties:
- `error` (RemoteServiceErrorInfo)

### default

The request failed. The body carries the standard error envelope: a machine-readable `error.code`, a human-readable `error.message`, and `error.validationErrors` when the failure was a validation rejection. See the error-code reference in this document's description for the values `error.code` can take.

**Content type:** `application/json`

Schema: `RemoteServiceErrorResponse`

Properties:
- `error` (RemoteServiceErrorInfo)

## Example request

Every block below sends the same request. Replace {{BASE_URL}} with the address of the API you are calling and {{API_KEY}} with your own key.

### cURL

```bash
curl -X POST "{{BASE_URL}}/api/notifications/events/{id}/replay" \
  -H "api-key: {{API_KEY}}"
```

### PowerShell

```powershell
$headers = @{
    'api-key' = '{{API_KEY}}'
}

$response = Invoke-RestMethod -Method POST -Uri '{{BASE_URL}}/api/notifications/events/{id}/replay' `
    -Headers $headers
```

### TypeScript (SDK)

```bash
npm install @winkpg/winkpg-api
```

```typescript
import { Configuration, NotificationsApi } from '@winkpg/winkpg-api';

const api = new NotificationsApi(new Configuration({
  basePath: '{{BASE_URL}}',
  apiKey: '{{API_KEY}}',
}));

const { data } = await api.notificationsReplayWebhookEvent("3fa85f64-5717-4562-b3fc-2c963f66afa6");
```

### TypeScript (raw HTTP)

```typescript
const response = await fetch('{{BASE_URL}}/api/notifications/events/{id}/replay', {
  method: 'POST',
  headers: {
    "api-key": "{{API_KEY}}",
  },
});

const data = await response.json();
```

### C# (SDK)

```bash
dotnet add package WinkPg.Api.Client
```

```csharp
using WinkPg.Api.Client.Api;
using WinkPg.Api.Client.Client;

var config = new Configuration { BasePath = "{{BASE_URL}}" };
config.AddApiKey("api-key", "{{API_KEY}}");

var api = new NotificationsApi(config);
var result = await api.NotificationsReplayWebhookEventAsync(Guid.Parse("3fa85f64-5717-4562-b3fc-2c963f66afa6"));
```

### C# (raw HTTP)

```csharp
using var http = new HttpClient { BaseAddress = new Uri("{{BASE_URL}}") };

var request = new HttpRequestMessage(new HttpMethod("POST"), "/api/notifications/events/{id}/replay");
request.Headers.Add("api-key", "{{API_KEY}}");

var response = await http.SendAsync(request);
response.EnsureSuccessStatusCode();
var json = await response.Content.ReadAsStringAsync();
```

### Python (SDK)

```bash
pip install winkpg-api
```

```python
import winkpg_api

configuration = winkpg_api.Configuration(host="{{BASE_URL}}")
configuration.api_key["ApiKey"] = "{{API_KEY}}"

with winkpg_api.ApiClient(configuration) as client:
    api = winkpg_api.NotificationsApi(client)
    result = api.notifications_replay_webhook_event("3fa85f64-5717-4562-b3fc-2c963f66afa6")
```

### Python (raw HTTP)

```bash
pip install requests
```

```python
import requests

headers = {
    "api-key": "{{API_KEY}}",
}

response = requests.request(
    "POST",
    "{{BASE_URL}}/api/notifications/events/{id}/replay",
    headers=headers,
)
response.raise_for_status()
data = response.json()
```

## See also

- [All documentation](https://devportal-simpay-sbx.winkpg.io/llms.txt): the machine-readable index of every public page on this site.