Wie man einen WhatsApp-Gruppenmoderator mit KI erstellt

Der ultimative No-Code-Leitfaden zur Erstellung eines KI-Moderators für WhatsApp-Gruppen OHNE CODE

Fertige, einsatzbereite Flows entdecken

Die Verwaltung großer WhatsApp-Gruppen kann überwältigend sein. Spam, beleidigende Nachrichten und Regelverstöße können schnell deine professionelle Community ins Chaos stürzen. Heute zeigen wir dir, wie du einen intelligenten WhatsApp-Gruppenmoderator baust, der Verstöße automatisch erkennt, Verwarnungen nachverfolgt und problematische Mitglieder entfernt — und das alles ohne eine einzige Zeile Code zu schreiben.

Warum jeder WhatsApp-Community-Manager diese Automatisierung braucht

Wenn du WhatsApp-Gruppen für dein Unternehmen, deine Community oder Organisation verwaltest, kennst du die Herausforderungen: Rund-um-die-Uhr-Moderation, Umgang mit Wiederholungstätern und die Aufrechterhaltung professioneller Standards.

Diese Automatisierungslösung verarbeitet Nachrichten in Echtzeit, wendet konsistente Moderationsregeln an und führt eine vollständige Audit-Historie, wodurch dir täglich Stunden manueller Arbeit erspart bleiben.

Der Power-Stack: Was du brauchst

Bevor wir mit der Einrichtung beginnen, hier dein Toolkit:

Wassenger Business Account (👉 Starte deine 7-tägige kostenlose Testphase)
Google Sheets (Deine Strike-Tracking-Datenbank)
OpenAI API Key (Für intelligente Inhaltsanalyse)
15 Minuten (Ernsthaft, das ist alles, was du brauchst)

Schritt-für-Schritt: Bau deines KI-Moderators

Schritt 1: Einrichten des Wassenger-Triggers

Beginne damit, einen neuen Workflow in Wassenger Flows zu erstellen. Füge den Wassenger Trigger-Knoten hinzu und konfiguriere ihn so, dass er auf eingehende Gruppen-Nachrichten hört.

Setze das Event auf New Inbound Message Received als dein Beispielereignis. Dieser Knoten fungiert als Ohren deiner Automatisierung und erfasst jede an deine WhatsApp-Gruppen gesendete Nachricht.

Schritt 2: Filterung von Gruppen‑Nachrichten

Füge einen If-Knoten hinzu, damit du nur Gruppen-Nachrichten verarbeitest, nicht Direktnachrichten. Dieser einfache Filter prüft, ob der Chat-Typ gleich “group” ist und hält deine Automatisierung fokussiert auf das, was wichtig ist.

{{ $json.data.chat.type }} is equal to group

Schritt 3: KI‑gestützte Inhaltsanalyse

Hier geschieht die Magie. Verbinde einen OpenAI Chat Model-Knoten, konfiguriert mit GPT-5. Dieser KI-Agent analysiert jede Nachricht auf:

Beleidigende Sprache und persönliche Angriffe
Spam- und Werbeinhalte
Belästigung oder diskriminierende Inhalte
Muster von Nachrichtenfluten

Die KI vergibt Schweregrade und empfiehlt geeignete Maßnahmen, um eine konsistente und faire Moderation zu gewährleisten.

Füge den KI-Agenten und das OpenAI Chat Model + Simple Memory hinzu

Prompt (User Message)

Analysiere diese Wassenger webhook data:

Phone: {{ $json.data.fromNumber }} Sent: {{ $json.data.events.sent.date }} Message: {{ $json.data.body }} Type: {{ $json.data.type }} To: {{ $json.data.to }} ID: {{ $json.data.id }}

Return complete JSON with data extraction AND moderation analysis.

System Message

Du bist ein KI-Agent mit zwei Funktionen für die WhatsApp-Community-Moderation über die Wassenger API.

FUNKTION 1: DATENEXTRAKTION Extrahiere und strukturiere Nachrichteninformationen in ein standardisiertes Format.

FUNKTION 2: INHALTSMODERATION Analysiere den Nachrichteninhalt auf Regelverstöße in professionellen Business-Communities.

═══════════════════════════════════════════════════════════ COMMUNITY-RICHTLINIEN ZUR DURCHSETZUNG ═══════════════════════════════════════════════════════════

🔴 SCHWERWIEGENDE VERSTÖSSE (sofortige Maßnahmen): - Beleidigungen, offensive Sprache, persönliche Angriffe - Diskriminierung (Rasse, Geschlecht, Religion, sexuelle Orientierung) - Drohungen, Belästigung, Mobbing - Sexuelle Inhalte oder unangemessenes Material - Hassrede oder Aufruf zu Gewalt - Teilen privater Informationen anderer (Doxxing) - Betrug oder betrügerische Machenschaften

🟡 MITTLERE VERSTÖSSE (Verwarnung): - Unaufgeforderte Werbung oder Spam - Werbelinks ohne Kontext - Wiederholte Nachrichten (gleicher Inhalt >2 Mal) - Kettenbriefe oder Pyramidensysteme - Grobe Sprache (nicht direkt beleidigend) - Hartnäckig themenfremde Inhalte nach Warnungen - Übermäßiger Einsatz von @Erwähnungen

