Webhooks vs. WebSockets: Wann Sie welche nutzen
Webhooks und WebSockets im Vergleich nach Verbindungsmodell, Wiederholversuchen, Skalierung und Sicherheit, mit Checkliste und Webhook-Queue-WebSocket-Muster.
Geprüft von Maurice Sobiera

Ein Webhook ist eine einseitige HTTP-Anfrage, die ein Server an Ihre URL sendet, sobald ein Ereignis eintritt. Ein WebSocket ist eine dauerhafte, bidirektionale Verbindung für laufenden Nachrichtenaustausch. Nutzen Sie Webhooks für Server-zu-Server-Ereignisse wie Zahlungsbestätigungen und WebSockets für Live-Updates im Browser. Viele Systeme kombinieren beides.
Kurzfassung:
- Webhooks eignen sich ideal für Server-zu-Server-Benachrichtigungen von Drittanbieterdiensten, erfordern aber eine öffentliche, erreichbare URL mit sicheren Signaturen und schnellen Antworten.
- WebSockets passen besser zu bidirektionaler Echtzeit-Kommunikation mit Browsern oder Apps, verlangen aber Verbindungsmanagement und Zustandsverwaltung, einschließlich Wiederverbindungslogik.
- Die Kombination aus Webhooks und WebSockets ergibt eine belastbare Architektur: Webhooks übernehmen die Ereignisaufnahme, WebSockets liefern Live-Updates effizient an Clients.
- Das Skalieren von WebSockets bedeutet, viele offene Verbindungen mit Sticky Sessions oder einem gemeinsamen Message Broker zu verwalten, während Webhooks einfach über serverlose, zustandslose Verarbeitung mit Queues skalieren.
- Die Sicherheit von Webhooks beruht auf rotierenden Signaturen und TLS; bei WebSockets stehen Authentifizierung der Verbindung und Validierung jeder Nachricht im Vordergrund, um unbefugten Zugriff zu verhindern.
Inhaltsverzeichnis
- Was ist ein Webhook und wie funktioniert er?
- Wie funktioniert eine WebSocket-Verbindung?
- Wie unterscheiden sich Webhooks und WebSockets technisch?
- Wann sollten Sie Webhooks und wann WebSockets einsetzen?
- Skalierbarkeit und Betrieb
- Sicherheitsunterschiede und empfohlene Schutzmaßnahmen
- Ein reales Muster: Webhooks speisen den WebSocket-Fan-Out
- Standardentscheidungen und was Sie als Nächstes beobachten sollten
- Zuverlässige Webhook-Zustellung, ohne sie selbst zu bauen
- Quellen
- FAQ
Was ist ein Webhook und wie funktioniert er?
Ein Webhook beginnt mit der Registrierung. Sie geben einem Anbieter (einem Zahlungsdienstleister, einem Git-Host, einem Blockchain-Node) eine URL. Wenn ein passendes Ereignis eintritt, sendet der Anbieter einen HTTP-POST mit einer JSON-Nutzlast an diese URL. Kein Polling, keine offene Verbindung, die untätig herumsteht. Es ist ereignisgesteuertes Push über Standard-HTTP, deshalb fügt es sich so leicht in eine Architektur ein, die Sie bereits betreiben.
Der Haken sind die Zustellgarantien. Viele Webhook-Anbieter arbeiten mit At-least-once-Semantik: Antwortet Ihr Endpunkt nicht schnell genug mit einem 2xx-Status, versucht der Anbieter es erneut, manche stunden- oder tagelang.
Ihr Handler muss deshalb idempotent sein. Das heißt, er kann dieselbe Zustellung zweimal verarbeiten, ohne doppelte Abbuchungen oder Datenbankzeilen zu erzeugen. Das OWASP Webhook Security Cheat Sheet empfiehlt aus diesem Grund idempotente Handler, die über die Ereignis-ID gesteuert werden. Nicht jeder Anbieter wiederholt Zustellungen. Chaingateway wiederholt fehlgeschlagene Webhooks nicht automatisch, listet aber fehlgeschlagene Benachrichtigungen auf und sendet sie auf Anfrage erneut.
Weil Webhooks eine erreichbare URL brauchen, bringen sie eine eigene Betriebs-Checkliste mit:
- Ein öffentlicher Endpunkt, der Firewall- und Load-Balancer-Konfiguration übersteht
- Signaturprüfung (meist HMAC), um zu bestätigen, dass die Anfrage tatsächlich vom Anbieter stammt
- Protokollierung der Zustell-IDs, damit Sie Duplikate oder Lücken nachvollziehen können
- Eine Antwortzeit, die schnell genug ist, um keine Wiederholungen für eine Anfrage auszulösen, die Sie noch verarbeiten
Webhooks stecken hinter Zahlungsbestätigungen, CI/CD-Pipeline-Triggern, Git-Push-Benachrichtigungen und Einzahlungsbenachrichtigungen. Sie passen auch gut zu Serverless-Backends, da zwischen den Aufrufen kein Verbindungszustand aufrechterhalten werden muss.
Wie funktioniert eine WebSocket-Verbindung?
Eine WebSocket-Verbindung beginnt als gewöhnliche HTTP-Anfrage und wird dann hochgestuft. Der Client sendet einen Upgrade: websocket-Header, der Server stimmt zu, und von da an können beide Seiten über dieselbe TCP-Verbindung Nachrichten senden, wie RFC 6455 es festlegt. Damit ist sie vollduplexfähig: Server und Client können jederzeit Daten senden, nicht nur als Antwort auf eine Anfrage.
Heikel ist nicht der Handshake, sondern alles danach. Verbindungen brechen ab, Netzwerke setzen aus, Tabs gehen in den Ruhezustand. Der Client-Code braucht Wiederverbindungslogik, und Sie müssen bufferedAmount im Blick behalten, damit Sie nicht schneller ausgehende Nachrichten einreihen, als der Socket sie senden kann. MDN dokumentiert den gesamten Lebenszyklus in seinem WebSockets-API-Leitfaden.
Serverseitig sind WebSockets zustandsbehaftet. Jede offene Verbindung belegt einen File Descriptor und etwas Arbeitsspeicher. Bei mehreren Serverinstanzen brauchen Sie Sticky Sessions oder einen Message Broker (Redis Pub/Sub, NATS), damit eine auf einer Instanz veröffentlichte Nachricht einen Client erreicht, der mit einer anderen verbunden ist.
Typische Einsatzfälle sind:
- Chat-Anwendungen und kollaborative Editoren
- Live-Dashboards und Börsenticker
- Zustandssynchronisierung bei Multiplayer-Spielen
- Präsenzanzeigen („Nutzer tippt gerade“)
Wenn Sie aufwendigere Backpressure-Behandlung oder streambasierte APIs brauchen, sehen Sie sich WebTransport und WebSocketStream an. Beide zielen auf Schwächen der klassischen WebSocket-API, und die Browserunterstützung ist unterschiedlich. Prüfen Sie daher die Kompatibilitätstabellen von MDN, bevor Sie sich darauf verlassen.
Wie unterscheiden sich Webhooks und WebSockets technisch?
| Eigenschaft | Webhooks | WebSockets |
|---|---|---|
| Verbindungsdauer | Keine, eine Anfrage pro Ereignis | Dauerhaft, bleibt offen |
| Richtung / wer initiiert | Einseitig; der Anbieter löst jeden Push aus | Bidirektional; nach dem Handshake kann jede Seite senden |
| Protokoll / Ports | HTTP/HTTPS, Standardports | ws/wss, aus HTTP hochgestuft, Standardports |
| Zustand | Zustandslos zwischen den Aufrufen | Zustandsbehaftet für die Dauer der Verbindung |
| Zustellgarantien / Wiederholungen | At-least-once, der Anbieter wiederholt bei Fehlern | Keine eingebaute Wiederholung; die Anwendung muss Abbrüche selbst behandeln |
| Wer verwaltet Wiederholungen | Sendender Anbieter (mit Ihrem idempotenten Handler) | Ihr Client- und Server-Code |
| Typische Latenz / am besten für | Nahezu Echtzeit, ausreichend für Ereignisbenachrichtigungen | Niedrigste Latenz, am besten für durchgehende Interaktivität |
| Sicherheitsmodell | HMAC-Signaturen, TLS, Zeitstempelprüfung | TLS-Handshake (wss), Authentifizierungs-Token pro Verbindung |
| Anforderung an öffentlichen Endpunkt | Erforderlich, muss aus dem Internet erreichbar sein | Client verbindet sich nach außen; kein eingehender Endpunkt nötig |
| Typische Einsatzfälle | Zahlungen, CI/CD, Einzahlungen, Bestellstatus | Chat, Dashboards, Multiplayer, Präsenz |
Die praktische Folge: Webhooks schieben das Zustellproblem auf den Sender (mit Wiederholungen, die Sie idempotent behandeln müssen), während WebSockets das Problem der Verbindungsverwaltung auf Sie abwälzen. Keines von beiden ist abstrakt „einfacher“. Es hängt davon ab, ob Sie lieber einen zustandslosen HTTP-Handler schreiben oder einen zustandsbehafteten Verbindungspool betreiben.
Wann sollten Sie Webhooks und wann WebSockets einsetzen?
Gehen Sie diese Fragen durch, bevor Sie sich für eine Architektur entscheiden:
- Wo entsteht das Ereignis? Stammt es aus einem Drittsystem (einem Zahlungs-Gateway, einem Blockchain-Netzwerk, einem Git-Host), brauchen Sie Webhooks. Zu einem Dienst, den Sie nicht kontrollieren, können Sie keinen WebSocket öffnen.
- Wie viel Latenz können Sie tolerieren? Aktualisierungen der Oberfläche im Sub-Sekunden-Bereich sprechen für WebSockets. Ein paar Sekunden Verzögerung bei der Aktualisierung eines Backend-Datensatzes sind für Webhooks in Ordnung.
- Wie sieht die Skalierungsform aus? Viele unabhängige Ereignisquellen, die ein Backend speisen, sprechen für Webhooks. Ein Backend, das Updates an Tausende verbundener Clients verteilt, spricht für WebSockets.
- Wie ist Ihre Server-Topologie? Serverless-Funktionen, die auf null herunterskalieren, passen natürlich zu Webhooks. Betreiben Sie bereits langlebige zustandsbehaftete Server, bringen WebSockets weniger zusätzliche Komplexität.
- Blockieren Firewall oder Netzwerkvorgaben eingehende Verbindungen? Kann Ihre Infrastruktur keinen öffentlichen Endpunkt bereitstellen, umgehen WebSockets (die der Client nach außen aufbaut) das Problem vollständig.
Auf Szenarien übertragen: Zahlungsbenachrichtigungen und Einzahlungsmeldungen gehören zu Webhooks. Die Aufnahme von Analyse-Ereignissen aus externen Tools gehört zu Webhooks. Chat und kollaboratives Bearbeiten gehören zu WebSockets. Ein Live-Trading-Dashboard braucht WebSockets für die letzte Meile, selbst wenn der zugrunde liegende Preis-Feed per Webhook ankommt.
Profi-Tipp: Starten Sie Prototypen mit Webhooks und einfachem Polling im Frontend. Das ist langsamer, aber Sie können das Ereignismodell validieren, bevor Sie in Verbindungsmanagement investieren. Ergänzen Sie WebSockets erst, wenn Sie bestätigt haben, dass Nutzer tatsächlich Updates im Sub-Sekunden-Bereich brauchen, nicht früher.
Skalierbarkeit und Betrieb
WebSockets verändern Ihre Kapazitätsrechnung. Jede offene Verbindung belegt einen File Descriptor und einen Teil des Arbeitsspeichers. Ab mehr als einer Serverinstanz brauchen Sie Sticky Sessions oder eine gemeinsame Pub/Sub-Schicht, damit Nachrichten die Clients erreichen, egal mit welcher Instanz diese verbunden sind. Das ist echte Infrastruktur, kein Konfigurationsschalter.
Webhooks skalieren anders, weil sie zwischen den Aufrufen keinen Zustand halten. Genau deshalb eignen sie sich für Serverless- und Scale-to-Zero-Umgebungen. Eine Funktion startet, verarbeitet den POST und verschwindet wieder.
Bei Produktionsvolumen halten einige Muster beide Modelle beherrschbar:
- Leiten Sie eingehende Webhooks über eine Queue (SQS, Pub/Sub, RabbitMQ), damit ein Ereignisschwall Ihren Handler nicht überlastet
- Bündeln oder entprellen Sie WebSocket-Broadcasts, wenn in kurzer Zeit viele Ereignisse auftreten
- Nutzen Sie Dead-Letter-Queues für Webhook-Zustellungen, die bei der idempotenten Verarbeitung wiederholt scheitern
- Überwachen Sie die Verbindungsfluktuation auf WebSocket-Servern und die Tiefe der Wiederholungs-Queue auf der Webhook-Seite; beides sind Frühwarnzeichen, bevor Kunden etwas bemerken
Sicherheitsunterschiede und empfohlene Schutzmaßnahmen
Webhooks und WebSockets scheitern auf unterschiedliche Weise, deshalb brauchen sie unterschiedliche Schutzmaßnahmen. Bei Webhooks geht es darum, die Echtheit der Anfrage zu belegen: HMAC-Signaturen in einem Header, ein Zeitstempel gegen Replay-Angriffe und striktes TLS. Bei WebSockets geht es um die Verbindung selbst. Das OWASP WebSocket Security Cheat Sheet stellt fest, dass WebSockets keine eingebaute Authentifizierung haben, rät dazu, bei jedem Handshake den Origin-Header gegen eine Allowlist zu prüfen, und warnt vor unverschlüsselten ws://-Verbindungen in Produktion. Es weist außerdem darauf hin, dass Nachrichten Injection-Nutzlasten enthalten können, validieren Sie sie also nach der Authentifizierung.
Schutzmaßnahmen, die Sie von Anfang an einbauen sollten:
- Rotieren Sie HMAC-Secrets regelmäßig und protokollieren Sie jeden Zustellversuch mit seinem Signaturstatus
- Weisen Sie Webhook-Nutzlasten mit veraltetem Zeitstempel ab, um Replays zu blockieren, sofern der Anbieter einen Zeitstempel signiert
- Verwenden Sie
wss://und prüfen Sie denOrigin-Header bei jedem WebSocket-Handshake - Begrenzen Sie die gleichzeitigen WebSocket-Verbindungen pro Client und die Nachrichtenfrequenz
- Validieren Sie Nutzlasten serverseitig auch nach der Authentifizierung, denn ein gültiges Token garantiert keine gültige Nachricht
Chaingateway signiert Webhooks mit einem X-Signature-HMAC, sobald Sie in Ihrem Profil ein persönliches Secret festlegen, wie der Leitfaden zur Webhook-Sicherheit beschreibt. Das Neugenerieren des Secrets wirkt sofort, aktualisieren Sie Ihren Empfänger also gleichzeitig. Die Signatur wird aus der Transaktions-ID und dem Secret gebildet und enthält keinen Zeitstempel. Den Replay-Schutz müssen Sie daher über die Deduplizierung der Transaktions-ID herstellen. Unser Beitrag zu dieser Funktion liefert den Hintergrund.
Ein reales Muster: Webhooks speisen den WebSocket-Fan-Out

