# Webhooks API

> Endpunkte registrieren, die signierte Event-Benachrichtigungen empfangen.

Basis-URL: `https://api.emailit.com/v2`. Authentifizieren Sie sich mit `Authorization: Bearer <API key>`.

## Webhook erstellen — POST /webhooks

> Registrieren Sie einen HTTP-Endpunkt, der signierte Event-Benachrichtigungen empfängt, und wählen Sie seine Event-Typen sowie ab Pro einen Payload-Filter.

# Webhook erstellen

Erstellt einen Webhook-Endpunkt in Ihrem Workspace. Emailit sendet passende Events in Batches von bis zu 100 an die URL, als JSON-Array, das mit dem `secret` des Webhooks signiert ist. Das Anfrageformat finden Sie unter [Webhook-Anfragen](/de/docs/webhooks/webhook-requests/). Erfordert einen API-Schlüssel mit dem Scope `full`.

`POST /webhooks`

## Anfrage-Body

- `name` (string, erforderlich): Name des Webhooks. Muss im Workspace eindeutig sein; Sie können ihn in den anderen API-Endpunkten für Webhooks statt der ID verwenden.

- `url` (string, erforderlich): Endpunkt, der die Events empfängt. `http`- und `https`-URLs werden akzeptiert; verwenden Sie im Produktivbetrieb `https`. Emailit löst den Hostnamen beim Speichern auf und lehnt `localhost`, private, Link-Local- und andere reservierte IP-Adressen ab. Bei der Zustellung folgt Emailit keinen HTTP-Redirects; verwenden Sie also die endgültige URL.

- `all_events` (boolean): Alle Event-Typen senden, auch später hinzukommende. Standardwert: `false`. Bei `true` wird `events` ignoriert.

- `enabled` (boolean): Ob Emailit Events an den Webhook zustellt. Standardwert: `true`.

- `events` (string[]): Zu sendende Event-Typen, zum Beispiel `["email.delivered", "email.bounced"]`. Siehe [Event-Typen](/de/docs/webhooks/event-types/). Standardwert: `[]`; zusammen mit `all_events: false` empfängt der Webhook dann nichts. Event-Namen werden nicht validiert. Ein falsch geschriebener Typ wird gespeichert, passt aber nie zu einem Event.

- `filter` (object | null): Payload-Filter. Emailit sendet nur Events, deren Objekt den Regeln entspricht. Verfügbar in den Tarifen Pro, Business und Custom; ein Filter mit Regeln gibt bei Pay as you go `403` zurück.

- `filter.match` (string): `all` (Standardwert) sendet ein Event, wenn alle Regeln zutreffen. `any` sendet es, wenn mindestens eine Regel zutrifft.

- `filter.rules` (object[]): Bis zu 25 Regeln.

- `filter.rules[].field` (string, erforderlich): Pfad in Punktnotation innerhalb des Event-Objekts, zum Beispiel `to`, `status`, `meta.plan` oder bei Klick- und Öffnungs-Events `email.campaign.id`. Ein vorangestelltes `payload.` wird ignoriert.

- `filter.rules[].operator` (string, erforderlich): `equals`, `not_equals`, `contains`, `not_contains`, `starts_with`, `ends_with`, `greater_than`, `less_than`, `is_set`, `is_not_set`, `in` oder `not_in`. Textoperatoren vergleichen Werte als Strings; `greater_than` und `less_than` vergleichen Zahlen.

- `filter.rules[].value` (any): Vergleichswert. Erforderlich für alle Operatoren außer `is_set` und `is_not_set`. Verwenden Sie bei `in` und `not_in` ein Array.

## Rückgabe

Gibt `201 Created` mit dem Webhook-Objekt zurück, einschließlich des Signatur-Secrets `secret` (`whsec_` gefolgt von 64 Hexadezimalzeichen). Mit dem Secret [verifizieren Sie die Signaturen der Anfragen](/de/docs/webhooks/request-signature/). Sie können es mit [Webhook abrufen](/de/docs/api-reference/webhooks/get/) erneut auslesen und mit [Signatur-Secret rotieren](/de/docs/api-reference/webhooks/reset-secret/) rotieren.

