Stripe Webhook einrichten: Payment-Automatisierung mit n8n und Make.com

Stripe Webhooks sind der Schlüssel zu vollständig automatisierten Zahlungsprozessen. Statt manuell zu prüfen, ob eine Zahlung eingegangen ist, reagiert Ihr System automatisch auf jedes Event: Zahlung erfolgreich, Abo gekündigt, Rückbuchung – alles in Echtzeit. In diesem Guide zeigen wir die komplette Einrichtung.

Was sind Stripe Webhooks?

Webhooks sind HTTP-Callbacks: Stripe sendet eine Nachricht an Ihre URL, sobald etwas passiert. Wenn Sie noch nicht mit Webhooks vertraut sind, empfehlen wir zuerst unseren allgemeinen Guide Webhook erstellen: Schritt-für-Schritt-Anleitung.

Ohne Webhooks:

Kunde zahlt → Sie prüfen manuell → Stunden später: Zugang freigeschaltet

Mit Webhooks:

Kunde zahlt → Stripe sendet Event → Sofort: Zugang freigeschaltet

Wichtige Stripe Events

Schritt 1: Webhook-Endpoint erstellen

Option A: n8n Webhook

Neuer Workflow erstellen

Node hinzufügen: Webhook

Konfiguration:

- HTTP Method: POST

- Path: stripe-webhook

URL kopieren: https://ihre-n8n-instanz.com/webhook/stripe-webhook

Option B: Make.com Webhook

Neues Szenario erstellen

Trigger: Webhooks > Custom webhook

URL kopieren und bei Stripe eintragen

Schritt 2: Webhook bei Stripe registrieren

Im Stripe Dashboard

Dashboard → Developers → Webhooks

"Add endpoint" klicken

Endpoint URL eintragen

Events auswählen (z.B. checkout.session.completed)

"Add endpoint" bestätigen

Webhook Secret kopieren

Nach dem Erstellen zeigt Stripe einen Signing Secret an:

whsec_1234567890abcdefghijklmnop

Wichtig: Diesen Key sicher speichern – für die Signatur-Verifizierung!

Per Stripe CLI (für Entwicklung)

# Stripe CLI installieren
brew install stripe/stripe-cli/stripe

# Login
stripe login

# Webhooks an localhost weiterleiten
stripe listen --forward-to localhost:5678/webhook/stripe-webhook

# Zeigt temporären Signing Secret

Schritt 3: Signatur verifizieren (Sicherheit!)

Warum wichtig? Ohne Verifizierung könnte jeder Fake-Events an Ihren Endpoint senden.

n8n: Signatur prüfen

// Node: Code (vor allen anderen Nodes)
const crypto = require('crypto');

const payload = $json.body; // Raw body
const signature = $headers['stripe-signature'];
const webhookSecret = 'whsec_1234567890abcdefghijklmnop';

// Stripe Signatur-Format: t=timestamp,v1=signature
const elements = signature.split(',');
const timestamp = elements.find(e => e.startsWith('t=')).split('=')[1];
const expectedSig = elements.find(e => e.startsWith('v1=')).split('=')[1];

// Signatur berechnen
const signedPayload = ${timestamp}.${JSON.stringify(payload)};
const computedSig = crypto
  .createHmac('sha256', webhookSecret)
  .update(signedPayload)
  .digest('hex');

if (computedSig !== expectedSig) {
  throw new Error('Invalid signature');
}

// Timestamp prüfen (max 5 Minuten alt)
const now = Math.floor(Date.now() / 1000);
if (now - parseInt(timestamp) > 300) {
  throw new Error('Timestamp too old');
}

return $json;

Make.com: HTTP Module mit Verifizierung

In Make.com können Sie ein HTTP-Modul vorschalten, das die Signatur prüft.

Schritt 4: Events verarbeiten

Workflow: Checkout abgeschlossen

Stripe Webhook
(checkout.session.completed)
        ↓
    Signatur verifizieren
        ↓
    Kundendaten extrahieren
        ↓
    Parallel:
    ├─ Datenbank: User erstellen/aktivieren
    ├─ E-Mail: Willkommens-Mail senden
    ├─ CRM: Deal als gewonnen markieren
    └─ Slack: Team benachrichtigen

n8n Implementation

Node 1: Webhook Trigger

