Eigener WhatsApp-KI-Bot auf Server: DSGVO-konform mit OpenClaw

Direkte Antwort: Ein eigener WhatsApp-KI-Bot mit Claude läuft auf deinem deutschen VPS, nutzt das WhatsApp-Web-Protocol für die Verbindung und bleibt DSGVO-konform, weil keine Inhalte über fremde Cloud-Services laufen. OpenClaw bringt das Gateway mit, du brauchst nur einen Server, ein gepairtes WhatsApp-Konto und eine Allowlist erlaubter Kontakte.

WhatsApp ist in Deutschland mit Abstand der dominierende Messenger – über 80 % der Menschen nutzen ihn täglich. Wenn du als Solo-Selbstständiger oder kleines Team einen KI-Assistenten dort haben willst, ohne deine Konversationen über die Cloud-Dienste anderer Anbieter zu jagen, dann bauen wir den heute selbst. Mit OpenClaw, einem eigenen Server in Deutschland und WhatsApps Web-Protocol bist du in 1-2 Stunden online.

Wichtig vorweg: Es gibt zwei Wege, einen WhatsApp-Bot zu betreiben. Den offiziellen Business-API-Weg (kostet pro Nachricht, ist Meta-zertifiziert, DSGVO-bedingt komplexer) und den Web-Protocol-Weg (gratis, nutzt deinen privaten WhatsApp-Account, läuft komplett auf deinem Server). Für Solo-Use-Cases, eigene Workflows und Familien-/Team-Bots ist der Web-Protocol-Weg praktischer. Genau den machen wir hier.

Wie funktioniert WhatsApp-Web-Protocol eigentlich?

WhatsApp nutzt für die Web-Version (web.whatsapp.com) das Multi-Device-Protocol, das Meta 2021 eingeführt hat. Dein Handy ist dabei nicht mehr der zentrale Hub, sondern jedes gepairte Gerät hat einen eigenen kryptographischen Key. Pairing geschieht entweder per QR-Code (klassisch) oder per Pairing-Code (8-stellig, ab 2023 verfügbar).

Für unseren Bot bedeutet das:

1. Wir installieren auf dem VPS eine Library, die das WhatsApp-Multi-Device-Protocol spricht (z. B. Baileys oder whatsapp-web.js)
2. Wir pairen unseren Server einmalig mit unserem WhatsApp-Konto
3. Der Server kann ab dann Nachrichten empfangen und senden, als wäre er ein weiteres Endgerät
4. OpenClaw übernimmt die Logik: empfangen → an Claude weitergeben → Antwort zurückspielen

Die Keys liegen bei dir auf dem Server, die Inhalte werden direkt zwischen WhatsApp-Servern und deinem VPS ausgetauscht (E2E-verschlüsselt durch das Signal-Protocol). Das ist DSGVO-architektonisch sauberer als die meisten kommerziellen Cloud-Bots.

Die Architektur: Was läuft wo?

[WhatsApp-User]  
       ↓ (WhatsApp-Server, E2EE)  
[WhatsApp-Servers]  
       ↓ (Multi-Device-Protocol über WebSocket)  
[Dein VPS in Frankfurt]  
   ├── OpenClaw Gateway (Node.js)
   │      ↓ (über interne Adapter-Schnittstelle)
   ├── Baileys WhatsApp-Adapter
   │      ↓ (Allowlist-Check, Persona-Auswahl)
   ├── Anthropic API (Claude Sonnet/Opus)
   │      ↑ (Antwort-Stream zurück)
   └── SQLite Memory + Logging

Was an deutschen DSGVO-Standards überzeugt:

• Keine Drittanbieter-Cloud zwischen User und Bot (außer Anthropic für die LLM-Inference, was du im AVV abdeckst)
• Frankfurt-Hosting (Hetzner oder Hostinger) bedeutet EU-Rechtsraum
• Allowlist-basierter Zugriff verhindert ungewollte Nutzer
• Strukturierte Logs sind auditierbar

Ein paar Punkte zur Ehrlichkeit, damit du keine Illusionen hast:

• Anthropic ist ein US-Anbieter. Die LLM-Aufrufe verlassen die EU. Du brauchst einen DPA mit Anthropic (gibts kostenlos im Console-Portal).
• Wenn du sehr sensible Daten verarbeitest (Gesundheits-/Mandantendaten), reicht das nicht. Dann brauchst du eine EU-gehostete LLM-Alternative wie Mistral Large oder lokales Llama.
• WhatsApp-Web-Protocol ist gegen Metas TOS für gewerbliche Nutzung in Grauzonen. Für persönliche und familiäre Use-Cases unproblematisch. Für Kunden-Kommunikation solltest du auf die offizielle Business-API umsteigen.

Voraussetzungen für das Setup

• VPS in Frankfurt (Hostinger KVM 2 oder Hetzner CX22 reichen)
• Ubuntu 22.04 LTS, Node.js 22, Git
• Anthropic-API-Key
• Eine WhatsApp-fähige Telefonnummer (privat oder eine zweite Geschäfts-SIM)
• 30-60 Minuten Zeit

Wenn du den Server noch nicht hast, lies meinen Hostinger-Setup-Guide – die ersten 4 Schritte (VPS bestellen, härten, Node.js installieren) gelten auch hier.

Tipp: Für einen WhatsApp-Bot reicht ein Hostinger KVM 2 in Frankfurt mit 8 GB RAM völlig. DSGVO-konform und in 5 Minuten online. Hostinger KVM 2 ansehen →Affiliate-Link — wir erhalten eine Provision, wenn du über diesen Link bestellst. Für dich ändert sich am Preis nichts.

Installation des WhatsApp-Adapters in OpenClaw

Wenn dein OpenClaw-Setup steht, ist der WhatsApp-Adapter eine zusätzliche npm-Dependency und ein Konfig-Block.

cd /opt/openclaw
npm install @whiskeysockets/baileys @hapi/boom

Erstelle einen neuen Adapter-Ordner:

mkdir -p src/adapters/whatsapp

In src/adapters/whatsapp/index.js kommt der Connection-Code:

const { default: makeWASocket, useMultiFileAuthState, DisconnectReason } = require('@whiskeysockets/baileys');
const { Boom } = require('@hapi/boom');
const path = require('path');

async function startWhatsApp(handleMessage, config) {
    const { state, saveCreds } = await useMultiFileAuthState(
        path.join(process.cwd(), 'data', 'whatsapp-auth')
    );

    const sock = makeWASocket({
        auth: state,
        printQRInTerminal: !config.usePairingCode,
        browser: ['OpenClaw', 'Chrome', '1.0.0']
    });

    sock.ev.on('creds.update', saveCreds);

    sock.ev.on('connection.update', async (update) => {
        const { connection, lastDisconnect, qr } = update;

        if (config.usePairingCode && !sock.authState.creds.registered) {
            const phoneNumber = config.phoneNumber.replace(/[^0-9]/g, '');
            const code = await sock.requestPairingCode(phoneNumber);
            console.log(`[WhatsApp] Pairing-Code: ${code}`);
        }

        if (connection === 'close') {
            const shouldReconnect = (lastDisconnect?.error)?.output?.statusCode !== DisconnectReason.loggedOut;
            console.log('[WhatsApp] Connection closed', shouldReconnect ? '- reconnecting' : '- logged out');
            if (shouldReconnect) startWhatsApp(handleMessage, config);
        } else if (connection === 'open') {
            console.log('[WhatsApp] Connected.');
        }
    });

    sock.ev.on('messages.upsert', async ({ messages, type }) => {
        if (type !== 'notify') return;
        for (const msg of messages) {
            if (msg.key.fromMe) continue;
            const sender = msg.key.remoteJid;
            const text = msg.message?.conversation || msg.message?.extendedTextMessage?.text;
            if (!text) continue;

            // Allowlist-Check
            if (!config.allowedJIDs.includes(sender)) {
                console.log(`[WhatsApp] Rejected message from ${sender}`);
                continue;
            }

            try {
                const reply = await handleMessage({ text, sender, channel: 'whatsapp' });
                if (reply) {
                    await sock.sendMessage(sender, { text: reply });
                }
            } catch (err) {
                console.error('[WhatsApp] Error handling message', err);
                await sock.sendMessage(sender, { text: 'Tut mir leid, da ist gerade was schiefgelaufen.' });
            }
        }
    });

    return sock;
}