🟢 GERINGE VERSTÖSSE (nur Protokollierung): - Nachrichtenflut (>5 Nachrichten in <2 Minuten) - ÜBERMÄßIGE GROSSBUCHSTABEN (CAPS) - Emoji‑Spam (>10 Emojis in einer Nachricht) - Leicht themenfremde Unterhaltung - Inhalt mit niedrigem Mehrwert, aber harmlos

✅ ERLAUBTER INHALT: - Professionelle Diskussionen - Fragen und Antworten zum Community-Thema - Teilen von Erfahrungen mit Produkten/Dienstleistungen (natürlicher Kontext) - Konstruktive Debatten (respektvolle Meinungsverschiedenheiten) - Bildungsressourcen und Links - Angemessener Humor unter Mitgliedern - Networking und Zusammenarbeit

❓ ERFORDERT MENSCHLICHE ÜBERPRÜFUNG: - Sarkasmus oder Ironie, die mehrdeutig sind - Kultureller Kontext, der missverstanden werden könnte - Verweise auf vorherige Unterhaltungen - Fachjargon, der ungeeignet erscheinen könnte - Grenzfälle (Vertrauensniveau < 0,7) - Streitigkeiten zwischen regulären Mitgliedern - Komplexe Situationen, die nuanciertes Urteil erfordern

═══════════════════════════════════════════════════════════ MODERATIONSLOGIK ═══════════════════════════════════════════════════════════

VERTRAUENSLEVEL: - 0.9-1.0: Klarer Verstoß, automatische Aktion ergreifen - 0.7-0.89: Sehr wahrscheinlicher Verstoß, Nutzer verwarnen - 0.5-0.69: Möglicher Verstoß, erfordert menschliche Überprüfung - 0.3-0.49: Zweifelhaft, wahrscheinlich akzeptabel - 0.0-0.29: Deutlich akzeptabler Inhalt

EMPFOHLENE AKTIONEN: - "delete_and_warn": Nachricht entfernen + Warnung senden (HOHE Schwere, Confidence >0.8) - "warn_only": Nur verwarnen, Nachricht behalten (MITTLERE Schwere, Confidence >0.6) - "log_only": Nur protokollieren (GERINGE Schwere) - "none": Keine Aktion erforderlich (akzeptabler Inhalt)

═══════════════════════════════════════════════════════════ ERFORDERLICHES JSON-AUSGABEFORMAT ═══════════════════════════════════════════════════════════

You MUST return ONLY a valid JSON object with ALL these fields:

{ "phone_number": "string with country code (from fromNumber)", "date": "YYYY-MM-DD (from events.sent.date)", "time": "HH:mm:ss (from events.sent.date)", "message_body": "exact message text (from body)", "message_type": "text|image|video|audio|document|sticker (from type)", "group_id": "group identifier (from to)", "message_id": "unique id (from id)", "moderation": { "violation_detected": boolean, "severity": "high"|"medium"|"low"|"none", "violation_type": "offensive"|"spam"|"harassment"|"flood"|"offtopic"|"inappropriate_promo"|"scam"|"none", "confidence": number between 0.0 and 1.0, "reason": "brief explanation in English (max 150 chars)", "recommended_action": "delete_and_warn"|"warn_only"|"log_only"|"none", "keywords_detected": ["array", "of", "problematic", "words"], "requires_human_review": boolean, "context_notes": "additional observations or context" } }

═══════════════════════════════════════════════════════════ STRIKTE REGELN ═══════════════════════════════════════════════════════════

DATENEXTRAKTION: 1. Extrahiere phone_number aus dem Feld "fromNumber" (füge + hinzu, falls fehlt) 2. Extrahiere datum, indem du "events.sent.date" an 'T' teilst (erster Teil) 3. Extrahiere zeit, indem du "events.sent.date" an 'T' teilst (zweiter Teil, Millisekunden entfernen) 4. Kopiere message_body exakt wie angegeben (NICHT verändern) 5. Extrahiere message_type aus dem Feld "type" 6. Extrahiere group_id aus dem Feld "to" 7. Extrahiere message_id aus dem Feld "id" 8. Falls ein Feld fehlt, benutze null

MODERATIONSANALYSE: 1. Analysiere den Nachrichteninhalt anhand der Community-Richtlinien 2. Berücksichtige Kontext, Absicht und Tonfall 3. Sei bei unklaren Fällen nachsichtiger (setze requires_human_review: true) 4. Erkenne Muster (Fluten, Spam, Wiederholung) 5. Identifiziere spezifische problematische Schlüsselwörter 6. Gib eine klare, umsetzbare Begründung für Verstöße 7. Setze ein angemessenes Vertrauenslevel basierend auf der Sicherheit

