Überblick
Notifuse kennt zwei Arten von Webhooks:
-
Eingehende Webhooks: Callbacks von E-Mail-Anbietern (Amazon SES, Mailgun, Postmark usw.), die Notifuse über Bounces, Beschwerden, Zustellungen und andere E-Mail-Ereignisse informieren. Sie werden automatisch konfiguriert, wenn Sie eine E-Mail-Integration einrichten.
-
Ausgehende Webhooks: HTTP-Callbacks, die Notifuse an Ihren Server sendet, wenn Ereignisse eintreten. Um diese geht es auf dieser Seite.
Ein ausgehender Webhook sendet eine HTTP-POST-Anfrage an Ihren Server, wenn in Notifuse ein bestimmtes Ereignis eintritt. Damit können Sie:
- Kontaktdaten mit Ihrem CRM oder anderen Systemen synchronisieren
- Workflows in externen Automatisierungstools auslösen
- Eigene Integrationen und Dashboards bauen
- In Echtzeit auf Interaktionen mit Ihren E-Mails reagieren
Webhook-Abonnement anlegen
Legen Sie ein Webhook-Abonnement in der Konsole unter Einstellungen → Webhooks → Endpunkt hinzufügen an. Dort wählen Sie die URL und die Ereignistypen:
Oder legen Sie es über die API an:
curl -X POST "https://your-instance.com/api/webhookSubscriptions.create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"workspace_id": "your_workspace",
"name": "Production Webhook",
"url": "https://api.example.com/webhooks/notifuse",
"event_types": ["contact.created", "contact.updated", "email.sent"]
}'
Verfügbare Ereignistypen
Kontaktereignisse
| Ereignis | Beschreibung |
|---|---|
contact.created | Ein neuer Kontakt wurde dem Arbeitsbereich hinzugefügt |
contact.updated | Kontaktdaten wurden geändert |
contact.deleted | Ein Kontakt wurde endgültig gelöscht |
Listenereignisse
| Ereignis | Beschreibung |
|---|---|
list.subscribed | Kontakt hat eine Liste abonniert |
list.unsubscribed | Kontakt hat sich von einer Liste abgemeldet |
list.confirmed | Kontakt hat ein Double-Opt-in-Abonnement bestätigt |
list.resubscribed | Zuvor abgemeldeter Kontakt hat sich erneut angemeldet |
list.bounced | E-Mail an den Kontakt wurde zurückgewiesen |
list.complained | Kontakt hat eine E-Mail als Spam markiert |
list.pending | Abonnement des Kontakts wartet auf Bestätigung |
list.removed | Kontakt wurde aus der Liste entfernt |
Segmentereignisse
| Ereignis | Beschreibung |
|---|---|
segment.joined | Kontakt ist in ein Segment eingetreten (erfüllt die Segmentkriterien) |
segment.left | Kontakt hat ein Segment verlassen (erfüllt die Kriterien nicht mehr) |
E-Mail-Ereignisse
| Ereignis | Beschreibung |
|---|---|
email.sent | E-Mail wurde an den Kontakt gesendet |
email.delivered | Der Server des Empfängers hat die Zustellung bestätigt |
email.opened | Kontakt hat die E-Mail geöffnet |
email.clicked | Kontakt hat einen Link in der E-Mail geklickt |
email.bounced | Zustellung der E-Mail ist fehlgeschlagen |
email.complained | Kontakt hat die E-Mail als Spam markiert |
email.unsubscribed | Kontakt hat sich über den Link in der E-Mail abgemeldet |
Benutzerdefinierte Ereignisse
| Ereignis | Beschreibung |
|---|---|
custom_event.created | Ein neues benutzerdefiniertes Ereignis wurde erfasst |
custom_event.updated | Ein benutzerdefiniertes Ereignis wurde aktualisiert |
custom_event.deleted | Ein benutzerdefiniertes Ereignis wurde vorläufig gelöscht (Soft Delete) |
Filter für benutzerdefinierte Ereignisse
Benutzerdefinierte Ereignisse können Sie optional nach goal_types und event_names filtern:
{
"event_types": ["custom_event.created"],
"custom_event_filters": {
"goal_types": ["purchase", "subscription"],
"event_names": ["orders/fulfilled", "payment.succeeded"]
}
}
Nach Liste und Segment filtern
Standardmäßig erhält ein Abonnement für list.*-Ereignisse ein Ereignis für jede Liste des Arbeitsbereichs, und eines für segment.*-Ereignisse für jedes Segment. Mit list_ids und segment_ids grenzen Sie das ein:
{
"event_types": ["list.subscribed", "list.unsubscribed", "segment.joined"],
"list_ids": ["newsletter", "product_updates"],
"segment_ids": ["vip_customers"]
}
list_idsgilt nur für dielist.*-Ereignisse,segment_idsnur für diesegment.*-Ereignisse. Auf Kontakt-, E-Mail- und benutzerdefinierte Ereignisse wirkt sich keiner der beiden Filter aus.- Ein weggelassener Filter oder ein leeres Array bedeutet „jede Liste“ bzw. „jedes Segment“. Abonnements, die vor Einführung dieser Filter angelegt wurden, verhalten sich weiterhin so.
- Beide Filter lassen sich später mit
webhookSubscriptions.updateändern.
Filtern Sie, wo immer es geht. Ein Arbeitsbereich mit großen Listen erzeugt pro Listenereignis eine Zustellung je Kontakt. Ein Abonnement, das eine Liste braucht, aber alle empfängt, lässt Ihre Instanz also für Ereignisse arbeiten, die es verwirft.
Felder eines Abonnements
Neben Name, URL und Ereignistypen meldet ein Abonnement:
| Feld | Beschreibung |
|---|---|
enabled | Ob das Abonnement gerade zustellt |
source | Was es angelegt hat. Fehlt bei einem Abonnement, das Sie selbst angelegt haben; zapier bei einem, das die Zapier-Integration angelegt hat |
consecutive_failures | Zustellversuche, die direkt hintereinander fehlgeschlagen sind. Wird beim ersten Erfolg auf null gesetzt |
failing_since | Seit wann die aktuelle Fehlerserie läuft. Wird beim ersten Erfolg geleert |
disabled_reason | Warum das Abonnement automatisch abgeschaltet wurde. Fehlt, wenn Sie es selbst abgeschaltet haben |
last_delivery_at | Wann zuletzt eine Zustellung erfolgreich war |
Warnung
Ein Abonnement mit source wurde von einem anderen Tool angelegt, dem es gehört. Löschen Sie ein von Zapier angelegtes Abonnement in Notifuse, funktioniert der Zap dahinter ohne Hinweis nicht mehr, und der Zap legt es nicht von selbst neu an. Schalten Sie stattdessen den Zap in Zapier ab.
Wann Notifuse ein Abonnement abschaltet
Notifuse legt einen Endpunkt, der nicht mehr antwortet, nur still, wenn beide Bedingungen erfüllt sind: 20 aufeinanderfolgende Fehler und eine Fehlerserie, die länger als zwei Stunden dauert. Ein kurzer Ausfall (ein Deployment, ein Neustart, ein während eines Imports kurz unerreichbarer Empfänger) schaltet Ihr Abonnement nie ab, egal wie viele Zustellungen er in der Zeit ablehnt. Diese Zustellungen werden mit dem üblichen Backoff erneut versucht.
Die Ausnahme ist ein Endpunkt, der mit 410 Gone antwortet: Er wird sofort stillgelegt, denn mit diesem Status sagt der Empfänger, dass das Abonnement nicht mehr existiert.
Wenn Sie ein Abonnement wieder einschalten, wird sein Fehlerverlauf gelöscht. Der nächste Fehler legt es also nicht gleich wieder still.
Wohin Notifuse zustellen kann
Ihr Endpunkt muss aus dem öffentlichen Internet erreichbar sein. Notifuse verweigert Verbindungen zu privaten, Loopback-, Link-Local- und reservierten Adressen, einschließlich des Metadaten-Endpunkts von Cloud-Instanzen. Bei jeder Weiterleitung prüft es erneut, sodass auch eine öffentliche URL abgelehnt wird, die auf eine interne weiterleitet. Ein Abonnement, dessen URL eine solche Adresse nennt, wird beim Speichern abgelehnt.
Hinweis
Nur bei Self-Hosting: Um Webhooks absichtlich an einen Dienst in Ihrem eigenen privaten Netzwerk zuzustellen (ein Container im selben Docker-Netzwerk, ein internes Automatisierungstool), setzen Sie WEBHOOK_DELIVERY_ALLOW_PRIVATE_HOSTS=true. Lassen Sie die Variable auf jedem Deployment weg, auf dem jemand Abonnements anlegen oder Automatisierungen bearbeiten kann, dem Sie Ihr internes Netzwerk nicht anvertrauen würden. Dieselbe Einstellung gilt für Webhook-Knoten in Automatisierungen.
Eine auf diese Weise verweigerte Zustellung wird wie jeder andere Fehler erneut versucht, zählt aber nie für das Abschalten des Abonnements. Es reicht also, die URL oder die Einstellung zu korrigieren, damit die Zustellung weiterläuft.
Aufbau der Payload
Alle Webhook-Payloads haben diesen Aufbau:
{
"id": "delivery_abc123",
"type": "contact.created",
"timestamp": "2024-01-15T10:30:00Z",
"workspace_id": "ws_1234567890",
"data": {
// Event-specific data
}
}
| Feld | Beschreibung |
|---|---|
id | Eindeutige Kennung der Webhook-Zustellung |
type | Der Ereignistyp, der den Webhook ausgelöst hat |
timestamp | ISO-8601-Zeitstempel des Webhook-Versands |
workspace_id | Der Arbeitsbereich, in dem das Ereignis eingetreten ist |
data | Ereignisspezifische Daten der Payload |
Beispiel: Kontakt erstellt
{
"id": "delivery_abc123",
"type": "contact.created",
"timestamp": "2024-01-15T10:30:00Z",
"workspace_id": "ws_1234567890",
"data": {
"email": "user@example.com",
"id": "contact_12345",
"external_id": "ext_67890",
"first_name": "John",
"last_name": "Doe",
"tags": ["newsletter", "customer"],
"tracking_opens_consent": "granted",
"tracking_clicks_consent": null,
"tracking_consent_updated_at": "2024-01-15T10:30:00Z",
"tracking_consent_source": "api",
"created_at": "2024-01-15T10:30:00Z",
"updated_at": "2024-01-15T10:30:00Z"
}
}
Beispiel: E-Mail gesendet
{
"id": "delivery_def456",
"type": "email.sent",
"timestamp": "2024-01-15T10:30:00Z",
"workspace_id": "ws_1234567890",
"data": {
"message_id": "msg_xyz789",
"email": "user@example.com",
"subject": "Welcome to our newsletter",
"broadcast_id": "bc_abc123",
"template_id": "welcome_email",
"created_at": "2024-01-15T10:30:00Z"
}
}
Beispiel: E-Mail geöffnet
{
"id": "delivery_ghi789",
"type": "email.opened",
"timestamp": "2024-01-15T11:45:00Z",
"workspace_id": "ws_1234567890",
"data": {
"message_id": "msg_xyz789",
"email": "user@example.com",
"subject": "Welcome to our newsletter",
"broadcast_id": "bc_abc123",
"template_id": "welcome_email",
"created_at": "2024-01-15T11:45:00Z"
}
}
Beispiel: Segment beigetreten
{
"id": "delivery_jkl012",
"type": "segment.joined",
"timestamp": "2024-01-15T10:30:00Z",
"workspace_id": "ws_1234567890",
"data": {
"email": "user@example.com",
"contact_id": "contact_12345",
"segment_id": "seg_vip_customers",
"segment_name": "VIP Customers",
"created_at": "2024-01-15T10:30:00Z"
}
}
Webhook-Signaturen prüfen
Notifuse signiert alle Webhook-Payloads nach der Spezifikation Standard Webhooks mit HMAC-SHA256.
Header
Jede Webhook-Anfrage enthält diese Header:
| Header | Beschreibung |
|---|---|
webhook-id | Eindeutige Kennung der Webhook-Zustellung |
webhook-timestamp | Unix-Zeitstempel des Webhook-Versands |
webhook-signature | HMAC-SHA256-Signatur der Payload |
Signatur prüfen
- Zeitstempel und Signatur aus den Headern lesen
- Die signierte Payload zusammensetzen:
{webhook-id}.{webhook-timestamp}.{body} - HMAC-SHA256 mit Ihrem Webhook-Secret berechnen
- Mit der mitgelieferten Signatur vergleichen
Codebeispiele
const crypto = require('crypto');
function verifyWebhook(payload, headers, secret) {
const msgId = headers['webhook-id'];
const msgTimestamp = headers['webhook-timestamp'];
const msgSignature = headers['webhook-signature'];
// Check timestamp is within 5 minutes
const now = Math.floor(Date.now() / 1000);
if (Math.abs(now - parseInt(msgTimestamp)) > 300) {
throw new Error('Timestamp too old');
}
// Construct signed payload
const signedPayload = `${msgId}.${msgTimestamp}.${payload}`;
// Compute signature
const secretBytes = Buffer.from(secret.replace('whsec_', ''), 'base64');
const expectedSignature = crypto
.createHmac('sha256', secretBytes)
.update(signedPayload)
.digest('base64');
// Extract v1 signature
const signatures = msgSignature.split(' ');
for (const sig of signatures) {
const [version, signature] = sig.split(',');
if (version === 'v1' && signature === expectedSignature) {
return true;
}
}
throw new Error('Invalid signature');
}import hmac
import hashlib
import base64
import time
def verify_webhook(payload: str, headers: dict, secret: str) -> bool:
msg_id = headers.get('webhook-id')
msg_timestamp = headers.get('webhook-timestamp')
msg_signature = headers.get('webhook-signature')
# Check timestamp is within 5 minutes
now = int(time.time())
if abs(now - int(msg_timestamp)) > 300:
raise ValueError('Timestamp too old')
# Construct signed payload
signed_payload = f"{msg_id}.{msg_timestamp}.{payload}"
# Compute signature
secret_bytes = base64.b64decode(secret.replace('whsec_', ''))
expected_signature = base64.b64encode(
hmac.new(secret_bytes, signed_payload.encode(), hashlib.sha256).digest()
).decode()
# Extract v1 signature
for sig in msg_signature.split(' '):
version, signature = sig.split(',')
if version == 'v1' and signature == expected_signature:
return True
raise ValueError('Invalid signature')package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"errors"
"fmt"
"math"
"strconv"
"strings"
"time"
)
func VerifyWebhook(payload string, headers map[string]string, secret string) error {
msgID := headers["webhook-id"]
msgTimestamp := headers["webhook-timestamp"]
msgSignature := headers["webhook-signature"]
// Check timestamp is within 5 minutes
ts, _ := strconv.ParseInt(msgTimestamp, 10, 64)
now := time.Now().Unix()
if math.Abs(float64(now-ts)) > 300 {
return errors.New("timestamp too old")
}
// Construct signed payload
signedPayload := fmt.Sprintf("%s.%s.%s", msgID, msgTimestamp, payload)
// Compute signature
secretBytes, _ := base64.StdEncoding.DecodeString(strings.TrimPrefix(secret, "whsec_"))
h := hmac.New(sha256.New, secretBytes)
h.Write([]byte(signedPayload))
expectedSig := base64.StdEncoding.EncodeToString(h.Sum(nil))
// Extract v1 signature
for _, sig := range strings.Split(msgSignature, " ") {
parts := strings.SplitN(sig, ",", 2)
if len(parts) == 2 && parts[0] == "v1" && parts[1] == expectedSig {
return nil
}
}
return errors.New("invalid signature")
}<?php
function verifyWebhook(string $payload, array $headers, string $secret): bool {
$msgId = $headers['webhook-id'] ?? '';
$msgTimestamp = $headers['webhook-timestamp'] ?? '';
$msgSignature = $headers['webhook-signature'] ?? '';
// Check timestamp is within 5 minutes
$now = time();
if (abs($now - (int)$msgTimestamp) > 300) {
throw new Exception('Timestamp too old');
}
// Construct signed payload
$signedPayload = "{$msgId}.{$msgTimestamp}.{$payload}";
// Compute signature
$secretBytes = base64_decode(str_replace('whsec_', '', $secret));
$expectedSignature = base64_encode(
hash_hmac('sha256', $signedPayload, $secretBytes, true)
);
// Extract v1 signature
foreach (explode(' ', $msgSignature) as $sig) {
[$version, $signature] = explode(',', $sig, 2);
if ($version === 'v1' && $signature === $expectedSignature) {
return true;
}
}
throw new Exception('Invalid signature');
}Wiederholungsverhalten
Notifuse wiederholt fehlgeschlagene Zustellungen mit exponentiellem Backoff.
Zeitplan der Wiederholungen
Eine Zustellung erhält bis zu 10 Versuche, der letzte etwa 10 Stunden nach dem ersten:
| Versuch | Wartezeit nach dem vorherigen |
|---|---|
| 1 | Sofort |
| 2 | 30 Sekunden |
| 3 | 1 Minute |
| 4 | 2 Minuten |
| 5 | 5 Minuten |
| 6 | 15 Minuten |
| 7 | 30 Minuten |
| 8 | 1 Stunde |
| 9 | 2 Stunden |
| 10 | 6 Stunden |
Schlägt auch der 10. Versuch fehl, wird die Zustellung als fehlgeschlagen markiert und nicht mehr wiederholt.
Erfolgskriterien
Eine Zustellung ist erfolgreich, wenn Ihr Endpunkt einen HTTP-Statuscode 2xx (200-299) zurückgibt.
Fehlerbedingungen
Ein Zustellversuch schlägt fehl, wenn:
- Ihr Endpunkt einen Statuscode außerhalb von 2xx zurückgibt
- Ihr Endpunkt länger als 10 Sekunden für die Antwort braucht
- der Endpunkt nicht erreichbar ist (DNS-Fehler, Verbindung abgelehnt usw.)
Automatische Deaktivierung
Ein Endpunkt, der umgezogen ist, außer Betrieb genommen wurde oder seinen DNS-Eintrag verloren hat, kommt nicht von selbst zurück, und Notifuse reiht nicht endlos Zustellungen für ihn ein.
Nach einer langen Serie direkt aufeinanderfolgender Fehler schaltet Notifuse das Abonnement ab und vermerkt den Grund daran. So können Sie es von einem Abonnement unterscheiden, das Sie selbst deaktiviert haben. Der Zähler gilt pro Abonnement, und eine einzige erfolgreiche Zustellung setzt ihn auf null zurück. Abgeschaltet wird also nur ein Endpunkt, der dauerhaft fehlschlägt.
Zwei Antworten werden besonders behandelt:
429 Too Many Requestszählt nie als Fehler. Damit bittet Ihr Server um weniger Anfragen, und ein Arbeitsbereich, der so viel Betrieb hat, dass er gedrosselt wird, soll deshalb nicht seine Integration verlieren. Die Zustellung wird nach dem normalen Zeitplan erneut versucht.410 Goneist schon bei der ersten Antwort endgültig. Mit diesem Status sagt ein Empfänger üblicherweise „dieses Abonnement ist tot, nicht mehr senden“. Das Abonnement wird daher sofort stillgelegt, ohne die übliche Fehlerserie. Ein von Ihnen angelegtes Abonnement wird mit diesem Grund abgeschaltet; eines, das ein anderes Tool wie Zapier angelegt hat, wird ganz entfernt, weil das Tool es bei Bedarf neu anlegt.404wird nicht so behandelt: Ein Endpunkt, der kurz fehlt, wird wie bei jedem anderen Fehler erneut versucht.
Um ein deaktiviertes Abonnement zurückzuholen, beheben Sie das Problem am Endpunkt und aktivieren es wieder.
Hinweis
Ein deaktiviertes Abonnement verwirft Ereignisse, statt sie einzureihen. Zustellungen, die fällig werden, während es abgeschaltet ist, ob von Ihnen oder von Notifuse, werden im Zustellprotokoll als fehlgeschlagen markiert und beim Wiedereinschalten nicht nachgeholt. Die Ereignisse eines Ausfalls holen Sie über die API nach.
Abonnement löschen
Wenn Sie ein Abonnement löschen, werden auch die noch eingereihten Zustellungen dafür verworfen. Es bleibt also nichts zu wiederholen, und Sie müssen keine Warteschlange vorher abarbeiten lassen.
Wenn Sie den Endpunkt wieder in Betrieb nehmen wollen, deaktivieren Sie das Abonnement, statt es zu löschen. Deaktivieren lässt sich rückgängig machen, und das Abonnement behält sein Signatur-Secret und seinen Zustellverlauf. Ein gelöschtes Abonnement lässt sich nicht wiederherstellen, und beim Neuanlegen entsteht ein neues Signatur-Secret.
Empfehlungen
Schnell mit 2xx antworten
Senden Sie so schnell wie möglich eine erfolgreiche Antwort und verarbeiten Sie die Payload bei Bedarf asynchron:
// Good: Acknowledge quickly, process later
app.post('/webhooks/notifuse', async (req, res) => {
// Quickly validate signature
verifyWebhook(req.body, req.headers, SECRET);
// Queue for async processing
await queue.add('process-webhook', req.body);
// Respond immediately
res.status(200).json({ received: true });
});
Doppelte Zustellungen behandeln
In seltenen Fällen wird ein Webhook mehr als einmal zugestellt. Nutzen Sie den Header webhook-id für Idempotenz:
app.post('/webhooks/notifuse', async (req, res) => {
const webhookId = req.headers['webhook-id'];
// Check if we've already processed this webhook
if (await hasProcessed(webhookId)) {
return res.status(200).json({ received: true, duplicate: true });
}
// Mark as processed before handling
await markProcessed(webhookId);
// Process the webhook
await processWebhook(req.body);
res.status(200).json({ received: true });
});
Signaturen prüfen
Prüfen Sie in der Produktion immer die Webhook-Signaturen, damit sicher ist, dass die Anfragen von Notifuse kommen.
Zustellfehler überwachen
In der Konsole zeigt Einstellungen → Webhooks für jedes Abonnement die Erfolgsquote der letzten 7 Tage und die letzte erfolgreiche Zustellung. Öffnen Sie ein Abonnement, um seine erfolgreichen und fehlgeschlagenen Zustellungen der letzten 24 Stunden oder 7 Tage zu sehen, und wählen Sie Zustellungen ansehen, um sie in den Protokollen aufzulisten.
Über die API geben Sie status an (pending, delivering, delivered oder failed), um nur die Zustellungen mit diesem Status aufzulisten; jeder andere Wert liefert 400. failed umfasst auch Zustellungen, die auf eine Wiederholung warten und beim erneuten Senden wieder zu delivering wechseln. Eine als fehlgeschlagen gelistete Zustellung kann also noch erfolgreich sein:
curl "https://your-instance.com/api/webhookSubscriptions.deliveries?workspace_id=ws_123&subscription_id=whsub_456&status=failed" \
-H "Authorization: Bearer YOUR_API_KEY"
Webhooks testen
Test-Webhook senden
Prüfen Sie Ihre Webhook-Konfiguration mit dem Test-Endpunkt:
curl -X POST "https://your-instance.com/api/webhookSubscriptions.test" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"workspace_id": "your_workspace",
"id": "whsub_a1b2c3d4e5f6",
"event_type": "contact.created"
}'
Mit dem optionalen Parameter event_type sendet der Test eine realistische Beispiel-Payload für diesen Ereignistyp. Ohne ihn sendet der Test eine allgemeine Payload.
Lokale Entwicklung
Für die lokale Entwicklung machen Sie Ihren lokalen Server mit Tools wie ngrok oder localtunnel erreichbar:
# Start ngrok
ngrok http 3000
# Use the ngrok URL as your webhook endpoint
# https://abc123.ngrok.io/webhooks/notifuse
Berechtigungen
Ausgehende Abonnements unterliegen der Berechtigung Webhook-Abonnements. Mit Gelesen listen Sie Abonnements auf, öffnen eines und sehen seinen Zustellverlauf, einschließlich jeder Ereignis-Payload sowie Statuscode und Antworttext des Endpunkts. Mit Schreiben legen Sie Abonnements an, aktualisieren, löschen, aktivieren und deaktivieren sie und lösen eine Testzustellung aus. Diese zählt als Schreibvorgang, weil sie Ihren Server zu einem Aufruf nach außen bringt.
Eingehende Callbacks der Anbieter unterliegen der Berechtigung Webhook-Ereignisse. Mit Gelesen sehen Sie die rohen Callbacks, die Ihre E-Mail-Anbieter an Notifuse zurückgesendet haben, einschließlich Empfängeradressen und Diagnosen der Anbieter. Schreibrecht für Webhook-Ereignisse steuert derzeit nichts: Die Einträge kommen über die Callback-Routen der Anbieter, die keine Sitzung tragen und keine Berechtigung prüfen, sodass dieses Recht nichts gewährt. Die Konsole zeigt es als gewährt und gesperrt an.
Der Katalog der verfügbaren Ereignistypen braucht keine Berechtigung: Jedes angemeldete Mitglied und jeder Schlüssel kann ihn abrufen.
Zwei Aktionen bleiben dem Inhaber des Arbeitsbereichs vorbehalten, unabhängig von den Berechtigungen eines Mitglieds oder API-Schlüssels:
- Das Signatur-Secret eines Abonnements neu erzeugen. Das Secret ist außerdem für alle außer dem Inhaber verborgen, sodass Leserecht für Webhook-Abonnements es nie preisgibt: Ein Mitglied kann Abonnements auflisten und Zustellungen einsehen, ohne je den Schlüssel zu sehen, der diese Payloads signiert.
- Webhooks bei einem E-Mail-Anbieter registrieren, weil dafür die in Ihrer Integration gespeicherten Zugangsdaten des Anbieters verwendet werden.
Warnung
Schreiben für Webhook-Abonnements reicht weiter, als der Name vermuten lässt. Ein Abonnement legt fest, welche Ereignisse es erhält. Wer diese Berechtigung hat, kann also Kontakt- und E-Mail-Ereignisse abonnieren und diese Daten an eine URL seiner Wahl senden lassen. Vergeben Sie sie so, wie Sie Leserecht für die Kontakte und den Nachrichtenverlauf hinter diesen Ereignissen vergeben würden.
Hinweise
- Webhooks erfordern in der Produktion HTTPS-Endpunkte
- Das Signatur-Secret wird automatisch erzeugt, wenn Sie ein Abonnement anlegen
- Mit
webhookSubscriptions.regenerateSecreterneuern Sie das Signatur-Secret - Die vollständige Dokumentation der Endpunkte finden Sie in der API-Referenz
