WhatsApp GPT 4o AI-Chatbot in C Vollständiges Tutorial

2. Juli 2025

Back to Blog

Ein vielseitiger, anpassbarer WhatsApp AI-Chatbot in C# 🔷, der Text 📝, Audio 🎵 und Bilder 🖼️ verstehen kann und deinen Kund:innen 💬 direkt auf WhatsApp ✅ alles rund um dein Geschäft 🏢 beantworten kann. Angetrieben von OpenAI GPT4o 🚀 (andere Modelle sind ebenfalls nutzbar) und der Wassenger WhatsApp API 🔗.

Unterstützt jetzt GPT-4o mit Text‑ + Audio‑ + Bildeingabe 📝🎵🖼️, Audio‑Antworten 🔊 sowie verbessertes RAG + MCP mit Function Calling 🛠️ und Unterstützung für externe API‑Aufrufe 🌐

Finde weitere AI‑Chatbot‑Implementierungen in Python, Node.js und PHP

🚀 Starte kostenlos mit der Wassenger WhatsApp API in wenigen Minuten, indem du deine bestehende WhatsApp‑Nummer verbindest und deinen API‑Schlüssel erhältst ✨

Funktionen

  • 🤖 Voll ausgestatteter Chatbot für deine mit Wassenger verbundene WhatsApp‑Nummer
  • 💬 Automatische Antworten auf eingehende Nachrichten von Nutzer:innen
  • 🌍 Mehrsprachige Unterstützung — versteht und antwortet in 90+ Sprachen
  • 🎤 Audioein-/-ausgabe — Transkription und Text‑zu‑Sprache‑Funktionen
  • 🖼️ Bildverarbeitung — kann Bilder analysieren und interpretieren
  • 👥 Übergabe an Menschen — ermöglicht Nutzer:innen, menschliche Hilfe anzufordern
  • ⚙️ Anpassbares AI‑Verhalten und Anweisungen
  • 🔧 Function Calling zur Integration externer Daten
  • 📊 Speicherverwaltung mit Gesprächsverlauf und Rate‑Limiting
  • 🚦 Intelligentes Routing mit Webhook‑Verarbeitung und Fehlerbehandlung
  • 🔒 Sicher mit ordentlicher Fehlerbehandlung und Protokollierung
  • 🔄 Modernes C# mit .NET 9, Dependency Injection und async/await‑Mustern

Inhalt

Schnellstart

  • Repository klonen:
git clone https://github.com/wassengerhq/whatsapp-chatgpt-bot-csharp.git cd whatsapp-chatgpt-bot-csharp

cp.env.example.env # Edit.env file with your API keys(see Configuration section)
  • Bot starten (lokaler Entwicklungsmodus):
cd src/WhatsAppChatBot dotnet run

Voraussetzungen

Konfiguration

Bearbeite die .env‑Datei mit deinen API‑Zugangsdaten:

# Required: Wassenger API key
API_KEY=your_wassenger_api_key_here
# Required: OpenAI API key
OPENAI_API_KEY=your_openai_api_key_here
# OpenAI model to use(gpt-4o, gpt-4, gpt-3.5-turbo)
OPENAI_MODEL=gpt-4o
# Required for local development: Ngrok auth token
NGROK_TOKEN=your_ngrok_token_here
# Optional: Specific WhatsApp device ID
DEVICE=
# Optional: Webhook URL for production deployment
WEBHOOK_URL=https://yourdomain.com/webhook
# Server configuration
PORT=8080
LOG_LEVEL=Information
# Development mode(auto-initializes services)
DEV=true

API‑Schlüssel einrichten

Wassenger API‑Schlüssel:

  • Registriere dich bei Wassenger (kostenlose Testphase verfügbar)
  • Gehe zu API Keys
  • Erstelle einen neuen API‑Schlüssel und kopiere ihn in API_KEY in der .env

OpenAI API‑Schlüssel:

  • Registriere dich bei OpenAI (kostenlose Guthaben verfügbar)
  • Gehe zu API Keys
  • Erstelle einen neuen API‑Schlüssel und kopiere ihn in OPENAI_API_KEY in der .env

Ngrok Token (für lokale Entwicklung):

Bot‑Anpassung

Bearbeite src/WhatsAppChatBot/Config/BotConfig.cs, um Folgendes anzupassen:

  • Bot‑Anweisungen und Persönlichkeit
  • Begrüßungs‑ und Hilfenachrichten
  • Unterstützte Funktionen (Audio, Bilder usw.)
  • Ratenlimits und Kontingente
  • Whitelist-/Blacklist‑Nummern
  • Labels und Metadaten‑Einstellungen

Verwendung

Lokale Entwicklung

Starte den Entwicklungsserver:

cd src/WhatsAppChatBot dotnet run