// Webhook empfängt Event
{
  "type": "checkout.session.completed",
  "data": {
    "object": {
      "id": "cs_1234",
      "customer": "cus_1234",
      "customer_email": "kunde@example.com",
      "amount_total": 9900,
      "currency": "eur",
      "metadata": {
        "plan": "pro",
        "user_id": "123"
      }
    }
  }
}

Node 2: Switch nach Event-Typ

// Node: Switch
const eventType = $json.type;

switch(eventType) {
  case 'checkout.session.completed':
    return { route: 'checkout_completed' };
  case 'invoice.paid':
    return { route: 'invoice_paid' };
  case 'customer.subscription.deleted':
    return { route: 'subscription_cancelled' };
  default:
    return { route: 'unknown' };
}

Node 3: Daten extrahieren

// Node: Set
{
  "customerId": "{{ $json.data.object.customer }}",
  "email": "{{ $json.data.object.customer_email }}",
  "amount": "{{ $json.data.object.amount_total / 100 }}",
  "plan": "{{ $json.data.object.metadata.plan }}",
  "userId": "{{ $json.data.object.metadata.user_id }}"
}

Node 4: User aktivieren (Ihre Datenbank)

// Node: HTTP Request (zu Ihrer API)
{
  "method": "POST",
  "url": "https://api.ihre-app.de/users/activate",
  "body": {
    "userId": "{{ $json.userId }}",
    "plan": "{{ $json.plan }}",
    "stripeCustomerId": "{{ $json.customerId }}"
  }
}

Workflow: Abo-Zahlung fehlgeschlagen

Stripe Webhook
(invoice.payment_failed)
        ↓
    Versuch-Nummer prüfen
        ↓
    Switch:
    ├─ Versuch 1: Freundliche E-Mail
    ├─ Versuch 2: Dringende E-Mail
    ├─ Versuch 3: Letzte Warnung
    └─ Versuch 4: Zugang sperren

Implementation

// Node: Code
const invoice = $json.data.object;
const attemptCount = invoice.attempt_count;

let action, emailTemplate;

switch(attemptCount) {
  case 1:
    action = 'soft_reminder';
    emailTemplate = 'payment_failed_soft';
    break;
  case 2:
    action = 'urgent_reminder';
    emailTemplate = 'payment_failed_urgent';
    break;
  case 3:
    action = 'final_warning';
    emailTemplate = 'payment_failed_final';
    break;
  default:
    action = 'suspend_account';
    emailTemplate = 'account_suspended';
}

return { action, emailTemplate, attemptCount };

Workflow: Rückerstattung

Stripe Webhook
(charge.refunded)
        ↓
    Vollständig oder teilweise?
        ↓
    Vollständig:
    ├─ Zugang entziehen
    ├─ Interne Notiz erstellen
    └─ Team benachrichtigen
        ↓
    Teilweise:
    └─ Nur loggen

Workflow: Chargeback (Dispute)

Stripe Webhook
(charge.dispute.created)
        ↓
    SOFORT Alert an Team!
        ↓
    Slack: @channel Alert
        ↓
    Zendesk: High-Priority Ticket
        ↓
    Alle Kundendaten sammeln
    (für Stripe Dispute Response)

Wichtig: Chargebacks kosten 15€ Gebühr und können zu Account-Sperrung führen!

Make.com Szenario: Stripe Checkout

Module-Aufbau

Webhooks → Custom Webhook

JSON → Parse JSON

Router → Nach Event-Typ

HTTP → Ihre API aufrufen

Email → Bestätigung senden

Slack → Team benachrichtigen

Filter-Beispiel

// Nur bei bestimmten Produkten
Bedingung: {{data.object.metadata.product_type}} = "subscription"

Erweiterte Patterns

Mehr Hintergrundwissen zu APIs und deren Integration finden Sie in unserem Artikel API-Integration erklärt.

Idempotenz sicherstellen

Stripe kann Events mehrfach senden. Verhindern Sie doppelte Verarbeitung:

// Node: Code
const eventId = $json.id; // z.B. "evt_1234"

// Prüfen ob bereits verarbeitet
const existing = await getFromDatabase('stripe_events', eventId);
if (existing) {
  return { skip: true, reason: 'already_processed' };
}

// Als verarbeitet markieren
await saveToDatabase('stripe_events', {
  id: eventId,
  type: $json.type,
  processedAt: new Date().toISOString()
});

return { skip: false };

Retry-Logik

Wenn Ihr Endpoint ausfällt, versucht Stripe es erneut:

Tipp: Antworten Sie immer mit Status 200, auch bei Fehlern – und verarbeiten Sie asynchron.

