Skip to content
Back to Blog
For BusinessAI & ChatbotsTutorials

Tutoriel complet du chatbot IA GPT 4o de WhatsApp en C

Un chatbot IA WhatsApp polyvalent et personnalisable en C# 🔷 capable de comprendre du texte 📝, de l'audio 🎵 et des images 🖼️, et de répondre à vos clients 💬 sur n'importe quel sujet lié à votre entreprise 🏢 directement sur WhatsApp ✅. Propulsé par OpenAI GPT4o 🚀 (d'autres modèles peuvent aussi être utilisés) et par Wassenger WhatsApp API 🔗.

Prend désormais en charge GPT-4o avec entrée texte + audio + image 📝🎵🖼️, réponses audio 🔊, et RAG amélioré + MCP avec appel de fonctions 🛠️ et prise en charge des appels API externes 🌐

Trouvez d'autres implémentations de chatbot IA en Python, Node.js et PHP

🚀 Commencez gratuitement avec Wassenger WhatsApp API en quelques minutes en connectant votre numéro WhatsApp existant et obtenez votre clé API ✨

Fonctionnalités

  • 🤖 Chatbot complet pour votre numéro WhatsApp connecté à Wassenger
  • 💬 Réponses automatiques aux messages entrants des utilisateurs
  • 🌍 Support multilingue — comprend et répond dans plus de 90 langues différentes
  • 🎤 Entrée/sortie audio — capacités de transcription et synthèse vocale
  • 🖼️ Traitement d'images — peut analyser et comprendre des images
  • 👥 Transfert vers un humain — permet aux utilisateurs de demander une assistance humaine
  • ⚙️ Comportement et instructions de l'IA personnalisables
  • 🔧 Appel de fonctions pour l'intégration de données externes
  • 📊 Gestion de la mémoire avec historique de conversation et limitation de débit
  • 🚦 Routage intelligent avec gestion des webhooks et des erreurs
  • 🔒 Sécurisé avec gestion appropriée des erreurs et journalisation
  • 🔄 C# moderne avec .NET 9, injection de dépendances et modèles async/await

Contenu

Démarrage rapide

  • Clonez le dépôt :
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)
  • Lancez le bot (mode développement local) :
cd src/WhatsAppChatBot dotnet run

Exigences

Configuration

Modifiez le fichier .env avec vos identifiants API :

# 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

Configuration des clés API

Clé API Wassenger :

  • Inscrivez-vous sur Wassenger (essai gratuit disponible)
  • Allez dans API Keys
  • Créez une nouvelle clé API et copiez-la dans API_KEY dans .env

Clé API OpenAI :

  • Inscrivez-vous sur OpenAI (crédits gratuits disponibles)
  • Allez dans API Keys
  • Créez une nouvelle clé API et copiez-la dans OPENAI_API_KEY dans .env

Jeton Ngrok (pour le développement local) :

Personnalisation du bot

Modifiez src/WhatsAppChatBot/Config/BotConfig.cs pour personnaliser :

  • Les instructions et la personnalité du bot
  • Les messages de bienvenue et d'aide
  • Les fonctionnalités prises en charge (audio, images, etc.)
  • Les limites de débit et les quotas
  • Les numéros en liste blanche/liste noire
  • Les étiquettes et paramètres de métadonnées

Utilisation

Développement local

Démarrez le serveur de développement :

cd src/WhatsAppChatBot dotnet run

Le bot va :

  • Démarrer un serveur HTTP local sur le port 8080
  • Éventuellement créer un tunnel Ngrok automatiquement
  • Enregistrer le webhook auprès de Wassenger
  • Commencer à traiter les messages WhatsApp

Envoyez un message à votre numéro WhatsApp connecté à Wassenger pour tester le bot.

Déploiement en production

Définissez les variables d'environnement sur votre serveur :

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

Build et exécution :

dotnet build -c Release dotnet run - configuration Release

Assurez-vous que votre serveur peut recevoir des requêtes POST à /webhook

Déploiement

Vous pouvez déployer ce bot sur n'importe quelle plateforme cloud qui prend en charge .NET 8.

Déploiement Docker

# 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

Architecture

L'implémentation C# suit les patterns modernes de .NET et une architecture propre :

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

Le projet inclut des vérifications de santé (health checks) et des validations intégrées :

Test de connexion API

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

Test du webhook

# 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"
}
}'

Test d'envoi de message

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

Développement

Structure du projet

La solution suit les principes d'une architecture propre :

  • Controllers : Gèrent les requêtes et réponses HTTP
  • Services : Logique métier et intégration des services externes
  • Models : Objets de transfert de données et modèles de domaine
  • Configuration : Gestion centralisée de la configuration
  • Dependency Injection : Conteneur DI intégré de .NET