Der Bot wird:

  • Einen lokalen HTTP‑Server auf Port 8080 starten
  • Optional automatisch einen Ngrok‑Tunnel erstellen
  • Den Webhook bei Wassenger registrieren
  • Mit der Verarbeitung von WhatsApp‑Nachrichten beginnen

Sende eine Nachricht an deine mit Wassenger verbundene WhatsApp‑Nummer, um den Bot zu testen.

Produktiv‑Bereitstellung

Setze die Umgebungsvariablen auf deinem Server:

export WEBHOOK_URL=https://yourdomain.com/webhook
export API_KEY=your_wassenger_api_key
export OPENAI_API_KEY=your_openai_api_key
export PRODUCTION=true

Builden und ausführen:

dotnet build -c Release dotnet run - configuration Release

Stelle sicher, dass dein Server POST‑Anfragen an /webhook empfangen kann

Bereitstellung

Du kannst diesen Bot auf jeder Cloud‑Plattform bereitstellen, die .NET 8 unterstützt.

Docker‑Bereitstellung

# Build the Docker image
docker build -t whatsapp-chatbot.
# Run the container
docker run -d \
--name whatsapp-chatbot \
-p 8080:8080 \
-e API_KEY=your_wassenger_api_key \
-e OPENAI_API_KEY=your_openai_api_key \
-e WEBHOOK_URL=https://yourdomain.com/webhook \
-e PRODUCTION=true \
whatsapp-chatbot

Render

# Create render.yaml for automated deployment
cat > render.yaml << EOF
services:
- type: web
name: whatsapp-chatbot
env: docker
dockerfilePath:./Dockerfile
envVars:
- key: API_KEY
value: your_wassenger_api_key
- key: OPENAI_API_KEY
value: your_openai_api_key
- key: PRODUCTION
value: true
- key: PORT
value: 8080
EOF
# Connect your GitHub repo to Render and deploy automatically
# Or deploy manually:
# 1.Push to GitHub
# 2.Connect repo in Render dashboard
# 3.Set environment variables in Render UI

Heroku

# Login and create app
heroku login
heroku create your-whatsapp-bot
# Set environment variables
heroku config:set API_KEY=your_wassenger_api_key
heroku config:set OPENAI_API_KEY=your_openai_api_key
heroku config:set PRODUCTION=true
# Create heroku.yml for container deployment
cat > heroku.yml << EOF
build:
docker:
web: Dockerfile
run:
web: dotnet run --configuration Release
EOF
# Set stack to container
heroku stack:set container
# Deploy
git add.
git commit -m "Deploy to Heroku"
git push heroku main

Railway

# Install Railway CLI
npm install -g @railway/cli
# Login and deploy
railway login
railway new
# Deploy with environment variables
railway add --name API_KEY --value your_wassenger_api_key
railway add --name OPENAI_API_KEY --value your_openai_api_key
railway add --name PRODUCTION --value true
# Deploy from current directory
railway up

Fly.io

# Install flyctl
curl -L https://fly.io/install.sh | sh
# Initialize and configure
flyctl auth login
flyctl launch --name whatsapp-chatbot
# Create fly.toml configuration
cat > fly.toml << EOF
app = "whatsapp-chatbot"
primary_region = "iad"
[build]
dockerfile = "Dockerfile"
[env]
PRODUCTION = "true"
PORT = "8080"
[[services]]
http_checks = []
internal_port = 8080
processes = ["app"]
protocol = "tcp"
script_checks = []
[[services.ports]]
force_https = true
handlers = ["http"]
port = 80
[[services.ports]]
handlers = ["tls", "http"]
port = 443
EOF
# Set secrets
flyctl secrets set API_KEY=your_wassenger_api_key
flyctl secrets set OPENAI_API_KEY=your_openai_api_key
# Deploy
flyctl deploy

Azure App Service

# Create resource group
az group create --name rg-whatsapp-bot --location "East US"
# Create App Service plan
az appservice plan create --name asp-whatsapp-bot --resource-group rg-whatsapp-bot --sku B1 --is-linux
# Create web app
az webapp create --resource-group rg-whatsapp-bot --plan asp-whatsapp-bot --name your-app-name --runtime "DOTNETCORE:8.0"
# Configure app settings
az webapp config appsettings set --resource-group rg-whatsapp-bot --name your-app-name --settings \
API_KEY=your_wassenger_api_key \
OPENAI_API_KEY=your_openai_api_key \
PRODUCTION=true
# Deploy
dotnet publish -c Release
cd src/WhatsAppChatBot/bin/Release/net9.0/publish
zip -r../../../../../deploy.zip.
az webapp deployment source config-zip --resource-group rg-whatsapp-bot --name your-app-name --src deploy.zip