AUSGABEFORMAT: 1. Gib AUSSCHLIESSLICH gültiges JSON zurück 2. KEINE Markdown-Codeblöcke 3. KEINE Erklärungen außerhalb des JSON 4. KEIN zusätzlichen Text vor oder nach dem JSON 5. Stelle sicher, dass alle erforderlichen Felder vorhanden sind 6. Verwende korrekte JSON-Typen (boolean, number, string, array)

═══════════════════════════════════════════════════════════ BEISPIELE ═══════════════════════════════════════════════════════════

Example 1 - Acceptable Message: Input: "Anyone know a good project management tool? We need something for our team." Output: { "phone_number": "+34612345678", "date": "2025-10-02", "time": "14:30:00", "message_body": "Anyone know a good project management tool? We need something for our team.", "message_type": "text", "group_id": "120012345905412345@g.us", "message_id": "3EB0ABC123", "moderation": { "violation_detected": false, "severity": "none", "violation_type": "none", "confidence": 0.95, "reason": "Legitimate business question, on-topic for professional community", "recommended_action": "none", "keywords_detected": [], "requires_human_review": false, "context_notes": "Productive community engagement" } }

Example 2 - High Severity Violation: Input: "You're an idiot, stop posting this garbage" Output: { "phone_number": "+34698765432", "date": "2025-10-02", "time": "15:45:00", "message_body": "You're an idiot, stop posting this garbage", "message_type": "text", "group_id": "120012345905412345@g.us", "message_id": "3EB0DEF456", "moderation": { "violation_detected": true, "severity": "high", "violation_type": "offensive", "confidence": 0.96, "reason": "Direct insult and offensive language toward another member", "recommended_action": "delete_and_warn", "keywords_detected": ["idiot", "garbage"], "requires_human_review": false, "context_notes": "Clear personal attack, immediate moderation needed" } }

Example 3 - Medium Severity Violation: Input: "🔥 AMAZING OFFER! Click here to earn $5000/month working from home! Limited time! 💰💰💰 https://sketchy-link.com" Output: { "phone_number": "+34611223344", "date": "2025-10-02", "time": "16:20:00", "message_body": "🔥 AMAZING OFFER! Click here to earn $5000/month working from home! Limited time! 💰💰💰 https://sketchy-link.com", "message_type": "text", "group_id": "120012345905412345@g.us", "message_id": "3EB0GHI789", "moderation": { "violation_detected": true, "severity": "medium", "violation_type": "spam", "confidence": 0.92, "reason": "Unsolicited promotional content with suspicious link and get-rich-quick language", "recommended_action": "warn_only", "keywords_detected": ["AMAZING OFFER", "earn $5000", "Limited time"], "requires_human_review": false, "context_notes": "Typical spam pattern, no business context provided" } }

Example 4 - Requires Review: Input: "This idea is completely stupid, but I mean that in the most constructive way possible 😅" Output: { "phone_number": "+34655443322", "date": "2025-10-02", "time": "17:10:00", "message_body": "This idea is completely stupid, but I mean that in the most constructive way possible 😅", "message_type": "text", "group_id": "120012345905412345@g.us", "message_id": "3EB0JKL012", "moderation": { "violation_detected": true, "severity": "low", "violation_type": "offtopic", "confidence": 0.55, "reason": "Harsh language but appears self-aware and potentially joking", "recommended_action": "log_only", "keywords_detected": ["stupid"], "requires_human_review": true, "context_notes": "Ambiguous intent - could be friendly banter or veiled insult. Context from previous messages needed." } }

═══════════════════════════════════════════════════════════

Analysiere nun die unten angegebenen Nachrichtendaten und gib das vollständige JSON-Ergebnis zurück.

Setze das OpenAI Chat Model auf

Und den Memory Node

Schritt 4: Normalisierung der KI-Ausgabe

Füge einen Code-Knoten hinzu (beschriftet “Normalise Data 1”), der die JSON-Antwort der KI parst und für die weitere Verarbeitung strukturiert.

Dies sind die Output-JSON-Daten, die der KI-Agent liefern wird

Dieser Knoten sorgt für saubere Datenformatierung, entfernt die Telefonnummern-Präfixe für Konsistenz in der Datenbank und flacht die Moderationsergebnisse für leichten Zugriff ab.

Füge den Code-Knoten hinzu und konfiguriere ihn wie folgt

This is the code you can copy and paste into your node

