Architekturdiagramm des WhatsApp-Lead-Generierungs-Bots — Konversations-Zustandsmaschine mit GPT-4o-Qualifizierung, CRM-Schreibvorgang und Human-Handover auf dunklem Hintergrund
Sie werden bauen: Eingehender WhatsApp-Lead-Gen-Bot · Konversations-Zustandsmaschine (Redis) · GPT-4o-Qualifizierungs-Scoring · CRM-API-Schreibvorgang · Slack-Handover-Alert · n8n-No-Code-Alternative · Vollständiger Node.js-Code durchgehend
Was Sie in diesem Tutorial bauen werden
Eingehender WhatsApp-Bot, der Leads durch Konversation qualifiziert
Redis-gestützte Zustandsmaschine, die die Phase jedes Kontakts verfolgt
GPT-4o-Scoring von Leads 1–10 mit JSON-Ausgabe
HubSpot/Pipedrive-CRM-Schreibvorgang bei Qualifizierung
Slack-Alert für Human-Handover bei hochbewerteten Leads
n8n-No-Code-Alternative für den gesamten Flow

Inbound-First: Warum diese Architektur Outbound-Bots übertrifft

Jedes No-Code-WhatsApp-Chatbot-Tutorial setzt standardmäßig auf Outbound — Templates, BotPress, Make.com, Nachrichten an Listen senden. Das ist der schwierige Weg. Meta erfordert Template-Genehmigung (1–5 Werktage), berechnet Gebühren pro ausgehender Nachricht und sperrt Nummern, die als Spam markierte Inhalte senden. Die meisten Tutorials übergehen dies und dann entdecken Sie es um 23 Uhr, wenn Ihre Nummer eingeschränkt wird.

Die bessere Architektur ist Inbound-First:

  • Der Kunde sendet Ihnen zuerst eine Nachricht (von einer Click-to-WhatsApp-Anzeige, einem WhatsApp-Link oder einem QR-Code)
  • Dadurch öffnet sich ein kostenloses 24-Stunden-Service-Fenster — alle Ihre Antworten sind kostenlos
  • Keine Template-Genehmigung erforderlich für Antworten innerhalb dieses Fensters
  • Ihr Webhook feuert, Ihr Bot übernimmt, Leads qualifizieren sich selbst

Dies ist keine passive Strategie. Sie generieren eingehenden Traffic mit bezahlten Anzeigen — Click-to-WhatsApp auf Facebook und Instagram sendet Personen direkt in eine WhatsApp-Konversation mit Ihrer Nummer. Meta gewährt Ihnen ein kostenloses 72-Stunden-Fenster für diese Konversationen (nicht nur 24). Sie bezahlen für den Anzeigen-Klick. Das Qualifizierungsgespräch ist kostenlos.

Architektur-Übersicht

Fünf Komponenten. Alle sind austauschbar — tauschen Sie HubSpot gegen Salesforce, GPT-4o gegen Claude 3, Redis gegen DynamoDB. Die Architektur ist die Konstante; die Anbieter sind optional.

Architektur
pipeline.txt
Kunde sendet WhatsApp-Nachricht ↓ [WhatsApp Cloud API] — feuert HTTP POST Webhook ↓ [SocialHook] — verifiziert HMAC, normalisiert Payload, <50ms Lieferung ↓ [Ihr Webhook-Server — Node.js / Express] 1. Konversationszustand aus Redis laden (nach Telefonnummer) 2. Zustandsmaschine vorrücken: nächste Qualifizierungsfrage stellen 3. ODER: GPT-4o für finales Scoring aufrufen 4. Über Cloud API Graph-Endpoint antworten 5. Aktualisierten Zustand in Redis speichern ↓ [Redis] — Konversationszustandsspeicher (TTL: 48h pro Kontakt) ↓ Bei QUALIFIZIERT (Score ≥ 7): → POST an HubSpot / Pipedrive CRM API → POST an Slack Webhook (Sales-Team-Alert) → Antwort an Kunden: "Ein Spezialist meldet sich in 2 Std. bei Ihnen" Bei DISQUALIFIZIERT (Score < 4): → In Datenbank protokollieren → Hilfreichen Ressourcen-Link senden → Konversation abschließen

Schritt 1: Die Webhook-Schicht zum Laufen bringen