Architektur

Die C#‑Implementierung folgt modernen .NET‑Mustern und Clean Architecture:

src/
├── WhatsAppChatBot/
│ ├── Api/ # API clients
│ │ ├── OpenAIClient.cs # OpenAI API integration
│ │ └── WassengerClient.cs # Wassenger API integration
│ ├── Bot/ # Core bot logic
│ │ ├── ChatBot.cs # Main bot processing
│ │ └── FunctionHandler.cs # Function calling system
│ ├── Config/ # Configuration management
│ │ └── BotConfig.cs # Centralized configuration
│ ├── Controllers/ # HTTP layer
│ │ └── WebhookController.cs # API endpoints and webhook handling
│ ├── Models/ # Data models
│ │ ├── OpenAIModels.cs # OpenAI API models
│ │ ├── WassengerModels.cs # Wassenger API models
│ │ └── WebhookModels.cs # Webhook and general models
│ ├── Services/ # Business services
│ │ ├── MemoryStore.cs # In-memory caching and state
│ │ └── NgrokTunnel.cs # Development tunnel management
│ ├── Program.cs # Application entry point
│ ├── appsettings.json # Application configuration
│ └── WhatsAppChatBot.csproj # Project file
├──.env.example # Environment template
├── Dockerfile # Docker configuration
└── README.md

Tests

Das Projekt enthält eingebaute Health‑Checks und Validierungen:

API‑Verbindungstest

# Test the API endpoints
curl http://localhost:8080/

Webhook‑Test

# Simulate a webhook request
curl -X POST http://localhost:8080/webhook \
-H "Content-Type: application/json" \
-d '{
"event": "message:in:new", 
"data": {
"chat": {"id": "test", "fromNumber": "123", "type": "chat"}, 
"fromNumber": "123", 
"body": "Hello"
}
}'

Sende‑Nachricht‑Test

curl -X POST http://localhost:8080/message \
-H "Content-Type: application/json" \
-d '{
"phone": "1234567890", 
"message": "Test message", 
"device": "your-device-id"
}'

Entwicklung

Projektstruktur

Die Lösung folgt den Prinzipien der Clean Architecture:

  • Controllers: Verarbeiten HTTP‑Anfragen und ‑Antworten
  • Services: Geschäftslogik und Integration externer Dienste
  • Models: Data Transfer Objects und Domain‑Modelle
  • Configuration: Zentrale Konfigurationsverwaltung
  • Dependency Injection: Eingebaute .NET DI‑Container

Wichtige Klassen

  • ChatBot - Hauptlogik des Bots mit Nachrichtenfilterung und Routing
  • OpenAIClient - OpenAI API‑Integration mit Chat, Audio und Bildunterstützung
  • WassengerClient - Wassenger API‑Integration für WhatsApp‑Nachrichten
  • FunctionHandler - AI‑Function‑Calling‑System für externe Integrationen
  • WebhookController - HTTP‑Routing und Webhook‑Verarbeitung
  • BotConfig - Zentrale Konfigurationsverwaltung über Umgebungsvariablen
  • MemoryStore - In‑Memory‑Caching und Gesprächszustandsverwaltung
  • NgrokTunnel - Development‑Tunneling für lokale Tests

Ausführung in der Entwicklung

# Run with hot reload
dotnet watch run
# Run with specific environment
dotnet run --environment Development
# Run tests(if you add them)
dotnet test

NuGet‑Pakete hinzufügen

dotnet add package PackageName

Anpassung

Bot‑Anweisungen

Bearbeite das AI‑Verhalten in Config/BotConfig.cs:

private const string DefaultBotInstructions =
"You are a helpful assistant...";

Funktionsaufrufe

Füge benutzerdefinierte Funktionen in Bot/FunctionHandler.cs hinzu:

["getBusinessHours"] = new()
{
Name = "getBusinessHours", 
Description = "Get business operating hours", 
Parameters = new { type = "object", properties = new { } }, 
Handler = GetBusinessHours
}

Ratenlimits

Passe die Limits in Config/BotConfig.cs an:

public class LimitsConfig
{
public int MaxInputCharacters { get; set; } = 1000;
public int MaxOutputTokens { get; set; } = 1000;
public int ChatHistoryLimit { get; set; } = 20;
//...more limits
}

Neue API‑Integrationen hinzufügen

  1. Erstelle einen neuen Client im Api/‑Ordner
  2. Definiere Modelle in Models/
  3. Registriere ihn in Program.cs via Dependency Injection
  4. Nutze ihn im ChatBot oder erstelle neue Services

API‑Endpunkte

  • GET / - Bot‑Informationen und Status
  • POST /webhook - Webhook für eingehende WhatsApp‑Nachrichten
  • POST /message - Endpoint zum Senden von Nachrichten
  • GET /sample - Sendet eine Beispielnachricht
  • GET /files/{id} - Temporäre Dateidownloads