module.exports = { startWhatsApp };

Das ist die Kurz-Version. In Production solltest du noch Reconnect-Backoff, Rate-Limiting und Message-Deduplication einbauen.

Pairing: Server mit deinem WhatsApp-Konto verbinden

In .env ergänzt du:

WHATSAPP_ENABLED=true
WHATSAPP_PHONE_NUMBER=4915112345678
WHATSAPP_USE_PAIRING_CODE=true
WHATSAPP_ALLOWED_JIDS=4915112345678@s.whatsapp.net,4915187654321@s.whatsapp.net

WHATSAPP_PHONE_NUMBER ist die Nummer im internationalen Format ohne + und ohne Leerzeichen. WHATSAPP_ALLOWED_JIDS ist die Liste erlaubter WhatsApp-IDs (das @s.whatsapp.net ist Pflicht).

Erster Start (manuell, damit du den Pairing-Code sehen kannst):

cd /opt/openclaw
node src/index.js

Du siehst in der Konsole: [WhatsApp] Pairing-Code: ABCD-EFGH. Auf deinem Handy gehst du in WhatsApp → Einstellungen → Verknüpfte Geräte → Gerät verknüpfen → "Stattdessen mit Telefonnummer verknüpfen". Du gibst die Nummer und den 8-stelligen Code ein.

Nach erfolgreichem Pairing:

• [WhatsApp] Connected. erscheint in der Konsole
• Im Ordner data/whatsapp-auth/ werden die Keys gespeichert
• Bei zukünftigen Starts ist kein neues Pairing nötig

Ab jetzt kannst du eine Nachricht von einer der Allowlist-Nummern an dein Bot-Konto schicken und Claude antwortet.

Allowlist und Sicherheit: Wer darf den Bot benutzen?

Eine Allowlist ist Pflicht, weil dein Konto sonst von jedem WhatsApp-Nutzer erreichbar ist, der deine Nummer hat. Drei Levels von Sicherheit:

Level 1: Eigene Nummern + Familie

Der einfachste Fall. Du listest in WHATSAPP_ALLOWED_JIDS 3-5 Nummern (deine, deine Partner:in, eventuell Eltern oder enge Freunde). Alle anderen Nachrichten werden gelogged und ignoriert.

Level 2: Dynamische Allowlist mit Admin-Befehl

Praktisch, wenn du jemandem temporär Zugriff geben willst. Erweitere den Bot um einen Admin-Befehl wie /allow +49151..., der nur von dir kommen darf. Speicher die Liste in der SQLite-DB statt in der .env.

Level 3: Gruppen-Modus

Wenn du den Bot in eine WhatsApp-Gruppe einlädst, erkennt er Gruppen-JIDs (Format: 1234567890-12345@g.us). Hier prüfst du, ob die Gruppen-ID erlaubt ist und ob der Sender zur Gruppe gehört. Vorsicht: Im Gruppen-Modus wird jede Nachricht eingelesen, was schnell teure API-Calls auslöst. Nutze hier strikt einen Trigger-Prefix wie @bot oder /claw.

DSGVO-Compliance im Detail

Damit dein Setup auch DSGVO-rechtlich sauber ist, hier die Pflicht-Punkte:

Auftragsverarbeitungsverträge (AVV)

• Anthropic: AVV ist im Console-Portal verfügbar (Settings → Privacy → Sign DPA). Kostenlos, automatisch.
• Hostinger/Hetzner: AVV mit Vertragsabschluss inkludiert oder als Download verfügbar.
• Meta/WhatsApp: Hier wirds tricky. Für privaten/familiären Gebrauch reicht die WhatsApp-AGB. Für gewerbliche Bot-Kommunikation brauchst du theoretisch die WhatsApp-Business-API mit eigenem AVV-Pfad.