| Status | Wann |
| --- | --- |
| `400` | `name` oder `url` fehlt, die URL ist ungültig, lässt sich nicht auflösen oder zeigt auf eine blockierte Adresse, oder der Filter ist ungültig. |
| `403` | Der Filter hat Regeln und Ihr Tarif enthält keine Webhook-Filter. Der Body lautet `{"error": "plan_required", "required_plan": "pro"}`. |
| `409` | Ein Webhook mit diesem Namen existiert bereits. Der Body enthält in `existing` die `id` und den `name` des vorhandenen Webhooks. |
| `422` | Der Workspace hat das Webhook-Limit seines Tarifs erreicht. Der Body enthält `usage.used` und `usage.limit`. Siehe [Limits](/de/docs/limits/). |

**Anfrage** `POST /webhooks`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const webhook = await emailit.webhooks.create({
    name: 'Production events',
    url: 'https://api.acme.com/webhooks/emailit',
    events: ['email.delivered']
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

webhook = client.webhooks.create({
    "name": "Production events",
    "url": "https://api.acme.com/webhooks/emailit",
    "events": ["email.delivered"]
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$webhook = $emailit->webhooks()->create([
    'name' => 'Production events',
    'url' => 'https://api.acme.com/webhooks/emailit',
    'events' => ['email.delivered']
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

webhook = client.webhooks.create(
    name: "Production events",
    url: "https://api.acme.com/webhooks/emailit",
    events: ["email.delivered"]
)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

webhook, err := client.Webhooks.Create(&emailit.CreateWebhookRequest{
    Name:   "Production events",
    Url:    "https://api.acme.com/webhooks/emailit",
    Events: []string{"email.delivered"},
})
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let webhook = emailit.webhooks.create(
    emailit::types::CreateWebhookParams::new(
        "Production events",
        "https://api.acme.com/webhooks/emailit"
    ).with_events(vec!["email.delivered".into()])
).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject webhook = emailit.webhooks().create(
    WebhookCreateParams.builder()
        .setName("Production events")
        .setUrl("https://api.acme.com/webhooks/emailit")
        .setEvents(Arrays.asList("email.delivered"))
        .build()
);
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var webhook = emailit.Webhooks.Create(new WebhookCreateOptions {
    Name = "Production events",
    Url = "https://api.acme.com/webhooks/emailit",
    Events = new[] { "email.delivered" }
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$webhook = Emailit::webhooks()->create([
    'name' => 'Production events',
    'url' => 'https://api.acme.com/webhooks/emailit',
    'events' => ['email.delivered']
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/webhooks \
  -H "Authorization: Bearer your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production events",
    "url": "https://api.acme.com/webhooks/emailit",
    "events": ["email.delivered"]
  }'
```

**201**

```json
{
  "object": "webhook",
  "id": "wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e",
  "name": "Production events",
  "url": "https://api.acme.com/webhooks/emailit",
  "all_events": false,
  "enabled": true,
  "events": ["email.delivered", "email.bounced"],
  "filter": null,
  "filters_allowed": true,
  "last_used_at": null,
  "created_at": "2026-10-01T09:41:05.302000+00:00",
  "updated_at": "2026-10-01T09:41:05.302000+00:00",
  "secret": "whsec_175a02aca3fb7dc3107ca21e4224a73d058cacc628356a39e020422aec3ca434"
}
```

**400**

```json
{
  "error": "URL resolves to a private/reserved IP address"
}
```

**403**

```json
{
  "error": "plan_required",
  "required_plan": "pro"
}
```

**409**

```json
{
  "error": "Webhook with this name already exists",
  "existing": {
    "object": "webhook",
    "id": "wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e",
    "name": "Production events"
  }
}
```

**422**

```json
{
  "error": "Pay as you go includes 3 webhook endpoints.",
  "usage": {
    "used": 3,
    "limit": 3
  }
}
```

**Filter**

```json
{
  "name": "Enterprise bounces",
  "url": "https://api.acme.com/webhooks/emailit",
  "events": ["email.bounced", "email.complained"],
  "filter": {
    "match": "all",
    "rules": [
      { "field": "meta.plan", "operator": "equals", "value": "enterprise" },
      { "field": "to", "operator": "not_contains", "value": "@acme.com" }
    ]
  }
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/create/

## Webhook abrufen — GET /webhooks/{id}

> Rufen Sie einen Webhook per ID oder Name ab, mit URL, Event-Typen, Payload-Filter und Signatur-Secret.

# Webhook abrufen

Gibt einen Webhook zurück, gesucht per ID oder Name. Das ist der einzige lesende Endpunkt, der das Signatur-Secret `secret` zurückgibt. Erfordert einen API-Schlüssel mit dem Scope `full`.

`GET /webhooks/:id`

## Pfadparameter

- `id` (string, erforderlich): ID des Webhooks (`wh_…`) oder sein Name, URL-kodiert.

## Rückgabe

Gibt `200 OK` mit dem Webhook-Objekt zurück, einschließlich `secret` und `filters_allowed` (ob Ihr Tarif dem Webhook einen Payload-Filter erlaubt). `last_used_at` ist der Zeitpunkt der letzten erfolgreichen Zustellung oder `null`, wenn noch nichts zugestellt wurde.

Gibt `404` mit `error: "Webhook not found"` zurück, wenn kein Webhook passt.

**Anfrage** `GET /webhooks/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const webhook = await emailit.webhooks.get('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

webhook = client.webhooks.get("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$webhook = $emailit->webhooks()->get('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

webhook = client.webhooks.get("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

webhook, err := client.Webhooks.Get("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e")
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let webhook = emailit.webhooks.get("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e").await?;
```

**Java**

```java
import com.emailit.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject webhook = emailit.webhooks().get("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e");
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var webhook = emailit.Webhooks.Get("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$webhook = Emailit::webhooks()->get('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e');
```

**cURL**

```bash
curl https://api.emailit.com/v2/webhooks/wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e \
  -H "Authorization: Bearer your_api_key"
```

**200**

```json
{
  "object": "webhook",
  "id": "wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e",
  "name": "Production events",
  "url": "https://api.acme.com/webhooks/emailit",
  "all_events": false,
  "enabled": true,
  "events": ["email.delivered", "email.bounced"],
  "filter": {
    "match": "all",
    "rules": [
      { "field": "meta.plan", "operator": "equals", "value": "enterprise" }
    ]
  },
  "filters_allowed": true,
  "last_used_at": "2026-10-01T10:02:17.845000+00:00",
  "created_at": "2026-10-01T09:41:05.302000+00:00",
  "updated_at": "2026-10-01T09:41:05.302000+00:00",
  "secret": "whsec_175a02aca3fb7dc3107ca21e4224a73d058cacc628356a39e020422aec3ca434"
}
```

**404**

```json
{
  "error": "Webhook not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/get/

## Webhook aktualisieren — POST /webhooks/{id}

> Ändern Sie Name, URL, Event-Typen, Payload-Filter oder Aktivierungsstatus eines Webhooks, den Sie per ID oder Name angeben.

# Webhook aktualisieren

Aktualisiert einen Webhook. Senden Sie nur die Felder, die Sie ändern möchten; mindestens eines ist erforderlich. Das Signatur-Secret ändert sich nicht; Sie rotieren es mit [Signatur-Secret rotieren](/de/docs/api-reference/webhooks/reset-secret/). Erfordert einen API-Schlüssel mit dem Scope `full`.

`POST /webhooks/:id`

## Pfadparameter

- `id` (string, erforderlich): ID des Webhooks (`wh_…`) oder sein Name, URL-kodiert.

## Anfrage-Body

- `name` (string): Neuer Name. Muss im Workspace eindeutig sein.

- `url` (string): Neue URL des Endpunkts, `http` oder `https`. Wird genauso validiert wie beim [Erstellen](/de/docs/api-reference/webhooks/create/).

- `all_events` (boolean): `true` sendet alle Event-Typen und leert die Liste `events`. Wenn Sie den Wert auf `false` setzen, senden Sie auch `events`, sonst empfängt der Webhook nichts.

- `enabled` (boolean): `false` stoppt Zustellungen, `true` nimmt sie wieder auf. Events, die auftreten, während der Webhook deaktiviert ist, werden für ihn nicht in die Warteschlange gestellt und auch später nicht gesendet.

- `events` (string[]): Ersetzt die Liste der Event-Typen. Wird ignoriert, solange `all_events` den Wert `true` hat. Namen werden nicht validiert.

- `filter` (object | null): Ersetzt den Payload-Filter, im selben Format wie beim [Erstellen](/de/docs/api-reference/webhooks/create/). Senden Sie `null`, um ihn zu entfernen. Ein Filter mit Regeln setzt den Tarif Pro, Business oder Custom voraus.

## Rückgabe

Gibt `200 OK` mit dem aktualisierten Webhook zurück. Das `secret` ist nicht enthalten; lesen Sie es mit [Webhook abrufen](/de/docs/api-reference/webhooks/get/) aus.

| Status | Wann |
| --- | --- |
| `400` | Der Body enthält keines der obigen Felder oder URL bzw. Filter sind ungültig. |
| `403` | Der Filter hat Regeln und Ihr Tarif enthält keine Webhook-Filter (`plan_required`). |
| `404` | Kein Webhook passt zu `id`. |
| `409` | Ein anderer Webhook verwendet bereits den neuen Namen. |

**Anfrage** `POST /webhooks/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const webhook = await emailit.webhooks.update('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e', {
    enabled: false
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

webhook = client.webhooks.update("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e", {
    "enabled": False
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$webhook = $emailit->webhooks()->update('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e', [
    'enabled' => false
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

webhook = client.webhooks.update("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e", enabled: false)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

webhook, err := client.Webhooks.Update("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e", &emailit.UpdateWebhookRequest{
    Enabled: false,
})
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let webhook = emailit.webhooks.update("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e",
    emailit::types::UpdateWebhookParams {
        enabled: Some(false),
        ..Default::default()
    }
).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject webhook = emailit.webhooks().update("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e",
    WebhookUpdateParams.builder()
        .setEnabled(false)
        .build()
);
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var webhook = emailit.Webhooks.Update("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e", new WebhookUpdateOptions {
    Enabled = false
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$webhook = Emailit::webhooks()->update('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e', [
    'enabled' => false
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/webhooks/wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e \
  -H "Authorization: Bearer your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"enabled": false}'
```

**200**

```json
{
  "object": "webhook",
  "id": "wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e",
  "name": "Production events",
  "url": "https://api.acme.com/webhooks/emailit",
  "all_events": false,
  "enabled": false,
  "events": ["email.delivered", "email.bounced"],
  "filter": null,
  "filters_allowed": true,
  "last_used_at": "2026-10-01T10:02:17.845000+00:00",
  "created_at": "2026-10-01T09:41:05.302000+00:00",
  "updated_at": "2026-10-01T10:15:40.000000+00:00"
}
```

**400**

```json
{
  "error": "No valid fields provided for update. Provide at least one of: name, url, all_events, enabled, events, filter"
}
```

**404**

```json
{
  "error": "Webhook not found"
}
```

**409**

```json
{
  "error": "Another webhook with this name already exists"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/update/

## Webhooks auflisten — GET /webhooks

> Listen Sie die Webhooks in Ihrem Workspace auf, mit Suche, Filtern und seitenbasierter Paginierung, dazu die Webhook-Nutzung Ihres Tarifs.

# Webhooks auflisten

Gibt die Webhooks in Ihrem Workspace zurück, die neuesten zuerst, und wie viele Ihr Tarif erlaubt. Signatur-Secrets sind in der Liste nicht enthalten. Erfordert einen API-Schlüssel mit dem Scope `full`.

`GET /webhooks`

## Query-Parameter

- `page` (integer): Seitennummer, beginnend bei `1`. Standardwert: `1`.

- `limit` (integer): Webhooks pro Seite, von `1` bis `100`. Standardwert: `10`.

- `search` (string): Abgleich mit Name oder URL des Webhooks, ohne Beachtung der Groß-/Kleinschreibung.

- `match`, `order`, `direction`: siehe [Filtern und Sortieren](https://emailit.com/de/docs/api-reference/filtering/).

## Filter und Sortierung

Filter- und Sortierschlüssel: siehe [Filtern und Sortieren](https://emailit.com/de/docs/api-reference/filtering/).

## Rückgabe

Gibt `200 OK` mit den Webhooks in `data`, mit `next_page_url` und `previous_page_url` (`null` am jeweiligen Ende) sowie einem Objekt `usage` zurück: `used` ist die Anzahl der Webhooks im Workspace, `limit` das Maximum Ihres Tarifs und `filters_allowed` gibt an, ob Ihr Tarif Payload-Filter enthält.

**Anfrage** `GET /webhooks`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const webhooks = await emailit.webhooks.list();
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

webhooks = client.webhooks.list()
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$webhooks = $emailit->webhooks()->list();
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

webhooks = client.webhooks.list
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

webhooks, err := client.Webhooks.List(nil)
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let webhooks = emailit.webhooks.list(None).await?;
```

**Java**

```java
import com.emailit.*;
EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject webhooks = emailit.webhooks().list();
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

var webhooks = emailit.Webhooks.List();
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$webhooks = Emailit::webhooks()->list();
```

**cURL**

```bash
curl https://api.emailit.com/v2/webhooks \
  -H "Authorization: Bearer your_api_key"
```

**200**

```json
{
  "data": [
    {
      "object": "webhook",
      "id": "wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e",
      "name": "Production events",
      "url": "https://api.acme.com/webhooks/emailit",
      "all_events": false,
      "enabled": true,
      "events": ["email.delivered", "email.bounced"],
      "filter": null,
      "filters_allowed": true,
      "last_used_at": "2026-10-01T10:02:17.845000+00:00",
      "created_at": "2026-10-01T09:41:05.302000+00:00",
      "updated_at": "2026-10-01T10:02:17.845000+00:00"
    }
  ],
  "next_page_url": null,
  "previous_page_url": null,
  "usage": {
    "used": 1,
    "limit": 10,
    "filters_allowed": true
  }
}
```

**401**

```json
{
  "statusCode": 401,
  "error": "Unauthorized",
  "message": "Invalid API key"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/list/

## Webhook löschen — DELETE /webhooks/{id}

> Löschen Sie einen Webhook per ID oder Name. Emailit sendet keine Events mehr an seine URL, auch keine noch ausstehenden Wiederholungen.

# Webhook löschen

Löscht einen Webhook und seine Event-Abonnements endgültig. Um Zustellungen vorübergehend zu stoppen, [aktualisieren Sie den Webhook](/de/docs/api-reference/webhooks/update/) stattdessen mit `enabled: false`. Erfordert einen API-Schlüssel mit dem Scope `full`.

`DELETE /webhooks/:id`

## Pfadparameter

- `id` (string, erforderlich): ID des Webhooks (`wh_…`) oder sein Name, URL-kodiert.

## Rückgabe

Gibt `200 OK` mit `id` und `name` des gelöschten Webhooks sowie `deleted: true` zurück. Gibt `404` mit `error: "Webhook not found"` zurück, wenn kein Webhook passt.

**Anfrage** `DELETE /webhooks/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

await emailit.webhooks.delete('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

client.webhooks.delete("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$emailit->webhooks()->delete('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

client.webhooks.delete("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

err := client.Webhooks.Delete("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e")
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

emailit.webhooks.delete("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e").await?;
```

**Java**

```java
import com.emailit.*;
EmailitClient emailit = new EmailitClient("your_api_key");

emailit.webhooks().delete("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e");
```

**.NET**

```csharp
using Emailit;
var emailit = new EmailitClient("your_api_key");

emailit.Webhooks.Delete("wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

Emailit::webhooks()->delete('wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e');
```

**cURL**

```bash
curl -X DELETE https://api.emailit.com/v2/webhooks/wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e \
  -H "Authorization: Bearer your_api_key"
```

**200**

```json
{
  "object": "webhook",
  "id": "wh_2xLb3Kp9Qr1Vt7Mn5Ws0Yd4Hc8e",
  "name": "Production events",
  "deleted": true
}
```

**404**

```json
{
  "error": "Webhook not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/delete/

## Test-Event senden — POST /webhooks/{id}/test

> Senden Sie ein signiertes Beispiel-Event beliebigen Typs an einen Webhook-Endpunkt und erhalten Sie sofort die Antwort des Endpunkts.

# Test-Event senden

Sendet ein Beispiel-Event des gewählten Typs an die URL des Webhooks und gibt die Antwort Ihres Endpunkts zurück. So prüfen Sie, ob Ihr Endpunkt erreichbar ist und [Signaturen](/de/docs/webhooks/request-signature/) korrekt verifiziert. Erfordert einen API-Schlüssel mit dem Scope `full`.

Die Anfrage hat dasselbe Format, dieselben Header und dieselbe Signatur wie eine echte Zustellung: ein JSON-Array mit einem Event, dessen `event_id` mit `evt_test_` beginnt, signiert mit dem aktuellen Secret des Webhooks. Sie wird auch gesendet, wenn der Webhook deaktiviert ist oder diesen Typ nicht abonniert hat, wird nicht als Webhook-Anfrage gespeichert und nicht wiederholt. Die Beispieldaten sind fest vorgegeben und beziehen sich nicht auf echte Objekte.

Sie können 5 Test-Events pro Minute von derselben IP-Adresse senden; weitere geben `429` zurück.

`POST /webhooks/{id}/test`

## Pfadparameter

- `id` (string, erforderlich): Die ID des Webhooks (`wh_…`) oder sein Name.

## Body-Parameter

- `type` (string, erforderlich): Der zu sendende Event-Typ. Einer der Typen unten.

| Ressource | Event-Typen |
| --- | --- |
| E-Mail | `email.accepted`, `email.scheduled`, `email.delivered`, `email.bounced`, `email.attempted`, `email.failed`, `email.rejected`, `email.clicked`, `email.loaded`, `email.complained`, `email.received`, `email.suppressed`, `email.canceled`, `email.unsubscribed`, `email.resubscribed` |
| Domain | `domain.created`, `domain.updated`, `domain.deleted` |
| Kontaktliste | `audience.created`, `audience.updated`, `audience.deleted` |
| Abonnent | `subscriber.created`, `subscriber.updated`, `subscriber.deleted` |
| Kontakt | `contact.created`, `contact.updated`, `contact.deleted` |
| Vorlage | `template.created`, `template.updated`, `template.deleted` |
| Sperrung | `suppression.created`, `suppression.updated`, `suppression.deleted` |
| E-Mail-Verifizierung | `email_verification.created`, `email_verification.updated`, `email_verification_list.created`, `email_verification_list.updated` |
| Kampagne | `campaign.created`, `campaign.updated`, `campaign.deleted`, `campaign.scheduled`, `campaign.queued`, `campaign.sending`, `campaign.testing`, `campaign.sent`, `campaign.canceled`, `campaign.archived` |

Was jedes Event bedeutet, erfahren Sie unter [Event-Typen](/de/docs/webhooks/event-types/).

## Rückgabe

- `ok` (boolean): `true`, wenn Ihr Endpunkt mit einem 2xx-Status geantwortet hat.

- `status_code` (integer): Der HTTP-Status Ihres Endpunkts. `0`, wenn Emailit keine Verbindung herstellen konnte, die Anfrage nach 30 Sekunden in ein Timeout lief, der Endpunkt umgeleitet hat (HTTP-Redirects werden nicht verfolgt) oder die URL auf eine blockierte Adresse zeigt.

- `body` (string): Die ersten 2.000 Zeichen der Antwort Ihres Endpunkts oder der Verbindungsfehler.

- `type` (string): Der gesendete Event-Typ.

- `payload` (object[]): Das exakte JSON-Array, das gesendet wurde.

Gibt `400` zurück, wenn `type` fehlt oder unbekannt ist, `404`, wenn der Webhook nicht existiert, und `429`, wenn Sie das Testlimit überschreiten.

**Anfrage** `POST /webhooks/{id}/test`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/test \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "type": "email.delivered" }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/test', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ type: 'email.delivered' }),
});
const { ok, status_code, body } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/test",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={"type": "email.delivered"},
)
result = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/test', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => ['type' => 'email.delivered'],
]);
$result = json_decode($response->getBody(), true);
```

**200**

```json
{
  "ok": true,
  "status_code": 200,
  "type": "email.delivered",
  "payload": [
    {
      "event_id": "evt_test_3G0pUekgBm1uIxi9m4C380H70Zq",
      "type": "email.delivered",
      "object": {
        "id": "eml_test_001",
        "email_id": 12345,
        "message_id": "<test-token@mydomain.com>",
        "from": "sender@mydomain.com",
        "to": "recipient@example.com",
        "subject": "Test email",
        "status": "delivered",
        "delivered_at": "2026-01-15T10:30:00.000Z"
      },
      "data": {
        "object": {
          "id": "eml_test_001",
          "email_id": 12345,
          "message_id": "<test-token@mydomain.com>",
          "from": "sender@mydomain.com",
          "to": "recipient@example.com",
          "subject": "Test email",
          "status": "delivered",
          "delivered_at": "2026-01-15T10:30:00.000Z"
        }
      }
    }
  ],
  "body": "{\"received\":true}"
}
```

**400**

```json
{
  "error": "Unknown event type"
}
```

**429**

```json
{
  "statusCode": 429,
  "error": "Too Many Requests",
  "message": "Rate limit exceeded, retry in 1 minute"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/test/

## Signatur-Secret rotieren — POST /webhooks/{id}/reset-secret

> Ersetzen Sie das Signatur-Secret eines Webhooks. Jede Zustellung nach der Rotation, einschließlich Wiederholungen, wird mit dem neuen Secret signiert.

# Signatur-Secret rotieren

Erzeugt ein neues Signatur-Secret für den Webhook und gibt es zurück. Erfordert einen API-Schlüssel mit dem Scope `full`.

Das alte Secret wird sofort nicht mehr verwendet: Jede nach der Rotation gesendete Anfrage, einschließlich Wiederholungen früherer Events, wird mit dem neuen Secret signiert. Es gibt keinen Übergangszeitraum; aktualisieren Sie das Secret in Ihrem Endpunkt also direkt nach der Rotation oder akzeptieren Sie während der Umstellung kurzzeitig beide Secrets. Siehe [Webhook-Signaturen verifizieren](/de/docs/webhooks/request-signature/).

`POST /webhooks/{id}/reset-secret`

## Pfadparameter

- `id` (string, erforderlich): Die ID des Webhooks (`wh_…`) oder sein Name.

## Rückgabe

Gibt das Webhook-Objekt mit dem neuen `secret` zurück (`whsec_` gefolgt von 64 Hexadezimalzeichen). Gibt `404` zurück, wenn der Webhook nicht existiert.

**Anfrage** `POST /webhooks/{id}/reset-secret`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/reset-secret \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/reset-secret', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { secret } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/reset-secret",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
secret = r.json()["secret"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/reset-secret', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$secret = json_decode($response->getBody(), true)['secret'];
```

**200**

```json
{
  "object": "webhook",
  "id": "wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ",
  "name": "Order notifications",
  "url": "https://acme.com/webhooks/emailit",
  "all_events": false,
  "enabled": true,
  "events": ["email.delivered", "email.bounced", "email.complained"],
  "filter": null,
  "last_used_at": "2026-10-01T12:58:40.000000+00:00",
  "created_at": "2026-08-14T09:12:03.000000+00:00",
  "updated_at": "2026-10-01T13:20:11.000000+00:00",
  "secret": "whsec_a0a593d006bdec5aff2f21e88afd543ba239431acbe7d8dc7a9723d76e0a64e2"
}
```

**404**

```json
{
  "error": "Webhook not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/reset-secret/

## Fehlgeschlagene Anfragen wiederholen — POST /webhooks/{id}/retry-failed

> Stellen Sie alle endgültig fehlgeschlagenen Webhook-Anfragen der letzten 7 Tage erneut zur Zustellung in die Warteschlange und aktivieren Sie den Webhook wieder.

# Fehlgeschlagene Anfragen wiederholen

Stellt jede Anfrage dieses Webhooks, die in den letzten 7 Tagen endgültig fehlgeschlagen ist, erneut zur Zustellung in die Warteschlange. Erfordert einen API-Schlüssel mit dem Scope `full`.

Eine Anfrage schlägt nach ihrer letzten automatischen Wiederholung endgültig fehl (11 Versuche über mehrere Tage; siehe [Wiederholungen und Fehlschläge](/de/docs/webhooks/retries-and-failures/)). Erneut gestellte Anfragen beginnen wieder mit dem vollständigen Wiederholungsplan und werden innerhalb von Sekunden zugestellt. Wird mindestens eine Anfrage in die Warteschlange gestellt und war der Webhook deaktiviert, etwa nach 3 Tagen durchgehender Fehlschläge, wird er wieder aktiviert.

Beheben Sie zuerst das Problem an Ihrem Endpunkt, sonst schlagen die Anfragen erneut fehl. Um eine einzelne Anfrage zu wiederholen, nutzen Sie [Einzelne Anfrage wiederholen](/de/docs/api-reference/webhooks/retry-request/).

`POST /webhooks/{id}/retry-failed`

## Pfadparameter

- `id` (string, erforderlich): Die ID des Webhooks (`wh_…`) oder sein Name.

## Rückgabe

- `retried` (integer): Anzahl der erneut in die Warteschlange gestellten Anfragen. `0`, wenn es nichts zu wiederholen gab; der Aktivierungsstatus des Webhooks ändert sich dann nicht.

Gibt `404` zurück, wenn der Webhook nicht existiert.

**Anfrage** `POST /webhooks/{id}/retry-failed`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/retry-failed \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/retry-failed', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { retried } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/retry-failed",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
retried = r.json()["retried"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/retry-failed', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$retried = json_decode($response->getBody(), true)['retried'];
```

**200**

```json
{
  "retried": 37
}
```

**404**

```json
{
  "error": "Webhook not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/retry-failed/

## Einzelne Anfrage wiederholen — POST /webhooks/{id}/requests/{request_id}/retry

> Stellen Sie eine einzelne endgültig fehlgeschlagene Webhook-Anfrage erneut zur Zustellung in die Warteschlange und aktivieren Sie den Webhook wieder, falls er deaktiviert war.

# Einzelne Anfrage wiederholen

Stellt eine endgültig fehlgeschlagene Webhook-Anfrage mit einem neuen Wiederholungsplan erneut zur Zustellung in die Warteschlange. War der Webhook deaktiviert, wird er wieder aktiviert. Erfordert einen API-Schlüssel mit dem Scope `full`.

Nur Anfragen, deren automatische Wiederholungen ausgeschöpft sind, lassen sich auf diese Weise wiederholen; für noch ausstehende oder gerade wiederholte Anfragen gibt der Endpunkt `400` zurück. Anfrage-IDs (`whr_…`) finden Sie im Tab **Requests** des Webhooks unter **Email API → Webhooks**. Um alle Anfragen der letzten 7 Tage auf einmal zu wiederholen, nutzen Sie [Fehlgeschlagene Anfragen wiederholen](/de/docs/api-reference/webhooks/retry-failed/).

`POST /webhooks/{id}/requests/{request_id}/retry`

## Pfadparameter

- `id` (string, erforderlich): Die ID des Webhooks (`wh_…`) oder sein Name.

- `request_id` (string, erforderlich): Die ID der Webhook-Anfrage (`whr_…`).

## Rückgabe

- `retried` (integer): Immer `1`.

- `id` (string): Die ID der Anfrage, die in die Warteschlange gestellt wurde.

| Status | Wann |
| --- | --- |
| `400` | Die Anfrage ist nicht endgültig fehlgeschlagen oder hat kein Event, das erneut gesendet werden kann. |
| `404` | Der Webhook existiert nicht oder die Anfrage gehört nicht zu ihm. |

**Anfrage** `POST /webhooks/{id}/requests/{request_id}/retry`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/requests/whr_3tWVVMd2eHv3R9B5DWTLtwwU05X/retry \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch(
  'https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/requests/whr_3tWVVMd2eHv3R9B5DWTLtwwU05X/retry',
  { method: 'POST', headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const result = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/requests/whr_3tWVVMd2eHv3R9B5DWTLtwwU05X/retry",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
result = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('webhooks/wh_3NGa6raJ3s1VJ75lO9km6Dqg4cQ/requests/whr_3tWVVMd2eHv3R9B5DWTLtwwU05X/retry', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$result = json_decode($response->getBody(), true);
```

**200**

```json
{
  "retried": 1,
  "id": "whr_3tWVVMd2eHv3R9B5DWTLtwwU05X"
}
```

**400**

```json
{
  "error": "Only permanently failed requests can be retried"
}
```

**404**

```json
{
  "error": "Webhook request not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/webhooks/retry-request/