Dieses Muster taucht in Produktion immer wieder auf: einen Webhook empfangen, verifizieren, in eine Queue stellen und dann einen Worker das Ergebnis über WebSockets an verbundene Clients verteilen lassen. Es verbindet auf der Aufnahmeseite die Dauerhaftigkeit der At-least-once-HTTP-Zustellung mit der niedrigen Latenz einer dauerhaften Verbindung auf der UI-Seite.
Die Schritte sehen so aus:
- Den Webhook-POST empfangen und die HMAC-Signatur prüfen, bevor Sie die Nutzlast anfassen
- Das verifizierte Ereignis in die Queue stellen, damit ein langsamer nachgelagerter Worker die HTTP-Antwort nie blockiert
- Das Ereignis verarbeiten (einen Datenbankeintrag schreiben, eine Zahlung als bestätigt markieren)
- Das Ergebnis in einem Pub/Sub-Kanal oder bei einem Broker veröffentlichen, den Ihre WebSocket-Server abonniert haben
- Das Update an jeden verbundenen Client senden, der sich für dieses Ereignis interessiert
Das entkoppelt Aufnahme und Auslieferung: Webhooks sind der eingehende Mechanismus, ein Broker sitzt in der Mitte, und WebSockets übernehmen die letzte Meile zu einem Browser oder einer App. Die Event-Notification-Webhooks von Chaingateway liefern dekodierte, HMAC-signierte Benachrichtigungen. Das spart einen Schritt in dieser Pipeline, weil Sie keine rohen Blockchain-Daten parsen müssen, bevor Sie handeln.
Standardentscheidungen und was Sie als Nächstes beobachten sollten
Setzen Sie für alles Server-zu-Server standardmäßig auf Webhooks, besonders auf Serverless-Infrastruktur, wo eine offene Verbindung architektonisch keinen Sinn ergibt. Setzen Sie auf WebSockets, wenn ein Mensch auf einen Bildschirm schaut und darauf wartet, dass sich in unter einer Sekunde etwas ändert. Die meisten realen Systeme kombinieren am Ende beides, statt dogmatisch eines zu wählen, und das ist kein Kompromiss, sondern meist das richtige Design.
Behalten Sie WebTransport und WebSocketStream im Auge. Keines von beiden hat WebSockets bisher vollständig verdrängt, aber beide zielen auf die Lücken bei Backpressure und Stream-Behandlung, die rohen WebSocket-Code schwerer korrekt schreibbar machen, als er sein müsste.
Zuverlässige Webhook-Zustellung, ohne sie selbst zu bauen
Ingestion, Verifizierung und Wiederholungslogik für Webhooks zu bauen kostet echte Entwicklungszeit. Die Blockchain-Webhooks von Chaingateway senden HMAC-signierte, dekodierte Ereignisbenachrichtigungen für Ethereum, Tron, Bitcoin, Polygon, BNB Chain und Arbitrum, sodass das obige Fan-Out-Muster mit einer verifizierten Nutzlast beginnt. Solana hat keine Webhooks, fragen Sie dort die Endpunkte für Guthaben und Transaktionen per Polling ab.