Swagger‑Dokumentation

Im Entwicklungsmodus besuchen:

Fehlerbehebung

Häufige Probleme

  1. „Keine aktiven WhatsApp‑Nummern“
  • Überprüfe deinen Wassenger API‑Schlüssel
  • Stelle sicher, dass du ein verbundenes WhatsApp‑Gerät in Wassenger hast
  1. „WhatsApp‑Nummer ist nicht online“
  • Stelle sicher, dass dein WhatsApp‑Gerät verbunden und online im Wassenger‑Dashboard ist
  1. Webhook empfängt keine Nachrichten
  • Prüfe, ob deine Webhook‑URL aus dem Internet erreichbar ist
  • Überprüfe Firewall‑Einstellungen
  • Prüfe die Logs auf Fehler bei der Webhook‑Registrierung
  1. OpenAI‑API‑Fehler
  • Überprüfe, ob dein OpenAI API‑Schlüssel gültig ist
  • Stelle sicher, dass der Modellname korrekt ist
  • Prüfe die Nutzung und Abrechnung deines OpenAI‑Kontos

Debug‑Modus

Aktiviere detailliertes Logging, indem du es in der .env setzt:

LOG_LEVEL=Debug

Oder in appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Debug"
    }
  }
}

Häufige Umgebungsprobleme

  • Port bereits in Verwendung: Ändere PORT in der .env
  • Ngrok nicht gefunden: Installiere ngrok oder setze NGROK_PATH
  • .NET‑Version: Stelle sicher, dass das .NET 8.0 SDK installiert ist

Ressourcen

Mitwirken

  1. Forke das Repository
  2. Erstelle einen Feature‑Branch (git checkout -b feature/amazing-feature)
  3. Nimm deine Änderungen vor
  4. Füge Tests hinzu, falls anwendbar
  5. Committe deine Änderungen (git commit -m 'Add some amazing feature')
  6. Push auf den Branch (git push origin feature/amazing-feature)
  7. Öffne einen Pull Request

Entwicklungsrichtlinien

  • Folge den C#‑Coding‑Konventionen
  • Verwende async/await für alle I/O‑Operationen
  • Füge XML‑Dokumentation für öffentliche APIs hinzu
  • Inkludiere Unit‑Tests für neue Funktionalität
  • Aktualisiere das README für neue Features

Performance & Skalierbarkeit

Diese C#‑Implementierung bietet mehrere Vorteile:

  • Hohe Performance: .NET 8 Runtime‑Optimierungen und kompilierter Code
  • Speicher‑Effizienz: Korrekte Disposal‑Muster und Speicherverwaltung
  • Nebenläufige Verarbeitung: Async/await und Task‑basierte Verarbeitung
  • Skalierbar: Eingebaute Dependency Injection und Service‑Lifetime‑Verwaltung
  • Produktionsreif: Umfassendes Logging, Fehlerbehandlung und Health‑Checks

Sicherheitsfunktionen

  • Eingabevalidierung: Alle Webhook‑Eingaben werden validiert
  • Ratenbegrenzung: Eingebaute Nachrichtenquoten und Gesprächsbegrenzungen
  • Sichere Konfiguration: Verwaltung von Geheimnissen über Umgebungsvariablen
  • Fehlerbehandlung: Umfassende Exception‑Behandlung ohne Informationsleckage
  • HTTP‑Sicherheit: Moderne ASP.NET Core Sicherheits‑Defaults

More Articles & Tutorials

How Clinics Are Saving Up 25 Hours Weekly With WhatsApp Automation

Wie Kliniken wöchentlich 25 Stunden mit WhatsApp-Automatisierung sparen

October 21, 2025
How Real Estate Agents Are Conquering The Market By Automating WhatsApp

Wie Immobilienmakler den Markt erobern, indem sie WhatsApp automatisieren

October 17, 2025
Connect WhatsApp With AI In 5 Minutes MCP

Verbinde WhatsApp mit KI in 5 Minuten MCP

October 10, 2025
How To Build A WhatsApp Group Moderator With AI

Wie man einen WhatsApp-Gruppenmoderator mit KI erstellt

October 8, 2025
I Automated 50 WhatsApp Groups Here S The Code

Ich habe 50 WhatsApp-Gruppen automatisiert, hier ist der Code

October 6, 2025
How To Make Money With Wassenger Flows While Your Competitors Are Still Doing Everything Manually

Wie man mit Wassenger Flows Geld verdient, während die Konkurrenz alles noch manuell macht

October 3, 2025

Ready to transform your WhatsApp communication?

Start automating your customer interactions today with Wassenger

Get Started Free