Webhooks einrichten: Echtzeit-Updates in Zapier, Make und eigenen Apps

Stell dir vor, deine Anwendung erfährt sofort, wenn ein neuer Datensatz angelegt, ein bestehender geändert oder ein Eintrag gelöscht wird – ohne permanent nachzufragen. Genau das leisten Webhooks. Sie sind das Echtzeit-Rückgrat moderner Integrationen und der sauberste Weg, Systeme reaktiv miteinander zu verbinden.

In diesem Artikel erklären wir, wie Webhooks funktionieren, wie du sie in instantapi.io einrichtest und wie du sie sicher in Zapier, Make.com oder deiner eigenen Anwendung empfängst.

Was sind Webhooks?

Ein Webhook ist ein event-gesteuerter HTTP-Callback. Wenn ein definiertes Ereignis eintritt (z. B. ein neuer Datensatz wird erstellt), sendet das System automatisch eine HTTP-POST-Anfrage an eine von dir festgelegte URL – deinen Webhook-Endpunkt.

Du musst nichts aktiv abfragen. Der Server kommt zu dir, sobald etwas passiert.

📬

Die Türklingel-Analogie

Polling wäre so, als würdest du alle fünf Minuten zur Haustür gehen und nachschauen, ob jemand da ist. Ein Webhook ist die Türklingel: Du wartest einfach zu Hause – und sobald jemand klingelt, weißt du sofort Bescheid. Kein unnötiges Aufstehen, keine verschwendete Energie.

Polling vs. Webhooks – der entscheidende Unterschied

Eigenschaft	Polling	Webhook
Initiierung	Client fragt regelmäßig nach	Server benachrichtigt bei Ereignis
Echtzeit	Nein (abhängig vom Intervall)	Ja (sofort)
API-Anfragen	Viele (auch wenn nichts passiert)	Nur wenn ein Ereignis auftritt
Rate-Limit-Verbrauch	Hoch	Minimal
Komplexität	Einfach zu implementieren	Erfordert öffentlichen Endpunkt

Die Faustregel lautet: Wenn du auf Änderungen reagieren willst, nutze Webhooks. Wenn du selbst den Zeitpunkt der Abfrage kontrollieren musst (z. B. beim Start einer App), nutze die reguläre API.

Typische Webhook-Events

instantapi.io löst Webhooks bei folgenden Ereignissen aus:

Event	Wann ausgelöst
`row.created`	Ein neuer Datensatz wird über die API oder das Dashboard angelegt
`row.updated`	Ein bestehender Datensatz wird geändert (PUT/PATCH)
`row.deleted`	Ein Datensatz wird gelöscht (DELETE)
`dataset.updated`	Das Schema des Datasets ändert sich (neue Spalten, Umbenennung)

Das Webhook-Payload-Format

Jede Webhook-Anfrage ist ein HTTP-POST mit einem JSON-Body. Das Format ist einheitlich und enthält immer das ausgelöste Ereignis, die Dataset-ID und die betroffenen Daten:

// Beispiel: row.created Webhook-Payload
{
  "event":      "row.created",
  "timestamp": "2026-04-02T14:32:07Z",
  "dataset_id": "ds_abc123xyz",
  "data": {
    "id":        42,
    "name":      "Mustermann GmbH",
    "status":    "aktiv",
    "umsatz":    184500,
    "erstellt_am": "2026-04-02T14:32:07Z"
  }
}

Bei row.updated enthält das Payload zusätzlich ein previous-Objekt mit den Werten vor der Änderung – so kannst du genau sehen, was sich verändert hat:

// Beispiel: row.updated – mit Vorher/Nachher
{
  "event":      "row.updated",
  "timestamp": "2026-04-02T15:10:22Z",
  "dataset_id": "ds_abc123xyz",
  "data": {
    "id":     42,
    "status": "inaktiv"
  },
  "previous": {
    "id":     42,
    "status": "aktiv"
  }
}

Webhook in instantapi.io einrichten

Die Konfiguration eines Webhooks ist in wenigen Schritten erledigt:

Öffne dein Dataset im instantapi.io Dashboard.
Navigiere zu Einstellungen → Webhooks.
Klicke auf "Webhook hinzufügen".
Trage die Ziel-URL ein (z. B. dein Server, deine Zapier-URL oder Make-URL).
Wähle die Events aus, die du empfangen möchtest (row.created, row.updated, row.deleted).
Kopiere den angezeigten Webhook-Secret – du brauchst ihn zur Signatur-Verifikation.
Klicke auf "Speichern & testen". instantapi.io sendet ein Test-Ereignis an deine URL.

💡 Test-Endpunkt für Entwicklung

Zum Testen eignet sich webhook.site hervorragend: Du bekommst sofort eine öffentliche URL und siehst alle eingehenden Payloads in Echtzeit – ohne eigenen Server einrichten zu müssen.

Webhooks in Zapier empfangen

Zapier ist einer der beliebtesten Wege, Webhooks in Automatisierungen zu nutzen. So richtest du es ein:

Erstelle einen neuen Zap und wähle als Trigger: Webhooks by Zapier → Catch Hook.
Zapier generiert eine eindeutige Webhook-URL – kopiere sie.
Trage diese URL als Webhook-Ziel in instantapi.io ein (siehe Abschnitt oben).
Klicke in Zapier auf "Test trigger" – instantapi.io sendet ein Testevent, Zapier erkennt das Payload-Format.
Wähle im nächsten Schritt deine gewünschte Aktion: z. B. eine E-Mail senden, einen Google-Sheet-Eintrag erstellen, eine Slack-Nachricht schicken oder einen weiteren API-Aufruf starten.

⚡ Beispiel-Use-Case Zapier

Immer wenn in instantapi.io ein neuer Kundendatensatz mit Status aktiv angelegt wird, sendet Zapier automatisch eine Willkommens-E-Mail über Mailchimp – vollautomatisch, ohne manuellen Eingriff.

Webhooks in Make.com empfangen

Make.com (ehemals Integromat) bietet mit dem Custom Webhook-Modul eine ebenso flexible Möglichkeit:

Erstelle ein neues Szenario in Make.com.
Füge als erstes Modul Webhooks → Custom Webhook hinzu.
Klicke auf "Add", vergib einen Namen und bestätige. Make generiert eine Webhook-URL.
Trage diese URL in instantapi.io als Webhook-Ziel ein.
Klicke in Make auf "Run once" und löse ein Test-Event in instantapi.io aus. Make erkennt die Datenstruktur automatisch.
Baue dein Szenario weiter aus: z. B. Datensatz in Airtable übertragen, Slack-Benachrichtigung, CRM-Eintrag aktualisieren.

Make hat gegenüber Zapier den Vorteil, dass Szenarios komplexere Ablauflogik (Verzweigungen, Schleifen, Aggregatoren) unterstützen – ideal für mehrstufige Automatisierungen.

Webhooks in eigenen Anwendungen empfangen

Wenn du Webhooks direkt in deiner eigenen Backend-Anwendung verarbeiten möchtest, brauchst du einen öffentlich erreichbaren HTTP-Endpunkt. Ein minimales Beispiel in Node.js mit Express:

// Node.js / Express – Webhook-Endpunkt
const express = require('express');
const crypto  = require('crypto');
const app = express();
app.use(express.json());

app.post('/webhook', (req, res) => {
  // 1. Signatur prüfen (siehe nächster Abschnitt)
  const sig    = req.headers['x-webhook-signature'];
  const secret = process.env.WEBHOOK_SECRET;
  const expected = crypto
    .createHmac('sha256', secret)
    .update(JSON.stringify(req.body))
    .digest('hex');

  if (sig !== expected) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  // 2. Event verarbeiten
  const { event, dataset_id, data } = req.body;
  console.log(`Event: ${event}, Dataset: ${dataset_id}`);

  // 3. Sofort mit 200 antworten (wichtig!)
  res.status(200).json({ received: true });

  // 4. Aufwendige Verarbeitung asynchron fortsetzen
  processWebhookAsync(event, data);
});