Datenminimierung

OpenClaw loggt standardmäßig wenig. Stell sicher, dass du:

• Keine vollständigen Nachrichten-Bodies in Production-Logs schreibst
• Nutzer-IDs hashst, wenn du sie für Statistiken brauchst
• Memory-Daten nach 30-90 Tagen automatisch rotierst

Datenschutzerklärung für Bot-Nutzer

Wenn der Bot mit Personen kommuniziert, die nicht zu deinem direkten Umfeld gehören, brauchen sie eine Möglichkeit, deine Datenschutzerklärung einzusehen. Ein einfacher Befehl /datenschutz im Bot, der den Link auf deine DSE schickt, ist ein Minimum.

Recht auf Löschung

Der Bot sollte einen Befehl /loeschen haben, der alle gespeicherten Konversationsdaten dieses Nutzers aus der Memory-DB entfernt. Das ist ein simples SQL-Statement, das du in einem Skill abbilden kannst.

Tipp: DSGVO-konformes WhatsApp-Bot-Hosting funktioniert nur mit EU-Server. Hostinger Frankfurt liefert das ab ~5 €/Monat. Hostinger ansehen →Affiliate-Link — wir erhalten eine Provision, wenn du über diesen Link bestellst. Für dich ändert sich am Preis nichts.

Praktische Use-Cases für einen privaten WhatsApp-KI-Bot

Damit das nicht abstrakt bleibt, hier ein paar Setups, die in meinem Umfeld laufen:

"Familien-Smart-Assistant"

Bot in einer Familien-Gruppe mit @claw-Trigger. Beantwortet Fragen wie "Was kochen wir heute?", "Wo ist der nächste Spielplatz mit Café?", "Erinnere uns alle am Freitag um 17 Uhr an die Arzttermine". Mit Skills für Wetter, Maps, Einkaufsliste.

"Solo-Selbstständigen-Sekretariat"

Privat-Nummer, an die alle ankommenden Mails per Forwarding-Skill gehen. Bot fasst zusammen, schlägt Antworten vor, schickt Kalender-Events bei Terminanfragen. Spart 30-60 Minuten pro Tag.

"Studenten-Lerncoach"

Bot in einer 4er-Lerngruppe. Nimmt Fragen entgegen, fasst Lehrmaterial zusammen, generiert Karteikarten, erinnert an Klausurtermine. Nur die 4 Studis sind in der Allowlist.

"Eltern-Kind-Hilfe"

Bot, der bei Hausaufgaben hilft, ohne Lösungen zu spoilern. Mit Custom-Skill für altersgerechte Antworten und Quellen-Verlinkung. Eltern bekommen wöchentliche Übersicht.

Erweiterte Features: Was über den Basis-Bot hinausgeht

Wenn dein Basis-Bot stabil läuft, gibt es eine Reihe von Erweiterungen, die den praktischen Nutzen massiv steigern. Hier die fünf, die in meinen Setups am meisten gebracht haben.

Sprachnachrichten verstehen

WhatsApp-Sprachnachrichten kannst du mit Whisper oder Anthropics Audio-API transkribieren lassen, bevor sie an Claude gehen. Im Adapter prüfst du den Message-Type:

if (msg.message?.audioMessage) {
    const audioBuffer = await downloadMediaMessage(msg, 'buffer', {});
    const transcription = await transcribeWithWhisper(audioBuffer);
    text = `[Sprachnachricht]: ${transcription}`;
}

Das ist besonders praktisch für Familien-Bots, in denen Sprachnachrichten dominieren.

Bilder analysieren

Claude Sonnet 4.7 und Opus haben native Vision-Fähigkeiten. Bilder kannst du als Multimodal-Input mitschicken:

if (msg.message?.imageMessage) {
    const imageBuffer = await downloadMediaMessage(msg, 'buffer', {});
    const base64 = imageBuffer.toString('base64');
    // an Claude mit type:'image' im Content-Array
}