Bevor Sie Bot-Logik schreiben, müssen eingehende WhatsApp-Nachrichten als sauberes JSON bei Ihrem Server ankommen. Der schnellste Weg: Verbinden Sie Ihre WhatsApp-Nummer mit SocialHook, fügen Sie Ihre Server-URL als Ziel ein, und jede eingehende Nachricht kommt als normalisierter Payload in unter 50 ms an.

Wenn Sie stattdessen direkte Cloud-API-Webhooks möchten, folgen Sie der vollständigen Einrichtungsanleitung. Für dieses Tutorial verwenden wir das normalisierte Format von SocialHook, das die Notwendigkeit von HMAC-Verifizierungscode und verschachtelter Payload-Extraktion in Ihrem Bot-Handler eliminiert.

Der Payload, den Ihr Bot-Handler für jede eingehende Kundennachricht erhält:

JSON
inbound-event.json (SocialHook normalisiert)
{ "platform": "whatsapp", "event": "message.received", "timestamp": 1747231892, "from": "+1 555 000 1234", // E.164 — der Schlüssel der Zustandsmaschine "conversation_id": "conv_8j3k...", "message": { "type": "text", "body": "Hi, I want to know more about your product", "id": "wamid.HBgL..." }, "signature_verified": true }

Schritt 2: Die Konversations-Zustandsmaschine entwerfen

Die Zustandsmaschine ist das Herzstück des Bots. Jede WhatsApp-Nachricht ist ein zustandsloses HTTP-Ereignis — Ihr Server hat kein Gedächtnis für vorherige Nachrichten, es sei denn, Sie speichern sie. Redis bietet Ihnen einen schnellen, TTL-basierten Key-Value-Speicher pro Telefonnummer. Das Zustandsobjekt verfolgt sowohl welchen Schritt die Konversation erreicht hat als auch welche Daten bisher gesammelt wurden.

Hier ist der vollständige Qualifizierungs-Flow mit 7 Zuständen:

GREETING
Hey! 👋 Danke, dass Sie sich an [Company] wenden. Ich bin hier, um die richtige Lösung für Sie zu finden. Wie ist Ihr Name?
→ COLLECT_NAME
COLLECT_NAME
Schön, Sie kennenzulernen, [name]! Von welchem Unternehmen sind Sie?
→ COLLECT_COMPANY
COLLECT_COMPANY
Super. Was versuchen Sie zu lösen — was ist der Hauptschmerzpunkt, der Sie heute hierher bringt?
→ COLLECT_USE_CASE
COLLECT_USE_CASE
Verstanden. Ungefähr wie viele Nachrichten oder Konversationen bearbeiten Sie pro Monat?
→ COLLECT_VOLUME
COLLECT_VOLUME
Und was ist Ihr ungefähres monatliches Budget für diese Art von Tool?
→ COLLECT_BUDGET
COLLECT_BUDGET
Danke — geben Sie mir nur einen Moment, während ich die richtigen Informationen für Sie zusammenstelle. ⏳
→ QUALIFYING (GPT-4o)
QUALIFIED (Score ≥ 7)
Sie passen hervorragend zu dem, was wir anbieten. Ein Spezialist wird sich innerhalb von 2 Stunden melden. Kann ich Ihre E-Mail bestätigen?
→ CRM write + Slack
DISQUALIFIED (Score < 4)
Danke [name]! Basierend auf Ihren Bedürfnissen ist hier eine Ressource, die helfen könnte: [link]. Melden Sie sich gerne, wenn der Zeitpunkt passt.
→ Log + close

So sieht die Konversation aus Kundensicht aus:

YourCompany Bot
● online
Zustand: GREETING
Hey! 👋 Danke, dass Sie sich melden. Ich bin hier, um die richtige Lösung für Sie zu finden. Wie ist Ihr Name?
Hi, ich bin Sarah
Zustand: COLLECT_COMPANY
Schön, Sie kennenzulernen, Sarah! Von welchem Unternehmen sind Sie?
Acme Corp, wir sind eine E-Commerce-Marke mit etwa 50k Bestellungen pro Monat
Zustand: COLLECT_USE_CASE
Super. Was versuchen Sie zu lösen — was ist der Hauptschmerzpunkt, der Sie heute hierher bringt?
Wir ertrinken in WhatsApp-Support-Tickets. Wir müssen Bestellstatus und Retouren automatisieren
Zustand: QUALIFYING → GPT-4o-Scoring
Danke — geben Sie mir nur einen Moment, während ich die richtigen Informationen für Sie zusammenstelle. ⏳
Zustand: QUALIFIED (Score: 9/10) → CRM write + Slack-Alert
Sie passen hervorragend zu dem, was wir anbieten, Sarah. Ein Spezialist wird sich innerhalb von 2 Stunden melden, um Ihr spezifisches Setup zu besprechen. Kann ich Ihre E-Mail für das Follow-up bestätigen?

Schritt 3: Die Zustandsmaschine in Node.js bauen

Der Webhook-Handler lädt den Zustand aus Redis, führt die Zustandsmaschinen-Logik aus, antwortet über die Cloud API und speichert den neuen Zustand. Dies ist die vollständige produktionsreife Implementierung:

Node.js + Express + Redis
leadBot.js
const express = require('express'); const redis = require('redis'); const { sendWhatsApp } = require('./whatsapp'); // siehe unten const { scoreLead } = require('./scorer'); // GPT-4o-Scorer const { writeCRM, notifySlack } = require('./integrations'); const app = express(); const store = redis.createClient({ url: process.env.REDIS_URL }); await store.connect(); app.use(express.json()); // SocialHook postet normalisierte Ereignisse hierher app.post('/webhook', async (req, res) => { res.sendStatus(200); // sofort bestätigen const event = req.body; if (event.event !== 'message.received') return; if (event.message.type !== 'text') return; const phone = event.from; const text = event.message.body.trim(); // Zustand laden — Standard auf GREETING bei erstem Kontakt const raw = await store.get(`lead:${phone}`); const state = raw ? JSON.parse(raw) : { stage: 'GREETING', data: {} }; const next = await advance(phone, text, state); // Aktualisierten Zustand mit 48h TTL speichern await store.set( `lead:${phone}`, JSON.stringify(next), { EX: 172800 } // 48 Stunden ); }); async function advance(phone, text, state) { switch (state.stage) { case 'GREETING': await sendWhatsApp(phone, "Hey! 👋 Danke, dass Sie sich melden. Wie ist Ihr Name?" ); return { stage: 'COLLECT_NAME', data: {} }; case 'COLLECT_NAME': await sendWhatsApp(phone, `Schön, Sie kennenzulernen, ${text}! Von welchem Unternehmen sind Sie?` ); return { stage: 'COLLECT_COMPANY', data: { name: text } }; case 'COLLECT_COMPANY': await sendWhatsApp(phone, "Was ist der Hauptschmerzpunkt, der Sie heute hierher bringt?" ); return { stage: 'COLLECT_USE_CASE', data: { ...state.data, company: text } }; case 'COLLECT_USE_CASE': await sendWhatsApp(phone, "Ungefähr wie viele Konversationen bearbeiten Sie pro Monat?" ); return { stage: 'COLLECT_VOLUME', data: { ...state.data, useCase: text } }; case 'COLLECT_VOLUME': await sendWhatsApp(phone, "Und Ihr ungefähres monatliches Budget dafür?" ); return { stage: 'COLLECT_BUDGET', data: { ...state.data, volume: text } }; case 'COLLECT_BUDGET': { await sendWhatsApp(phone, "Danke — nur einen Moment, während ich die richtigen Informationen für Sie zusammenstelle. ⏳" ); const leadData = { ...state.data, budget: text }; // Asynchron qualifizieren — nicht blockieren, Caller behandelt Zustand qualifyLead(phone, leadData); // Fire-and-forget mit eigener Fehlerbehandlung return { stage: 'QUALIFYING', data: leadData }; } case 'COLLECT_EMAIL': { // Letzter Schritt nach QUALIFIED — E-Mail sammeln und abschließen const finalData = { ...state.data, email: text }; await writeCRM(phone, finalData); await sendWhatsApp(phone, `Perfekt, ${finalData.name}! Alles erledigt. Bis bald. 🚀` ); return { stage: 'DONE', data: finalData }; } default: return state; // QUALIFYING / DONE / DISQUALIFIED — weitere Nachrichten ignorieren } } app.listen(3000);

Schritt 4: GPT-4o-Lead-Qualifizierungs-Scoring

Sobald alle Qualifizierungsdaten gesammelt sind, senden Sie sie mit einem strukturierten Prompt an GPT-4o. Das Modell gibt ein JSON-Score-Objekt zurück — kein Regex-Parsing, kein Raten. Der Schlüssel ist, das Modell anzuweisen, nur JSON und nichts anderes zurückzugeben.

7 – 10
Heißer Lead
Sofortiger Human-Handover. Slack-Alert an Sales. CRM-Deal mit hoher Priorität erstellt. Kunde wird informiert, dass sich ein Spezialist innerhalb von 2 Stunden meldet.
4 – 6
Warmer Lead
CRM-Kontakt mit mittlerer Priorität erstellt. Automatisierte E-Mail-Sequenz ausgelöst. Kunde erhält Produkt-Ressourcen und Case Study.
1 – 3
Keine Passung
Protokolliert, aber kein CRM-Deal. Kunde erhält hilfreiche Ressource. Konversation wird mit höflicher Abschiedsnachricht abgeschlossen.
Node.js + OpenAI
scorer.js
const OpenAI = require('openai'); const oai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY }); async function scoreLead(leadData) { const prompt = `Du bist Experte für B2B-Lead-Qualifizierung. Bewerte diesen Lead von 1 bis 10 basierend auf Fit und Intent. Gib NUR ein JSON-Objekt zurück — kein Vorwort, kein Markdown. Lead-Daten: - Name: ${leadData.name} - Unternehmen: ${leadData.company} - Anwendungsfall: ${leadData.useCase} - Volumen: ${leadData.volume} Konversationen/Monat - Budget: ${leadData.budget}/Monat Unser Produkt: WhatsApp Webhook-Infrastruktur für Entwickler. Idealer Kunde: Technisches Team, 500+ Konvos/Monat, Budget $50–$500. Gib exakt diese JSON-Struktur zurück: { "score": <1-10 Integer>, "rationale": "", "action": "handover" | "nurture" | "disqualify", "priority": "high" | "medium" | "low" }`; const response = await oai.chat.completions.create({ model: 'gpt-4o', max_tokens: 200, temperature: 0.2, // niedrige Temp = konsistente Bewertung messages: [{ role: 'user', content: prompt }], response_format: { type: 'json_object' } // erzwingt JSON-Output }); return JSON.parse(response.choices[0].message.content); } // Aufruf nach COLLECT_BUDGET — voller async Flow async function qualifyLead(phone, leadData) { try { const result = await scoreLead(leadData); if (result.action === 'handover') { await sendWhatsApp(phone, `Du passt perfekt zu uns, ${leadData.name}! Ein Spezialist meldet sich in 2 Std. Wie lautet deine E-Mail?` ); await store.set(`lead:${phone}`, JSON.stringify({ stage: 'COLLECT_EMAIL', data: { ...leadData, score: result.score } }), { EX: 172800 }); await notifySlack(phone, leadData, result); } else if (result.action === 'nurture') { await sendWhatsApp(phone, `Danke ${leadData.name}! Hier ist eine Case Study, die zu deiner Situation passt: [link]` ); } else { await sendWhatsApp(phone, `Danke für deine Nachricht! Aktuell passen wir eventuell nicht optimal zusammen, aber hier ist eine nützliche Ressource: [link]` ); } } catch (err) { console.error('Scorer Fehler:', err); // Fallback: trotzdem an Mitarbeiter weiterleiten await sendWhatsApp(phone, "Ich verbinde dich mit unserem Team. Einen Moment bitte!"); await notifySlack(phone, leadData, { score: 'ERROR', rationale: err.message }); } } module.exports = { scoreLead, qualifyLead };

Schritt 5: Qualifizierte Leads in dein CRM schreiben

Sobald die Bewertung vorliegt, schreibst du den Lead in HubSpot (oder Pipedrive, Salesforce — tausche einfach den Endpunkt aus). Die WhatsApp-Nummer dient als Kontakt-ID. Übergib eine Zusammenfassung der Konversation, damit der Vertriebsmitarbeiter beim Anruf den vollen Kontext hat.

Node.js + HubSpot API
integrations.js — writeCRM()
async function writeCRM(phone, leadData) { const contact = { properties: { phone: phone, firstname: leadData.name, company: leadData.company, email: leadData.email ?? '', // Custom Properties — diese zuerst in HubSpot anlegen whatsapp_use_case: leadData.useCase, whatsapp_volume: leadData.volume, whatsapp_budget: leadData.budget, lead_score: leadData.score.toString(), lead_source: 'whatsapp_bot', } }; // Kontakt erstellen oder aktualisieren (Upsert per Telefonnummer) await fetch('https://api.hubapi.com/crm/v3/objects/contacts', { method: 'POST', headers: { 'Authorization': `Bearer ${process.env.HUBSPOT_TOKEN}`, 'Content-Type': 'application/json', }, body: JSON.stringify(contact), }); } // Slack-Benachrichtigung für persönliche Übergabe async function notifySlack(phone, leadData, scoring) { await fetch(process.env.SLACK_WEBHOOK_URL, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: `🔥 *Neuer WhatsApp Lead — Score: ${scoring.score}/10*`, blocks: [{ type: 'section', text: { type: 'mrkdwn', text: `*${leadData.name}* von *${leadData.company}*\n📞 ${phone}\n💬 Case: ${leadData.useCase}\n📊 Volumen: ${leadData.volume}\n💰 Budget: ${leadData.budget}\n🤖 KI-Begründung: ${scoring.rationale}` } }] }) }); }``` module.exports = { writeCRM, notifySlack };

Schritt 6: WhatsApp-Antworten von deinem Server senden

Dein Bot sendet Antworten über den WhatsApp Cloud API-Endpunkt /messages. Dies ist die Outbound-Seite — verwende dein permanentes Systembenutzer-Zugriffstoken und deine Telefonnummern-ID.

Node.js
whatsapp.js — sendWhatsApp()
const GRAPH = 'https://graph.facebook.com/v21.0'; const PHONE_ID = process.env.WHATSAPP_PHONE_NUMBER_ID; const TOKEN = process.env.WHATSAPP_ACCESS_TOKEN; async function sendWhatsApp(to, body) { const res = await fetch(`${GRAPH}/${PHONE_ID}/messages`, { method: 'POST', headers: { 'Authorization': `Bearer ${TOKEN}`, 'Content-Type': 'application/json', }, body: JSON.stringify({ messaging_product: 'whatsapp', to, // E.164 — z.B. '+15550001234' type: 'text', text: { body, preview_url: false }, }), }); if (!res.ok) { throw new Error(`WhatsApp-Versand fehlgeschlagen: ${await res.text()}`); } return await res.json(); } module.exports = { sendWhatsApp };
Format der Telefonnummer: SocialHook liefert das Feld from im E.164-Format inklusive +-Präfix (+15550001234). Das to-Feld der Cloud API erwartet ebenfalls E.164. Nutze event.from direkt als deinen to-Wert — bei Verwendung des normalisierten Formats von SocialHook ist keine Umwandlung erforderlich.

No-Code-Alternative: Der n8n-Workflow

Wenn du den gleichen Bot ohne Node.js-Code bauen möchtest, kannst du dies in n8n tun. Die Architektur bleibt identisch — SocialHook liefert den Webhook an n8n, und n8n übernimmt die Zustandslogik (State Management) mithilfe von Code-Nodes und einer Redis-Integration.

n8n Workflow
n8n-lead-gen-workflow.txt
n8n Workflow: WhatsApp Lead Gen Bot ────────────────────────────────────── 1. Webhook Trigger → Methode: POST → Pfad: /whatsapp-lead → URL: in SocialHook Ziel einfügen 2. Code Node — State laden → Redis: GET lead:{{ $json.from }} → JSON parsen oder Default { stage: 'GREETING', data: {} } 3. Switch Node — Verzweigung nach state.stage → GREETING → Zweig A → COLLECT_NAME → Zweig B → COLLECT_* → Zweige C–E → COLLECT_BUDGET → Zweig F (triggert Scoring) → COLLECT_EMAIL → Zweig G (finaler CRM-Write) 4. HTTP Request Node (pro Zweig) → POST an graph.facebook.com/v21.0/${PHONE_ID}/messages → Body: { messaging_product, to, type: 'text', text: { body } } → Auth: Bearer Token Header 5. Code Node — State aktualisieren → Redis: SET lead:{{ $json.from }} {{ JSON.stringify(newState) }} EX 172800 6. Im Zweig COLLECT_BUDGET: → OpenAI Node: Chat Completions (gpt-4o) → Message: Scoring-Prompt mit Lead-Daten → JSON-Antwort parsen: score, action 7. Switch Node — Verzweigung nach action → handover: → Slack Node + HubSpot Kontakt erstellen → nurture: → HTTP Request (Ressourcen-Nachricht senden) → disqualify: → HTTP Request (Exit-Nachricht senden) Abhängigkeiten: Redis-Integration, OpenAI-Integration, HubSpot-Integration — alle nativ in n8n verfügbar.
SocialHook + n8n: Konfiguriere SocialHook so, dass Webhook-Events an deine n8n Webhook-URL weitergeleitet werden. SocialHook übernimmt die HMAC-Verifizierung von Meta und die Normalisierung des Payloads — n8n erhält einen sauberen JSON-Body ohne Vorverarbeitung. Dies funktioniert sowohl bei selbstgehostetem n8n als auch in der n8n Cloud. Details zum HTTP-Setup findest du im SocialHook n8n Integrations-Guide.

Schritt 7: Inbound-Traffic auf deinen Bot lenken

Ein Webhook-Bot ohne Traffic ist nur ein Server, der sinnlos Rechenleistung verbraucht. Hier sind drei Kanäle, die Inbound-WhatsApp-Konversationen ohne erforderliche Template-Zulassung generieren:

Click-to-WhatsApp Ads (Facebook + Instagram)

Erstelle eine Lead-Gen-Anzeige auf Facebook oder Instagram mit einem Click-to-WhatsApp CTA. Sobald jemand klickt, öffnet sich WhatsApp mit deiner vorab ausgefüllten Nummer. Sendet der Nutzer eine Nachricht, öffnet sich dein kostenloses 72-Stunden-Fenster und dein Bot startet. Dies ist der Kanal mit der höchsten Conversion — du targetest nach Interesse und Absicht, und der Sprung von der Anzeige zur Konversation erfolgt mit nur einem Klick. Jede Konversation, die dein Bot über eine CTA-Anzeige qualifiziert, ist für 72 Stunden von den Meta-Nachrichtengebühren befreit.

WhatsApp-Link / QR-Code

Erzeuge einen wa.me/+{deine_nummer}?text=Hi Link. Binde ihn auf deiner Website, in E-Mail-Signaturen, LinkedIn-Profilen und Landingpages ein. Ein Klick öffnet eine vorformulierte WhatsApp-Nachricht an deine Nummer. Eine QR-Code-Version funktioniert hervorragend auf Printmedien, Events und Verpackungen. Null Kosten, null Setup außer der Link-Generierung.

WhatsApp-Button auf deiner Website

Ein schwebender WhatsApp-Button ersetzt dein Live-Chat-Widget — und konvertiert signifikant besser. Besucher gelangen direkt zu WhatsApp (mobil) oder scannen einen QR-Code (Desktop). Dein Bot übernimmt die Qualifizierung, bevor ein Mensch die Konversation übernimmt. Dies ersetzt teure Live-Chat-Abos durch deine eigene Qualifizierungs-Infrastruktur für insgesamt ca. 50 $/Monat.

FAQ

Häufig gestellte Fragen

Wie funktioniert ein WhatsApp Lead-Generation-Bot mit Webhooks?
Wenn ein Kunde deinem WhatsApp Business-Account schreibt, sendet die Cloud API einen HTTP-POST an deinen Webhook-Endpunkt. Dein Server liest die Nachricht, lädt den Konversationsstatus aus Redis, stellt die nächste Qualifizierungsfrage, sendet eine Antwort über die Cloud API und speichert den aktualisierten Status. Dieser Zyklus wiederholt sich für jede Nachricht, bis der Lead bewertet und weitergeleitet wird. Den genauen Ablauf findest du oben im Abschnitt Architektur.
Kann ich das ohne einen BSP bauen?
Ja. Registriere deine WhatsApp-Nummer direkt über das Meta Developer Portal (kostenlos, dauert ca. 30 Minuten). Nutze SocialHook als Webhook-Delivery-Layer — es übernimmt die HMAC-Verifizierung und Payload-Normalisierung. Du rufst die Cloud API direkt für Outbound-Antworten auf. Kein BSP erforderlich, keine BSP-Plattformgebühren. Komplette Anleitung: API-Zugriff ohne BSP erhalten.
Warum Redis für den Konversationsstatus statt einer Datenbank?
Redis arbeitet in-memory, bietet Lesezugriffe im Sub-Millisekundenbereich und unterstützt nativ TTL-basiertes Ablaufen von Schlüsseln. Dein Webhook-Handler muss den Status bei jeder Nachricht laden — Latenz beeinträchtigt hier direkt die Antwortgeschwindigkeit. Eine PostgreSQL- oder MongoDB-Abfrage fügt 5–50 ms pro Nachricht hinzu; Redis weniger als 1 ms. Das TTL-Feature bereinigt abgebrochene Gespräche automatisch (48h TTL bedeutet, dass veraltete Zustände ohne Cronjob gelöscht werden). Bei geringem Volumen (<100 gleichzeitige Gespräche) reicht eine lokale Map oder SQLite völlig aus.
Was ist der Unterschied zwischen Inbound- und Outbound-Lead-Gen auf WhatsApp?
Inbound: Der Kunde schreibt dir zuerst → kostenloses 24h-Fenster (72h bei Click-to-WhatsApp Ads) → kein Template erforderlich → Antworten innerhalb des Kontingents kostenlos. Outbound: Du nimmst zuerst Kontakt auf → erfordert von Meta genehmigtes Template → 1–5 Tage Genehmigungsdauer → Abrechnung pro Nachricht → höheres Risiko für Sperrungen. Für Lead-Generation ist Inbound-First die richtige Architektur. Lenke Traffic über Ads oder Links und lass den Bot die Qualifizierung übernehmen.
Wie viel kostet der Betrieb dieses Bots pro Monat?
Infrastruktur-Aufschlüsselung: SocialHook (Webhook-Layer) = 50 $/Monat flat. Redis (Upstash Free Tier oder 7 $/Monat) = ca. 7 $. OpenAI GPT-4o (200 Tokens pro Scoring-Call × Lead-Volumen bei ca. 0,005 $ pro Call) = ca. 5–50 $. HubSpot (Free CRM Tier) = 0 $. Cloud API Inbound = 0 $ (innerhalb des Free-Kontingents). Gesamtkosten für ca. 500 Leads/Monat: ca. 60–100 $/Monat. Keine Gebühren pro Lead, kein BSP-Abo, keine kontaktbasierte Preisgestaltung.
Wie gehe ich mit Nicht-Text-Nachrichten (Bilder, Sprachnachrichten) im Bot um?
Filtere diese im Webhook-Handler durch Prüfung von event.message.type !== 'text' und sende einen Hinweis: "Bitte sende deine Antwort als Text, damit ich dir besser helfen kann." Für Sprachnachrichten kannst du optional die event.message.id durch die Whisper API zur Transkription jagen — das erhöht jedoch Latenz und Kosten. Für die Lead-Qualifizierung ist "Text-Only" der beste Startpunkt. Siehe Erklärung aller Nachrichtentypen.
Feature
WhatsApp Webhook Integration
Normalisiertes JSON für deinen Bot in unter 50ms. HMAC-verifiziert. Retries bei Fehlern. 50 $/Monat flat.
Tutorial
Nachrichten auf deinem Server empfangen
Webhook-Setup, HMAC-Verifizierung, alle Nachrichtentypen — das Infrastruktur-Fundament für diesen Bot.
Referenz
Vollständige Webhook-Referenz
Jedes Feld, Retry-Zeitpläne, Event-Typen und HTTP-Verhalten — setze dir hierfür ein Lesezeichen beim Build.

Deine Webhook-Ebene ist nur
einen Klick entfernt.

Verbinde deine WhatsApp-Nummer mit SocialHook und empfange in weniger als 5 Minuten normalisierte JSON-Events für deinen Bot. Die State Machine, das Scoring und der CRM-Write liegen in deiner Hand — SocialHook stellt sicher, dass jede eingehende Nachricht sauber, verifiziert und bei Bedarf wiederholt ankommt.

WhatsApp kostenlos verbinden → Dokumentation lesen
Keine Kreditkarte erforderlich · 50 $/Monat nach dem Testzeitraum · Jederzeit kündbar