Zum Inhalt springen

Funktionen

Webhooks

Erhalten Sie HTTP-Callbacks in Echtzeit, wenn in Ihrem Arbeitsbereich Ereignisse eintreten.

Überblick

Notifuse kennt zwei Arten von Webhooks:

  1. 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.

  2. 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
Einstellungen, Webhooks: zwei Endpunkte mit ihren Ereignissen und ihrer Zustell-Erfolgsquote

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:

Die Ereignistypen eines Webhook-Endpunkts, per Kontrollkästchen gewählt, mit Alle auswählen

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

EreignisBeschreibung
contact.createdEin neuer Kontakt wurde dem Arbeitsbereich hinzugefügt
contact.updatedKontaktdaten wurden geändert
contact.deletedEin Kontakt wurde endgültig gelöscht

Listenereignisse

EreignisBeschreibung
list.subscribedKontakt hat eine Liste abonniert
list.unsubscribedKontakt hat sich von einer Liste abgemeldet
list.confirmedKontakt hat ein Double-Opt-in-Abonnement bestätigt
list.resubscribedZuvor abgemeldeter Kontakt hat sich erneut angemeldet
list.bouncedE-Mail an den Kontakt wurde zurückgewiesen
list.complainedKontakt hat eine E-Mail als Spam markiert
list.pendingAbonnement des Kontakts wartet auf Bestätigung
list.removedKontakt wurde aus der Liste entfernt

Segmentereignisse

EreignisBeschreibung
segment.joinedKontakt ist in ein Segment eingetreten (erfüllt die Segmentkriterien)
segment.leftKontakt hat ein Segment verlassen (erfüllt die Kriterien nicht mehr)

E-Mail-Ereignisse

EreignisBeschreibung
email.sentE-Mail wurde an den Kontakt gesendet
email.deliveredDer Server des Empfängers hat die Zustellung bestätigt
email.openedKontakt hat die E-Mail geöffnet
email.clickedKontakt hat einen Link in der E-Mail geklickt
email.bouncedZustellung der E-Mail ist fehlgeschlagen
email.complainedKontakt hat die E-Mail als Spam markiert
email.unsubscribedKontakt hat sich über den Link in der E-Mail abgemeldet

Benutzerdefinierte Ereignisse

EreignisBeschreibung
custom_event.createdEin neues benutzerdefiniertes Ereignis wurde erfasst
custom_event.updatedEin benutzerdefiniertes Ereignis wurde aktualisiert
custom_event.deletedEin 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_ids gilt nur für die list.*-Ereignisse, segment_ids nur für die segment.*-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:

FeldBeschreibung
enabledOb das Abonnement gerade zustellt
sourceWas es angelegt hat. Fehlt bei einem Abonnement, das Sie selbst angelegt haben; zapier bei einem, das die Zapier-Integration angelegt hat
consecutive_failuresZustellversuche, die direkt hintereinander fehlgeschlagen sind. Wird beim ersten Erfolg auf null gesetzt
failing_sinceSeit wann die aktuelle Fehlerserie läuft. Wird beim ersten Erfolg geleert
disabled_reasonWarum das Abonnement automatisch abgeschaltet wurde. Fehlt, wenn Sie es selbst abgeschaltet haben
last_delivery_atWann 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
  }
}
FeldBeschreibung
idEindeutige Kennung der Webhook-Zustellung
typeDer Ereignistyp, der den Webhook ausgelöst hat
timestampISO-8601-Zeitstempel des Webhook-Versands
workspace_idDer Arbeitsbereich, in dem das Ereignis eingetreten ist
dataEreignisspezifische 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:

HeaderBeschreibung
webhook-idEindeutige Kennung der Webhook-Zustellung
webhook-timestampUnix-Zeitstempel des Webhook-Versands
webhook-signatureHMAC-SHA256-Signatur der Payload

Signatur prüfen

  1. Zeitstempel und Signatur aus den Headern lesen
  2. Die signierte Payload zusammensetzen: {webhook-id}.{webhook-timestamp}.{body}
  3. HMAC-SHA256 mit Ihrem Webhook-Secret berechnen
  4. 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:

VersuchWartezeit nach dem vorherigen
1Sofort
230 Sekunden
31 Minute
42 Minuten
55 Minuten
615 Minuten
730 Minuten
81 Stunde
92 Stunden
106 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 Requests zä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 Gone ist 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. 404 wird 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.regenerateSecret erneuern Sie das Signatur-Secret
  • Die vollständige Dokumentation der Endpunkte finden Sie in der API-Referenz