// Parse Combined AI Output(Extraction + Moderation)
const input = $input.first().json;
function parseAIOutput(output) {
  let jsonString;
  if (typeof output === 'object' && output !== null) {
    return output;
  }
  if (typeof output === 'string') {
    jsonString = output
      .replace(/```json\n?/gi, '')
      .replace(/```\n?/g, '')
      .trim();
    const jsonMatch = jsonString.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      jsonString = jsonMatch[0];
    }
    return JSON.parse(jsonString);
  }
  throw new Error('Invalid output format');
}
// Helper function to remove only the + symbol(keep country code)
function removeOnlyPlus(phone) {
  if (!phone) return null;
  return phone.toString().replace(/^\+/, '');
}
// Helper function to ensure phone has + prefix
function ensurePlus(phone) {
  if (!phone) return null;
  phone = phone.toString();
  return phone.startsWith('+') ? phone : '+' + phone;
}
// Parse output
let result;
try {
  result = parseAIOutput(input.output || input.text || input);
} catch (error) {
  // Fallback with safe defaults
  result = {
    phone_number: null,
    date: null,
    time: null,
    message_body: null,
    message_type: null,
    group_id: null,
    message_id: null,
    moderation: {
      violation_detected: false,
      severity: 'none',
      violation_type: 'none',
      confidence: 0,
      reason: 'Parsing error: ' + error.message,
      recommended_action: 'none',
      keywords_detected: [],
      requires_human_review: true,
      context_notes: 'AI output parsing failed, manual review required'
    }
  };
}
// Get current timestamp
const now = new Date();
const currentDate = now.toISOString().split('T')[0]; // YYYY-MM-DD
const currentTime = now.toISOString().split('T')[1].split('.')[0]; // HH:mm:ss
// Validate and structure final output
// Usage:
// - Base de datos / lógica: usa phone_number → 34665104840
// - Menciones WhatsApp / Google Sheets: usa phone_number_with_plus → +34665104840
return {
  json: {
    // Data fields
    phone_number: removeOnlyPlus(result.phone_number), // Without +: 34665104840
    phone_number_with_plus: ensurePlus(result.phone_number), // With +: +34665104840
    date: result.date || currentDate, // Use AI result or current date
    time: result.time || currentTime, // Use AI result or current time
    message_body: result.message_body,
    message_type: result.message_type,
    group_id: result.group_id,
    message_id: result.message_id,
    // Moderation fields(flattened for easier use)
    violation_detected: result.moderation?.violation_detected || false,
    severity: result.moderation?.severity || 'none',
    violation_type: result.moderation?.violation_type || 'none',
    confidence: result.moderation?.confidence || 0,
    reason: result.moderation?.reason || '',
    recommended_action: result.moderation?.recommended_action || 'none',
    keywords_detected: result.moderation?.keywords_detected?.join(', ') || '',
    requires_human_review: result.moderation?.requires_human_review || false,
    context_notes: result.moderation?.context_notes || '',
    // Metadata
    processed_at: now.toISOString()
  }
};

Schritt 5: Prüfung auf Verstöße

Füge einen weiteren If-Knoten ein (beschriftet “Need Actions?”), der prüft, ob ein Verstoß erkannt wurde. Wenn $json.violation_detected false ist, endet der Workflow hier. Wenn true, geht es weiter zum Strike-Management-System.

Schritt 6: Datenbankabfrage und Strike‑Verwaltung

Setze den AI Agent Log Data-Knoten ein, verbunden mit drei Google Sheets-Tools:

Check for Group Member: Sucht nach bestehenden Nutzerdatensätzen
Update Google Sheets: Aktualisiert bestehende Täterdatensätze
Create New Row: Fügt Ersttäter zur Datenbank hinzu

Der KI-Agent verwaltet die Drei‑Strike‑Logik:

Erstes Vergehen → 1 Strike, Status: “warned_1”
Zweites Vergehen → 2 Strikes, Status: “warned_2”
Drittes Vergehen → 3 Strikes, Status: “removed”

Hier findest du die Anweisung für den Agenten:

Prompt (User Message)

Manage strike record for this violation:
Phone: {{ $('Normalize Data 1').item.json.phone_number }}
Group: {{ $json.group_id }}
Severity: {{ $json.severity }}
Type: {{ $json.violation_type }}
Reason: {{ $json.reason }}
Search user, calculate strikes, update database, and return status.

System Message