Use-Cases: "Was kostet das Produkt im Bild?", "Beschreib das Restaurant-Schild", "Erkenne die Pflanze".

Kalender-Integration

Mit Skills für Google Calendar oder CalDAV kann der Bot:

• Termine erkennen ("am Freitag um 18 Uhr Yoga") und automatisch im Kalender eintragen
• Konflikte erkennen ("an dem Tag hast du schon einen Termin um 17 Uhr")
• Erinnerungen senden ("in 30 Minuten startet dein Termin")

Web-Suche und Wikipedia

Ein simples Skill für Web-Suche (z. B. via DuckDuckGo-API oder SerpAPI) macht den Bot zu einem echten Assistenten:

User: "Wer hat gestern das EM-Spiel gewonnen?" Bot: [sucht web] "Italien hat 2:1 gegen Frankreich gewonnen…"

Achte darauf, dass die Web-Suche-Ergebnisse als untrusted Content markiert sind (siehe Prompt-Injection-Risiken).

Reminders & Cron-Tasks

Der Bot kann sich Erinnerungen merken: "Erinnere mich morgen um 14 Uhr daran, die Steuererklärung zu machen". Implementier das mit einem Skill, der einen Cron-Job in einer SQLite-DB anlegt und ein simpler Background-Worker, der die Reminders zur fälligen Zeit als WhatsApp-Nachricht sendet.

Performance und Skalierung im Praxis-Kontext

Ein Web-Protocol-Bot hat einige Performance-Charakteristika, die du kennen solltest:

Latenz

Jede WhatsApp-Nachricht durchläuft: User → WhatsApp-Server → dein VPS → Anthropic API → dein VPS → WhatsApp-Server → User. Die typische Round-Trip-Zeit liegt bei 1-3 Sekunden:

• WhatsApp-Server zu VPS: ~100-300 ms
• VPS zu Anthropic (US): ~150 ms
• Claude-Generation (kurze Antwort): 800-1500 ms
• Rückweg: ~150 ms
• Gesamt: ~1.2-2.1 Sekunden

Bei langen Antworten oder Tool-Calls kann das auf 5-15 Sekunden steigen. Das ist okay für die meisten Use-Cases, weil Messenger-Konversationen sowieso asynchron sind.

Concurrency

Baileys verarbeitet Nachrichten event-driven. Auf einem KVM 2 mit 8 GB RAM kannst du locker 50-100 parallele Konversationen halten, solange jede einzelne nicht durchgängig Anthropic-Calls macht. Wenn doch, ist Anthropics Rate-Limit der Engpass (Tier-1: 50 RPM, Tier-2: 1000 RPM).

Persistenz nach Reboot

Die WhatsApp-Auth-Keys liegen in data/whatsapp-auth/. Solange der Ordner erhalten bleibt, ist nach einem Reboot kein erneutes Pairing nötig. Achte darauf, dass dieser Ordner in deine Backup-Strategie einbezogen wird – ohne Auth-Keys musst du neu pairen, was bei vielen Geräten lästig wird.

Memory-Footprint

Ein einzelner Bot mit Baileys + Node.js + SQLite verbraucht ~150-300 MB RAM im Idle-Zustand, bei aktiver Nutzung 400-700 MB. Auf einem KVM 2 (8 GB) kannst du also problemlos 5-10 Bots parallel laufen lassen.

Wartung und typische Probleme

Der Bot wird nach Stunden/Tagen plötzlich offline

WhatsApp-Web-Sessions brauchen alle paar Stunden ein Refresh. Baileys macht das automatisch, aber es kann zu kurzen Disconnects kommen. Stelle sicher, dass dein systemd-Service Restart=always hat. In den Logs siehst du dann [WhatsApp] Connection closed - reconnecting und kurz darauf [WhatsApp] Connected.

Doppelte Antworten

Manchmal sendet WhatsApp dieselbe Nachricht mehrfach (besonders bei Netzwerk-Schwankungen). Implementier eine simple Deduplizierung über die msg.key.id:

const seen = new Set();
// in messages.upsert:
if (seen.has(msg.key.id)) continue;
seen.add(msg.key.id);
if (seen.size > 1000) seen.clear(); // simple GC

"Account aus Sicherheitsgründen abgemeldet"

Das passiert, wenn Meta deinen Account als "verdächtig" einstuft. Häufige Auslöser: zu viele Nachrichten in zu kurzer Zeit, viele neue Kontakte ansprechen, oder einfach Zufall. Prävention: Rate-Limiting (max 1 Antwort pro 2 Sekunden), keine Massensendungen, persönliche und ruhige Nutzung.

Der Bot antwortet auch in Gruppen, in denen er nicht erwünscht ist

Stelle sicher, dass du Gruppen-JIDs (...@g.us) explizit in der Allowlist hast und dass dein Bot nicht versehentlich auf jede Nachricht reagiert. Trigger-Prefix wie @bot ist Pflicht.

FAQ

Ist das wirklich legal?

Für persönlichen, familiären und engen sozialen Gebrauch: ja, deckt sich mit Metas AGB. Für gewerbliche Kunden-Kommunikation außerhalb eines verifizierten Business-Accounts: Grauzone bis Verstoß gegen TOS. Für gewerblich-relevante Use-Cases empfehle ich die offizielle WhatsApp-Business-API über einen BSP wie 360dialog oder MessageBird.

Brauche ich eine separate WhatsApp-Nummer?

Du kannst deine Privatnummer nutzen, dann teilt sich dein Bot die Konten-Session mit deiner WhatsApp-Web-Session am Laptop. Das funktioniert technisch, ist aber unsauber. Besser: zweite SIM (Prepaid für ~10 € reicht), eigene Nummer für den Bot, klare Trennung.

Was kostet der Spaß im Monat?

• VPS: 5-7 € (Hostinger KVM 2 oder Hetzner CX22)
• Anthropic-API: 5-15 € bei moderater Nutzung
• Optional: zweite SIM-Karte: 5-10 €
• Summe: 15-30 €/Monat

Verglichen mit kommerziellen Bot-Plattformen (oft 30-150 €/Monat plus Pro-Message-Kosten) ist das ein guter Deal.

Kann ich Bilder und Sprachnachrichten verarbeiten?

Ja. Baileys liefert Medien als Buffer, die du dann an Claude (mit Vision) oder Whisper (für Audio-Transkription) weitergeben kannst. Achte auf zusätzliche API-Kosten und auf längere Antwortzeiten bei Medien-Verarbeitung.

Wie skaliere ich das auf 50+ User?

Wenn du wirklich auf User-Zahlen jenseits Familie/Freundeskreis gehst, ist Web-Protocol nicht der richtige Weg. Steig auf WhatsApp-Business-API um. Die kostet zwar pro Conversation (~0,005-0,05 € je nach Land), ist aber stabil, skaliert beliebig und ist Meta-zertifiziert für gewerbliche Nutzung.

Was passiert, wenn Meta das Web-Protocol ändert?

Baileys und whatsapp-web.js werden aktiv von der Open-Source-Community gepflegt. Bei größeren Protokoll-Änderungen kommen meistens innerhalb von Tagen oder Wochen Patches. Plane trotzdem regelmäßige Updates ein und halt einen Fallback-Plan (z. B. Telegram-Adapter aktivieren) parat.

Fazit

Ein eigener WhatsApp-KI-Bot auf einem deutschen VPS ist kein Hexenwerk: 1-2 Stunden Setup, 15-30 €/Monat laufende Kosten, und du hast einen privaten Assistenten, der dir und deiner Familie Zeit spart. Architektonisch ist das Setup transparent, DSGVO-grundsätzlich sauber und du behältst die volle Kontrolle über deine Konversationen.

Die wichtigsten Hebel: knapper Einsatz (privat/Familie statt gewerblich), strikte Allowlist, Frankfurt-Hosting für DSGVO und Anthropic mit DPA als LLM-Backend. Wenn du das beachtest, hast du einen Bot, der nicht nur funktioniert, sondern auch vor jeder Daten-Audit-Frage gut dasteht.