Chaingateway übernimmt das Anlegen und Signieren der Webhooks und listet fehlgeschlagene Benachrichtigungen auf, damit Sie sie erneut senden können. Sie kümmern sich um die Queue und den WebSocket-Fan-Out an Ihre Nutzer. Die Tarife beginnen bei 49 € pro Monat (490 € pro Jahr) mit einer 7-tägigen kostenlosen Testphase ohne Karte, und die Preisseite listet die Stufen auf.
Quellen
- RFC 6455: The WebSocket Protocol
- WebSockets API, MDN
- Webhook Security Cheat Sheet, OWASP
- WebSocket Security Cheat Sheet, OWASP
- Server-sent events, MDN
Empfohlen
Häufig gestellte Fragen
Bisher hat nichts WebSockets vollständig ersetzt, aber WebTransport und WebSocketStream sind aufkommende Alternativen, die Backpressure und gemultiplexte Streams sauberer behandeln sollen. Die Browserunterstützung ist noch lückenhaft, daher bleiben WebSockets für die meisten Echtzeitfunktionen heute die praktische Standardwahl.
Gestreamte KI-Antworten im Browser nutzen häufig Server-Sent Events (SSE) für das einseitige Token-Streaming, da der Client den Datenstrom meist nur empfangen und nicht senden muss. Manche Echtzeit-Sprachfunktionen oder interaktiven Mehrschritt-Funktionen verwenden stattdessen WebSockets, wo der bidirektionale Austausch wichtiger ist.
Webhooks brauchen einen öffentlich erreichbaren Endpunkt, was Fragen zu Firewall und Sicherheit aufwirft, und die Zustellung ist in der Regel At-least-once, Ihr Handler muss also doppelte Ereignisse vertragen. Ist Ihr Endpunkt offline, wenn ein Ereignis eintritt, und die Wiederholungen laufen ab, kann das Ereignis unbemerkt verloren gehen, sofern Sie kein Monitoring darum herum aufbauen.
Typische Beispiele sind Zahlungsbestätigungen, Git-Push- und Pull-Request-Ereignisse, CI/CD-Pipeline-Trigger sowie Einzahlungs- oder Transaktionsbenachrichtigungen in Blockchain-Netzwerken. Die webhookbasierte Verarbeitung von Einzahlungen bei Chaingateway ist ein konkretes Beispiel dafür, Zahlungsbestätigungen zu automatisieren, ohne einen Blockchain-Node per Polling abzufragen.
Die Tarife von Chaingateway beginnen bei 49 € pro Monat (490 € pro Jahr), und jeder Tarif startet mit einer 7-tägigen kostenlosen Testphase ohne Karte. Die Preisseite zeigt, was jede Stufe enthält.
Möchten Sie das selbst umsetzen? API-Key erhalten — 7 Tage kostenlos testen, keine Karte nötig — oder werfen Sie einen Blick auf Blockchain-API für die vollständige Endpoint-Referenz.