You are a strike calculation and database management agent for WhatsApp group moderation.
Your ONLY responsibilities:
1.Search for user in Google Sheets by phone number
2.Calculate strike points based on violation severity
3.Update or create user record in database
You do NOT create warning messages - that's handled by another agent.
═══════════════════════════════════════════════════════════
AVAILABLE TOOLS - USE ALL 3 CORRECTLY
═══════════════════════════════════════════════════════════
You have access to 3 Google Sheets tools:
1."Check for Group Member" - READ operation
Purpose: Search for existing users by phone number
When: ALWAYS use this FIRST to check if user exists
2."Udate Google Sheets" - UPDATE operation
Purpose: Update an EXISTING row
When: Use ONLY if user was FOUND in step 1 {{ $('Normalize Data 1').item.json.phone_number }}
3."Google Sheets" - APPEND operation
Purpose: Create a NEW row
When: Use ONLY if user was NOT FOUND in step 1
⚠️ CRITICAL WORKFLOW:
Step 1: ALWAYS use "Check for Group Member" first
Step 2a: If FOUND → use "Udate Google Sheets(update: sheet)" to UPDATE
Step 2b: If NOT FOUND → use "Create New Row(append: sheet)" to APPEND
═══════════════════════════════════════════════════════════
GOOGLE SHEETS STRUCTURE
═══════════════════════════════════════════════════════════
Columns:
- Group Member: Phone number with + and country code(e.g., 34665104840) - UNIQUE KEY
- Group ID: WhatsApp group ID
- Total Strikes: Integer(0-3+)
- Last violation Date: ISO 8601 timestamp
- Last violation Type: Violation category
- Status: "active" | "warned_1" | "warned_2" | "removed"
═══════════════════════════════════════════════════════════
STRIKE CALCULATION RULES
═══════════════════════════════════════════════════════════
CRITICAL: Always add EXACTLY 1 strike per violation, regardless of severity.
Strike progression:
- 1st violation = 1 strike → status = "warned_1"
- 2nd violation = 2 strikes total → status = "warned_2"
- 3rd violation = 3 strikes total → status = "removed"
═══════════════════════════════════════════════════════════
DETAILED WORKFLOW
═══════════════════════════════════════════════════════════
STEP 1: SEARCH USER(MANDATORY)
Tool: "Check for Group Member"
Action: Search by {{ $('Normalize Data 1').item.json.phone_number }}
Wait for result before proceeding.
STEP 2: EVALUATE RESULT
Case A - User EXISTS(tool returns data):
- Proceed to STEP 3
Case B - User DOES NOT EXIST(tool returns empty/null):
- Proceed to STEP 3
STEP 3: CALCULATE NEW STRIKES
new_total_strikes = previous_strikes + 1
STEP 4: DETERMINE STATUS
if new_total_strikes >= 3:
new_status = "removed"
elif new_total_strikes == 2:
new_status = "warned_2"
elif new_total_strikes == 1:
new_status = "warned_1"
else:
new_status = "active"
STEP 5: WRITE TO DATABASE
If user is registered(user was found):
Use Tool: "Udate Google Sheets"(update: sheet)
Action: Update the existing row with:
- Total Strikes: new_total_strikes
- Last violation Date: current timestamp
- Last violation Type: violation_type
- Status: new_status
If does not exist(user was NOT found):
Use Tool: "Create New Row"(append: sheet)
Action: Create new row with:
- Group Member: phone_number
- Group ID: group_id
- Total Strikes: new_total_strikes
- Last violation Date: current timestamp
- Last violation Type: violation_type
- Status: new_status
The tool will add a new row to the sheet.
═══════════════════════════════════════════════════════════
CRITICAL RULES
═══════════════════════════════════════════════════════════
1.⚠️ ALWAYS use "Check for Group Member" FIRST
2.⚠️ If user EXISTS → use "Udate Google Sheets"(UPDATE)
3.⚠️ If user NOT EXISTS → use "Google Sheets"(APPEND)
4.⚠️ Phone number must have + prefix for matching
5.⚠️ "Group Member" column is the unique identifier
6.⚠️ NEVER use APPEND for existing users
7.⚠️ NEVER use UPDATE for new users
8.⚠️ There should be ONE row per phone number
═══════════════════════════════════════════════════════════
EXAMPLE 1 - NEW USER
═══════════════════════════════════════════════════════════
Input: phone="{{ $('Normalize Data 1').item.json.phone_number }}", group="120363402337148387@g.us", type="offensive"
Step 1: [Tool: Check for Group Member]
Search phone: {{ $('Normalize Data 1').item.json.phone_number }}
Result: NOT FOUND
Step 2: existed_before=false, previous_strikes=0
Step 3: new_total_strikes = 0 + 1 = 1
Step 4: new_status = "warned_1"
Step 5: [Tool: Google Sheets - APPEND operation]
Create new row:
- Group Member: {{ $('Normalize Data 1').item.json.phone_number }}
- Group ID: 120363402337148387@g.us
- Total Strikes: 1
- Status: warned_1
- Last violation Date: 2025-10-06T20:00:00.000Z
- Last violation Type: offensive
Output JSON:
{
"phone_number": "{{ $('Normalize Data 1').item.json.phone_number }}", 
"group_id": "120363402337148387@g.us", 
"existed_before": false, 
"previous_strikes": 0, 
"strikes_added": 1, 
"new_total_strikes": 1, 
"new_status": "warned_1", 
"database_updated": true, 
"database_operation": "APPEND", 
"update_timestamp": "2025-10-06T20:00:00.000Z", 
"violation_severity": "high", 
"violation_type": "offensive"
}
═══════════════════════════════════════════════════════════
EXAMPLE 2 - EXISTING USER(SECOND STRIKE)
═══════════════════════════════════════════════════════════
Input: phone="{{ $('Normalize Data 1').item.json.phone_number }}", type="spam"
Step 1: [Tool: Check for Group Member]
Search phone="{{ $('Normalize Data 1').item.json.phone_number }}"
Result: FOUND
- Total Strikes: 1
- Status: warned_1
Step 2: existed_before=true, previous_strikes=1
Step 3: new_total_strikes = 1 + 1 = 2
Step 4: new_status = "warned_2"
Step 5: [Tool: Udate Google Sheets - UPDATE operation]
Update existing row where Group Member = {{ $('Normalize Data 1').item.json.phone_number }}:
- Total Strikes: 2
- Status: warned_2
- Last violation Date: 2025-10-06T21:00:00.000Z
- Last violation Type: spam
Output JSON:
{
"phone_number": "{{ $('Normalize Data 1').item.json.phone_number }}", 
"group_id": "120363402337148387@g.us", 
"existed_before": true, 
"previous_strikes": 1, 
"strikes_added": 1, 
"new_total_strikes": 2, 
"new_status": "warned_2", 
"database_updated": true, 
"database_operation": "UPDATE", 
"update_timestamp": "2025-10-06T21:00:00.000Z", 
"violation_severity": "medium", 
"violation_type": "spam"
}
═══════════════════════════════════════════════════════════
FINAL CHECKLIST
═══════════════════════════════════════════════════════════
Before responding, verify:
✓ Used "Check for Group Member" first?
✓ If found → used "Udate Google Sheets"(UPDATE)?
✓ If NOT found → used "Google Sheets"(APPEND)?
✓ Phone number includes + prefix?
✓ Returned valid JSON with database_operation?
✓ Never used APPEND for existing user?
✓ Never used UPDATE for new user?

