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

1. Neuer Workflow erstellen
2. Node hinzufügen: Webhook
3. Konfiguration:
   • HTTP Method: POST
   • Path: stripe-webhook
4. URL kopieren: https://ihre-n8n-instanz.com/webhook/stripe-webhook

Option B: Make.com Webhook

1. Neues Szenario erstellen
2. Trigger: Webhooks > Custom webhook
3. URL kopieren und bei Stripe eintragen

Schritt 2: Webhook bei Stripe registrieren

Im Stripe Dashboard

1. Dashboard → Developers → Webhooks
2. "Add endpoint" klicken
3. Endpoint URL eintragen
4. Events auswählen (z.B. checkout.session.completed)
5. "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

1. Webhooks → Custom Webhook
2. JSON → Parse JSON
3. Router → Nach Event-Typ
4. HTTP → Ihre API aufrufen
5. Email → Bestätigung senden
6. 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:

1. Developers → Webhooks → Endpoint auswählen
2. "Send test webhook" klicken
3. Event-Typ auswählen
4. "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

1. Workflow öffnen
2. "Test Workflow" aktivieren
3. Stripe Test-Event senden
4. 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

Stand: August 2026. Anbieterpreise ändern sich — prüfen Sie die aktuellen Konditionen beim Anbieter.

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 -- als Projekt beauftragt starten wir mit einem Festpreis ab 5.000 EUR für einen klar abgegrenzten Zahlungs-Workflow. Sobald mehrere Systeme angebunden werden (Stripe, Buchhaltung, CRM, Versand), beginnen die Projekte bei 15.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) -- den fertigen Aufbau für Stripe → DATEV haben wir öffentlich dokumentiert
• Fehlermonitoring und Alerting

Kostenlose Erstberatung vereinbaren →

Nächste Schritte

1. Webhook-Endpoint erstellen (n8n/Make.com)
2. Bei Stripe registrieren
3. Signatur-Verifizierung implementieren
4. Ersten Event verarbeiten (checkout.session.completed)
5. Weitere Events hinzufügen

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