Classes clés

  • ChatBot - Logique principale de traitement du bot avec filtrage et routage des messages
  • OpenAIClient - Intégration de l'API OpenAI avec support chat, audio et image
  • WassengerClient - Intégration de l'API Wassenger pour la messagerie WhatsApp
  • FunctionHandler - Système d'appel de fonctions de l'IA pour intégrations externes
  • WebhookController - Routage des requêtes HTTP et gestion des webhooks
  • BotConfig - Gestion centralisée de la configuration via variables d'environnement
  • MemoryStore - Cache en mémoire et gestion de l'état des conversations
  • NgrokTunnel - Tunnel de développement pour les tests locaux

Exécution en développement

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

Ajout de packages NuGet

dotnet add package PackageName

Personnalisation

Instructions du bot

Modifiez le comportement de l'IA dans Config/BotConfig.cs :

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

Appel de fonctions

Ajoutez des fonctions personnalisées dans Bot/FunctionHandler.cs :

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

Limites de débit

Ajustez les limites dans Config/BotConfig.cs :

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

Ajout de nouvelles intégrations API

  1. Créez un nouveau client dans le dossier Api/
  2. Définissez les modèles dans Models/
  3. Enregistrez dans Program.cs l'injection de dépendances
  4. Utilisez dans ChatBot ou créez de nouveaux services

Endpoints API

  • GET / - Informations et état du bot
  • POST /webhook - Webhook pour les messages entrants WhatsApp
  • POST /message - Endpoint pour envoyer un message
  • GET /sample - Envoyer un message d'exemple
  • GET /files/{id} - Téléchargements temporaires de fichiers

Documentation Swagger

Lorsque vous exécutez en mode développement, visitez :

Dépannage

Problèmes courants

  1. « No active WhatsApp numbers »
  • Vérifiez votre clé API Wassenger
  • Vérifiez que vous avez un appareil WhatsApp connecté dans Wassenger
  1. « WhatsApp number is not online »
  • Assurez-vous que votre appareil WhatsApp est connecté et en ligne dans le tableau de bord Wassenger
  1. Le webhook ne reçoit pas de messages
  • Vérifiez que votre URL de webhook est accessible depuis Internet
  • Vérifiez les paramètres du pare-feu
  • Consultez les logs pour les erreurs d'enregistrement du webhook
  1. Erreurs de l'API OpenAI
  • Vérifiez que votre clé API OpenAI est valide
  • Assurez-vous que le nom du modèle est correct
  • Vérifiez l'utilisation et la facturation de votre compte OpenAI

Mode debug

Activez la journalisation détaillée en le configurant dans .env :

LOG_LEVEL=Debug

Ou dans appsettings.Development.json :

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

Problèmes d'environnement courants

  • Port déjà utilisé : changez PORT dans .env
  • Ngrok introuvable : installez ngrok ou définissez NGROK_PATH
  • Version de .NET : assurez-vous que le SDK .NET 8.0 est installé

Ressources

Contribuer

  1. Forkez le dépôt
  2. Créez une branche de fonctionnalité (git checkout -b feature/amazing-feature)
  3. Apportez vos modifications
  4. Ajoutez des tests si nécessaire
  5. Committez vos changements (git commit -m 'Add some amazing feature')
  6. Poussez sur la branche (git push origin feature/amazing-feature)
  7. Ouvrez une Pull Request

Directives de développement

  • Suivez les conventions de codage C#
  • Utilisez async/await pour toutes les opérations I/O
  • Ajoutez une documentation XML pour les API publiques
  • Incluez des tests unitaires pour les nouvelles fonctionnalités
  • Mettez à jour le README pour les nouvelles fonctionnalités

Performances et montée en charge

Cette implémentation C# offre plusieurs avantages :

  • Haute performance : optimisations du runtime .NET 8 et code compilé
  • Efficace en mémoire : bonnes pratiques de disposal et gestion de la mémoire
  • Traitement concurrent : async/await et traitement basé sur Task
  • Scalable : injection de dépendances intégrée et gestion des durées de vie des services
  • Prêt pour la production : journalisation complète, gestion des erreurs et health checks

Fonctionnalités de sécurité

  • Validation des entrées : toutes les entrées de webhook sont validées
  • Limitation de débit : quotas de messages et limites de conversation intégrés
  • Configuration sécurisée : gestion des secrets basée sur l'environnement
  • Gestion des erreurs : traitement complet des exceptions sans fuite d'informations
  • Sécurité HTTP : valeurs par défaut de sécurité modernes d'ASP.NET Core
More

More articles & tutorials

Ready to transform your WhatsApp communication?

Start automating your customer interactions today with Wassenger.

Get started freeSee pricing

Browse more

Tutorials, guides and case studies on running WhatsApp at team scale.

All articlesIntegrationsMCP for AI agents
Ready for the official WhatsApp Business API?See what Meta charges — and keep your current number.
WhatsApp API pricing