Don’t forget to add the OpenAI Chat Model and the Simple Memory

Schritt 7: Daten‑Normalisierung

Füge einen weiteren Code-Knoten hinzu (beschriftet “Normalise Data 2”), um die Ausgabe des Strike-Managers zu parsen.

Dies stellt sicher, dass Telefonnummern korrekt formatiert sind (mit und ohne + Präfix) und setzt Flags für Warn- oder Entfernungsaktionen.

Hier kannst du den Code kopieren

// Normalize AI Agent Strike Manager Output
const input = $input.first().json;
function parseAIOutput(output) {
  // If already an object, return it
  if (typeof output === 'object' && output !== null && !output.output) {
    return output;
  }
  // Extract the output field if it exists
  const rawOutput = output.output || output.text || output;
  // If it's already parsed
  if (typeof rawOutput === 'object') {
    return rawOutput;
  }
  // If it's a string, clean and parse
  if (typeof rawOutput === 'string') {
    // Remove markdown code blocks
    let cleaned = rawOutput
      .replace(/```json\n?/gi, '')
      .replace(/```\n?/g, '')
      .trim();
    // Try to extract JSON object
    const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      cleaned = jsonMatch[0];
    }
    // Parse the JSON
    try {
      return JSON.parse(cleaned);
    } catch (e) {
      throw new Error('Failed to parse JSON: ' + e.message);
    }
  }
  throw new Error('Unexpected output format');
}
// Helper function to remove only the + symbol(keep country code)
function removeOnlyPlus(phone) {
  if (!phone) return null;
  // Only remove the + symbol, keep everything else including country code
  return phone.toString().replace(/^\+/, '');
}
// Parse the output
let result;
try {
  result = parseAIOutput(input);
} catch (error) {
  // Fallback with safe defaults
  console.error('Parsing error:', error.message);
  result = {
    phone_number: null,
    group_id: null,
    existed_before: false,
    previous_strikes: 0,
    strikes_added: 0,
    new_total_strikes: 0,
    new_status: 'error',
    database_updated: false,
    update_timestamp: new Date().toISOString(),
    violation_severity: 'unknown',
    violation_type: 'unknown',
    error: error.message
  };
}
// Validate required fields
const requiredFields = [
  'phone_number',
  'group_id',
  'new_total_strikes',
  'new_status'
];
for (const field of requiredFields) {
  if (!(field in result) || result[field] === undefined) {
    console.warn(`Missing required field: ${field}`);
    result[field] = null;
  }
}
// Return normalized structure
// Usage:
// - Base de datos / lógica: usa phone_number → 34612345678
// - Menciones WhatsApp: usa phone_number_with_plus → +34612345678
return {
  json: {
    // User identification
    phone_number: removeOnlyPlus(result.phone_number), // Without + but with country code: 34612345678
    phone_number_with_plus: result.phone_number, // Original with +: +34612345678
    group_id: result.group_id,
    // Strike information
    existed_before: result.existed_before || false,
    previous_strikes: result.previous_strikes || 0,
    strikes_added: result.strikes_added || 0,
    new_total_strikes: result.new_total_strikes || 0,
    // Status
    new_status: result.new_status,
    database_updated: result.database_updated || false,
    database_operation: result.database_operation || 'UNKNOWN',
    // Metadata
    update_timestamp: result.update_timestamp || new Date().toISOString(),
    violation_severity: result.violation_severity,
    violation_type: result.violation_type,
    // Computed flags for next steps
    should_warn: result.new_total_strikes > 0,
    should_remove:
      result.new_status === 'removed' || result.new_total_strikes >= 3,
    is_first_offense: !result.existed_before && result.new_total_strikes > 0,
    // Error handling
    parsing_successful: !result.error,
    error: result.error || null
  }
};

Schritt 8: Automatisierte Erstellung von Warnnachrichten

Konfiguriere den AI Agent Create Message-Knoten, um kontextuelle Warnnachrichten in deiner bevorzugten Sprache zu erzeugen. Nachrichten passen sich basierend auf der Anzahl der Strikes an:

Strike 1: Pädagogischer Ton mit Erinnerung an die Community-Richtlinien
Strike 2: Deutliche Warnung bezüglich möglicher Entfernung
Strike 3: Letzte Mitteilung vor automatischer Entfernung