Webhook-Queue für Ausfallsicherheit

Stripe Webhook
        ↓
    In Queue speichern (Redis/SQS)
        ↓
    Sofort 200 OK antworten
        ↓
    [Asynchron]
    Worker verarbeitet Queue

Testen

Stripe Test-Events

Im Stripe Dashboard:

Developers → Webhooks → Endpoint auswählen

"Send test webhook" klicken

Event-Typ auswählen

"Send test webhook"

Stripe CLI

# Test-Event senden
stripe trigger checkout.session.completed

# Mit Custom Daten
stripe trigger payment_intent.succeeded \
  --add payment_intent:metadata.user_id=123

n8n Test-Mode

Workflow öffnen

"Test Workflow" aktivieren

Stripe Test-Event senden

Daten inspizieren

Debugging

Event-Logs in Stripe

Dashboard → Developers → Webhooks → Events

Zeigt:

• Alle gesendeten Events
• HTTP-Antwort Ihres Servers
• Retry-Versuche

Häufige Fehler

Produktions-Checkliste

Kosten

ROI: Automatische Verarbeitung spart 5-10h/Woche bei 100+ Transaktionen.

Weiterführende Artikel

• Webhook erstellen: Schritt-für-Schritt-Anleitung
• API-Integration erklärt: Grundlagen und Best Practices

Fazit

Stripe Webhooks sind essentiell für jedes SaaS/E-Commerce-Business:

• Echtzeit-Reaktion auf Zahlungen
• Vollautomatische Abo-Verwaltung
• Proaktives Churn-Management
• Compliance (Rechnungen, etc.)

Häufige Fragen

Was kostet ein Stripe Webhook Setup?

Die technische Einrichtung eines einzelnen Webhooks ist in wenigen Stunden erledigt. Die Kosten hängen davon ab, wie komplex Ihre Geschäftslogik ist -- einfache Benachrichtigungen ab 500 EUR, vollständige Zahlungs-Workflows mit Buchhaltungsanbindung ab 2.000 EUR.

Wie sicher sind Stripe Webhooks?

Sehr sicher, wenn korrekt implementiert. Stripe signiert jeden Webhook mit einem Shared Secret. Durch Verifizierung der Signatur stellen Sie sicher, dass die Daten tatsächlich von Stripe stammen und nicht manipuliert wurden.

Kann ich Stripe Webhooks ohne Programmierkenntnisse einrichten?

Ja, mit No-Code Tools wie Make.com oder n8n können Sie Stripe Webhooks empfangen und verarbeiten, ohne eine Zeile Code zu schreiben. Die Grundkonfiguration im Stripe Dashboard ist in wenigen Minuten erledigt.

Was passiert, wenn mein Webhook-Endpunkt nicht erreichbar ist?

Stripe hat einen eingebauten Retry-Mechanismus. Fehlgeschlagene Webhooks werden automatisch bis zu 72 Stunden lang erneut gesendet -- mit zunehmendem zeitlichem Abstand zwischen den Versuchen.

Welche Stripe-Events sollte ich abonnieren?

Das hängt von Ihrem Use Case ab. Die wichtigsten sind checkout.session.completed für erfolgreiche Zahlungen, invoice.payment_failed für fehlgeschlagene Zahlungen und customer.subscription.updated für Abo-Änderungen.

Stripe Integration vom Profi einrichten lassen

Sie möchten Ihre Stripe-Zahlungen professionell automatisieren, haben aber keine Zeit oder Kapazität für die technische Umsetzung? Wir bei Balane Tech sind spezialisiert auf Payment-Automatisierung mit Stripe, n8n und Make.com.

Was wir für Sie umsetzen:

• Stripe Webhook-Einrichtung und Absicherung
• Automatische Rechnungserstellung und Versand
• Abo-Management mit automatischer Verlängerung/Kündigung
• Anbindung an Ihre Buchhaltung (DATEV, lexoffice, Billomat)
• Fehlermonitoring und Alerting

Kostenlose Erstberatung vereinbaren →

Nächste Schritte

Webhook-Endpoint erstellen (n8n/Make.com)

Bei Stripe registrieren

Signatur-Verifizierung implementieren

Ersten Event verarbeiten (checkout.session.completed)

Weitere Events hinzufügen

Wir unterstützen Sie bei der Stripe-Integration -- von der Einrichtung bis zur komplexen Abo-Logik. Jetzt Kontakt aufnehmen.