app.listen(3000);

Webhook-Signaturen verifizieren (HMAC-SHA256)

Jede Webhook-Anfrage von instantapi.io enthält den Header X-Webhook-Signature. Er ist ein HMAC-SHA256-Hash des Anfrage-Bodys, signiert mit deinem Webhook-Secret. Diese Verifikation ist entscheidend für die Sicherheit deines Endpunkts.

Warum ist das wichtig? Ohne Signaturprüfung könnte jeder eine Anfrage an deinen Endpunkt schicken und vorgeben, instantapi.io zu sein. Die Signatur beweist die Authentizität der Nachricht.

// So wird die Signatur gebildet (zur Referenz)
// signature = HMAC-SHA256(raw_request_body, webhook_secret)

// Python-Beispiel zur Verifikation
import hmac, hashlib, json

def verify_signature(payload_bytes, signature, secret):
    expected = hmac.new(
        secret.encode(),
        payload_bytes,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

🔐 Sicherheitshinweis

Verwende für den Vergleich immer hmac.compare_digest() (Python) bzw. crypto.timingSafeEqual() (Node.js) statt eines einfachen String-Vergleichs (==). Einfache Vergleiche sind anfällig für Timing-Attacken.

Sicherheits-Best-Practices für Webhooks

1. Ausschließlich HTTPS verwenden

Trage als Webhook-URL nur HTTPS-Endpunkte ein. instantapi.io akzeptiert keine unverschlüsselten HTTP-URLs. Andernfalls könnten die Payloads – und das Webhook-Secret – im Klartext übertragen werden.

2. Signatur immer prüfen

Verifiziere bei jeder eingehenden Anfrage die Signatur, bevor du das Payload verarbeitest. Schlägt die Prüfung fehl, antworte mit 401 Unauthorized und tu nichts weiter.

3. Sofort antworten, dann verarbeiten

instantapi.io wartet maximal 10 Sekunden auf eine Antwort. Antworte sofort mit 200 OK und führe aufwendige Verarbeitungsschritte (Datenbankzugriff, weitere API-Aufrufe) danach asynchron aus. Andernfalls kommt es zu Timeouts und erneuten Zustellversuchen.

4. Idempotenz sicherstellen

Webhooks können bei Netzwerkproblemen mehrfach zugestellt werden. Speichere die timestamp-Kombination oder eine eindeutige Event-ID und prüfe vor der Verarbeitung, ob das Event bereits bearbeitet wurde. So verhinderst du doppelte Einträge oder doppelt ausgeführte Aktionen.

Best Practice	Warum wichtig
HTTPS-Only	Verschlüsselt Payload und Secret
Signatur prüfen	Authentizität der Nachricht sicherstellen
Sofort 200 antworten	Timeout und erneute Zustellung vermeiden
Idempotenz	Mehrfache Zustellung sicher verarbeiten
Secret rotieren	Bei Verdacht auf Kompromittierung neues Secret generieren

Fazit: Webhooks sind das Herzstück reaktiver Integrationen

Webhooks transformieren passive Integrationen in aktive, ereignisgesteuerte Systeme. Statt regelmäßig nachzufragen, ob sich etwas geändert hat, wirst du sofort informiert – das spart Anfragekontingente, reduziert Latenz und macht deine Automatisierungen zuverlässiger.

Mit instantapi.io richtest du Webhooks direkt im Dashboard ein, ohne Servercode zu schreiben. Ob Zapier, Make oder eigene Backend-Logik: Das einheitliche Payload-Format und die HMAC-Signatur machen die Integration sicher und unkompliziert.

Echtzeit-Updates für deine Daten

Webhooks, CORS-Whitelist, API-Keys und mehr – alles in einem Dashboard. Starte kostenlos und verbinde deine Daten mit Zapier, Make oder eigenen Apps.

Jetzt kostenlos starten →

Webhooks Zapier Make.com HMAC-SHA256 Echtzeit Fortgeschritten Automatisierung