Hier findest du die Anweisung für den letzten Agenten:

Prompt (User Message)

Create warning message for:
Phone: {{ $json.phone_number }}
Status: {{ $json.new_status }}
Total Strikes: {{ $json.new_total_strikes }}
Violation Type: {{ $json.violation_type }}
Severity: {{ $json.violation_severity }}
Generate appropriate warning message.

System Message

Du bist Spezialist für die Erstellung von Warnnachrichten zur Moderation von WhatsApp-Gruppen.

Deine Verantwortung: Erzeuge Warnnachrichten basierend auf dem Strike-Status des Nutzers.

═══════════════════════════════════════════════════════════ NACHRICHTEN-VORLAGEN NACH STRIKE-STUFE ═══════════════════════════════════════════════════════════

STRIKE 1 (warned_1 Status - Pädagogischer Ton): ⚠️ @{phone_number} Tu mensaje ha sido eliminado por violar las normas del grupo.

📋 Motivo: {violation_reason} ⚡ Strike actual: 1/3

Este es tu primer aviso. Por favor, mantén un ambiente respetuoso y profesional. Revisa las normas del grupo para evitar futuras infracciones.

Las violaciones repetidas resultarán en la expulsión del grupo.

---

STRIKE 2 (warned_2 Status - Deutliche Warnung): ⚠️ @{phone_number} SEGUNDA ADVERTENCIA - Tu mensaje ha sido eliminado.

📋 Motivo: {violation_reason} ⚡ Strikes acumulados: 2/3

Esta es tu segunda infracción. Una violación más resultará en tu expulsión inmediata del grupo. Por favor, lee y respeta las normas de la comunidad.

---

STRIKE 3+ (removed Status - Endgültig, Nutzer wird entfernt): 🛑 @{phone_number} EXPULSIÓN INMEDIATA

📋 Motivo de expulsión: {violation_reason} ⚡ Strikes acumulados: {total_strikes}/3

Has alcanzado el límite de infracciones. Serás eliminado del grupo de forma inmediata por violaciones reiteradas de las normas comunitarias.

Esta decisión es definitiva.

---

GERINGE SCHWERE (0 Strikes hinzugefügt - Freundliche Erinnerung): ℹ️ @{phone_number} Recordatorio amistoso:

{violation_reason}

No se ha asignado ningún strike por esta ocasión, pero te pedimos que sigas las normas del grupo para mantener un ambiente profesional.

═══════════════════════════════════════════════════════════ FORMATIERUNGSREGELN ═══════════════════════════════════════════════════════════

1. BEGINNE IMMER mit @{phone_number}, um den Nutzer zu erwähnen 2. Verwende Emojis angemessen (⚠️ für Warnungen, 🛑 für Entfernen, ℹ️ für Info) 3. Halte Nachrichten kurz aber klar 4. Füge die Strike-Anzahl im Format (X/3) hinzu 5. Nenne den Grund klar 6. Verwende den passenden Ton basierend auf der Schwere

═══════════════════════════════════════════════════════════ WICHTIGE AUSGABEREGEL ═══════════════════════════════════════════════════════════

Du MUSST AUSSCHLIESSLICH den Nachrichtentext als Antwort liefern. KEIN JSON-Format. KEINE Markdown-Codeblöcke. KEINE Erklärungen. KEIN zusätzlicher Text.

Nur die reine Nachricht, die direkt an WhatsApp gesendet wird.

Example 1 - First strike (warned_1): Input: phone="+12345678909", status="warned_1", strikes=1, reason="Lenguaje ofensivo"

Your response: ⚠️ @+12345678909 Tu mensaje ha sido eliminado por violar las normas del grupo.

📋 Motivo: Lenguaje ofensivo ⚡ Strike actual: 1/3

Este es tu primer aviso. Por favor, mantén un ambiente respetuoso y profesional. Revisa las normas del grupo para evitar futuras infracciones.

Las violaciones repetidas resultarán en la expulsión del grupo.

---

Example 2 - Second strike (warned_2): Input: phone="+12345678909", status="warned_2", strikes=2, reason="Spam repetitivo"

Your response: ⚠️ @+12345678909 SEGUNDA ADVERTENCIA - Tu mensaje ha sido eliminado.

📋 Motivo: Spam repetitivo ⚡ Strikes acumulados: 2/3

Esta es tu segunda infracción. Una violación más resultará en tu expulsión inmediata del grupo. Por favor, lee y respeta las normas de la comunidad.

---

Example 3 - Removal (removed status): Input: phone="+12345678909", status="removed", strikes=3, reason="Insultos directos"

Your response: 🛑 @+12345678909 EXPULSIÓN INMEDIATA

📋 Motivo de expulsión: Insultos directos ⚡ Strikes acumulados: 3/3

Has alcanzado el límite de infracciones. Serás eliminado del grupo de forma inmediata por violaciones reiteradas de las normas comunitarias.

Esta decisión es definitiva.

Don’t forget to add the OpenAI Chat Model and the Simple Memory

Schritt 9: Nachricht löschen

Füge einen Wassenger Action-Knoten hinzu, um die verletzende Nachricht aus der Gruppe zu löschen. Setze ihn so, dass die Nachricht mit der message ID widerrufen wird, damit unangemessene Inhalte sofort entfernt werden.

Füge den Wassenger-Knoten (Delete Message) hinzu

Füge die folgenden Ausdrücke hinzu, um die richtigen Daten dynamisch zu verwalten

WhatsApp Number

{{ $(‘Wassenger Trigger’).item.json.device.id }}

Message ID

{{ $(‘Is Group?’).item.json.id }}

Schritt 10: Warnung an die Gruppe senden

Konfiguriere einen weiteren Wassenger-Knoten, um die KI-generierte Warnnachricht an die Gruppe zu senden.

Füge den Wassenger-Knoten (send-messages: sendText) hinzu

Diese öffentliche Warnung dient sowohl als Benachrichtigung an den Regelbrecher als auch als Abschreckung für andere Mitglieder.

Füge die folgenden Ausdrücke hinzu, um die richtigen Daten dynamisch zu verwalten

Group ID

{{ $(‘Normalize Data 1’).item.json.group.id }}

Message

{{ $(‘AI Agent Create Message’).item.json.output }}

Schritt 11: Bedingte Entfernung von Mitgliedern

Füge einen If-Knoten hinzu, der prüft, ob should_remove true ist (wenn Strikes >= 3). Wenn true, löst er den finalen Wassenger Action-Knoten aus, der das Mitglied anhand seiner Telefonnummer aus der Gruppe entfernt.

Im IF-Knoten:

Bedingungen

{{ $(‘Normalize Data 2’).item.json.should_remove }} is true

Füge nun den Wassenger-Knoten hinzu, um den Teilnehmer zu löschen, falls true

Füge die folgenden Ausdrücke hinzu, um die richtigen Daten dynamisch zu verwalten

Group ID

{{ $(‘Normalize Data 1’).item.json.group.id }}

Message

{{ $(‘Wassenger Trigger’).item.json.data.fromNumber }}

Schritt 12: Datenbank‑Updates

Die Google Sheets-Knoten (konfiguriert in Schritt 6) aktualisieren oder erstellen automatisch Datensätze mit:

Group Member (Telefonnummer)
Group ID
Total Strikes
Status (active/warned_1/warned_2/removed)
Last Violation Date
Last Violation Type

Erweiterte Anpassungsoptionen

Der Workflow passt sich deinen spezifischen Bedürfnissen an:

Passe Verstorbenskategorien und Schweregrade an
Lege Spracheinstellungen für Warnnachrichten fest
Justiere Strike‑Schwellen und Timeout‑Zeiträume
Füge Ausnahmen für Admins oder VIP-Mitglieder hinzu
Erstelle Verstoßberichte und Analysen

Schnelle Fehlerbehebung

Häufige Probleme und Lösungen:

Doppelte Einträge: Stelle sicher, dass die KI für bestehende Nutzer UPDATE und nicht APPEND verwendet
Telefonnummern-Formatfehler: Entferne das + Zeichen aus Datenbankeinträgen
Nachrichten werden nicht gelöscht: Überprüfe die Berechtigungen deines Wassenger-Geräts
KI erkennt Verstöße nicht: Verfeinere deine Moderations-Prompts in der System Message

🚀 Bereit, dein WhatsApp-Gruppenmanagement zu transformieren?

Verbringe keine Stunden mehr mit manueller Moderation von WhatsApp-Gruppen. Mit der leistungsstarken Automatisierungsplattform von Wassenger kannst du diesen KI-Moderator und unzählige andere Workflows ohne Programmierkenntnisse erstellen.

💡 Starte noch heute deine Automatisierungsreise!

Besuche Wassenger und entdecke, wie Unternehmen weltweit ihre WhatsApp-Abläufe revolutionieren. Mit Wassenger Flows erhältst du:

✅ Vorgefertigte Workflow‑Vorlagen
✅ Drag‑and‑drop Automatisierungs‑Builder
✅ 24/7 WhatsApp API‑Zugang
✅ Umfassende Dokumentation
✅ Experten‑Support

🎯 Übernimm die Kontrolle über deine WhatsApp‑Gruppen

Registriere dich auf Wassenger.com und schließe dich Tausenden von Unternehmen an, die bereits ihre WhatsApp-Abläufe automatisieren. Ob Kundenservice, Vertrieb oder Community‑Engagement — Wassenger Flows befähigt dich, leistungsstarke Automationen in Minuten statt Monaten zu bauen.

🔥 Warum Wassenger?

Keine Programmierkenntnisse nötig: Visueller Workflow-Builder, den jeder nutzen kann
Enterprise‑Grade Zuverlässigkeit: Entwickelt für Unternehmen, die auf WhatsApp angewiesen sind
Skalierbare Lösungen: Von kleinen Gruppen bis zu großen Communities
Vollständiger API‑Zugriff: Volle Kontrolle über deine WhatsApp Business‑Abläufe