Skip to content
Back to Blog
For BusinessAI & ChatbotsTutorials

WhatsApp GPT 4o AI Chatbot in C Guida Completa

Un chatbot AI per WhatsApp generico e personalizzabile in C# 🔷 che può comprendere testo 📝, audio 🎵 e immagini 🖼️, e rispondere ai tuoi clienti 💬 su qualsiasi argomento relativo alla tua attività 🏢 direttamente su WhatsApp ✅. Alimentato da OpenAI GPT4o 🚀 (possono essere usati anche altri modelli) e da Wassenger WhatsApp API 🔗.

Ora supporta GPT-4o con input testo + audio + immagine 📝🎵🖼️, risposte audio 🔊, e RAG migliorato + MCP con function calling 🛠️ e supporto per chiamate a API esterne 🌐

Trova altre implementazioni del Chatbot AI in Python, Node.js e PHP

🚀 Inizia gratuitamente con Wassenger WhatsApp API in pochi minuti collegando il tuo numero WhatsApp esistente e ottieni la tua chiave API ✨

Funzionalità

  • 🤖 Chatbot completo per il tuo numero WhatsApp connesso a Wassenger
  • 💬 Risposte automatiche ai messaggi in arrivo dagli utenti
  • 🌍 Supporto multilingue — comprende e risponde in oltre 90 lingue diverse
  • 🎤 Input/output audio — funzionalità di trascrizione e text-to-speech
  • 🖼️ Elaborazione delle immagini — può analizzare e comprendere immagini
  • 👥 Handoff a operatore umano — consente agli utenti di richiedere assistenza umana
  • ⚙️ Comportamento e istruzioni AI personalizzabili
  • 🔧 Capacità di function calling per integrazione di dati esterni
  • 📊 Gestione della memoria con cronologia conversazioni e limitazione delle richieste
  • 🚦 Instradamento intelligente con gestione dei webhook ed errori
  • 🔒 Sicurezza con corretta gestione degli errori e logging
  • 🔄 C# moderno con .NET 9, dependency injection e pattern async/await

Contenuti

Avvio rapido

  • Clona il repository:
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)
  • Avvia il bot (modalità sviluppo locale):
cd src/WhatsAppChatBot dotnet run

Requisiti

Configurazione

Modifica il file .env con le tue credenziali 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

Configurazione delle chiavi API

Wassenger API Key:

  • Iscriviti su Wassenger (prova gratuita disponibile)
  • Vai a API Keys
  • Crea una nuova chiave API e copiala in API_KEY nel file .env

OpenAI API Key:

  • Iscriviti su OpenAI (crediti gratuiti disponibili)
  • Vai a API Keys
  • Crea una nuova chiave API e copiala in OPENAI_API_KEY nel file .env

Token Ngrok (per sviluppo locale):

Personalizzazione del bot

Modifica src/WhatsAppChatBot/Config/BotConfig.cs per personalizzare:

  • Istruzioni e personalità del bot
  • Messaggi di benvenuto e di aiuto
  • Funzionalità supportate (audio, immagini, ecc.)
  • Limiti di velocità e quote
  • Numeri in whitelist/blacklist
  • Impostazioni di etichette e metadata

Utilizzo

Sviluppo locale

Avvia il server di sviluppo:

cd src/WhatsAppChatBot dotnet run

Il bot:

  • Avvierà un server HTTP locale sulla porta 8080
  • Potenzialmente creerà automaticamente un tunnel Ngrok
  • Registrerà il webhook con Wassenger
  • Inizierà a processare i messaggi WhatsApp

Invia un messaggio al tuo numero WhatsApp connesso a Wassenger per testare il bot.

Distribuzione in produzione

Imposta le variabili d'ambiente sul tuo 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

Compila ed esegui:

dotnet build -c Release dotnet run - configuration Release

Assicurati che il tuo server possa ricevere richieste POST su /webhook

Distribuzione

Puoi distribuire questo bot su qualsiasi piattaforma cloud che supporti .NET 8.

Distribuzione con 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

Architettura

L'implementazione in C# segue i pattern moderni di .NET e una 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

Testing

Il progetto include health check e validazioni integrate:

Test di connessione API

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

Test 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 invio messaggio

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

Sviluppo

Struttura del progetto

La soluzione segue i principi della clean architecture:

  • Controllers: Gestiscono richieste e risposte HTTP
  • Services: Logica di business e integrazione con servizi esterni
  • Models: Oggetti di trasferimento dati e modelli di dominio
  • Configuration: Gestione centralizzata della configurazione
  • Dependency Injection: Container DI integrato di .NET

Classi chiave

  • ChatBot - Logica principale del bot con filtraggio e instradamento dei messaggi
  • OpenAIClient - Integrazione con l'API OpenAI per chat, audio e immagini
  • WassengerClient - Integrazione con l'API Wassenger per messaggistica WhatsApp
  • FunctionHandler - Sistema di function calling AI per integrazioni esterne
  • WebhookController - Instradamento delle richieste HTTP e gestione dei webhook
  • BotConfig - Gestione centralizzata della configurazione tramite variabili d'ambiente
  • MemoryStore - Caching in-memory e gestione dello stato delle conversazioni
  • NgrokTunnel - Tunneling per sviluppo locale

Esecuzione in ambiente di sviluppo

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

Aggiunta di pacchetti NuGet

dotnet add package PackageName

Personalizzazione

Istruzioni del bot

Modifica il comportamento AI in Config/BotConfig.cs:

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

Function Calling

Aggiungi funzioni personalizzate in Bot/FunctionHandler.cs:

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

Limiti di velocità

Regola i limiti in 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
}

Aggiungere nuove integrazioni API

  1. Crea un nuovo client nella cartella Api/
  2. Definisci i modelli in Models/
  3. Registralo in Program.cs per la dependency injection
  4. Usalo in ChatBot o crea nuovi servizi

Endpoint API

  • GET / - Informazioni e stato del bot
  • POST /webhook - Webhook per messaggi WhatsApp in arrivo
  • POST /message - Endpoint per inviare messaggi
  • GET /sample - Invia un messaggio di esempio
  • GET /files/{id} - Download temporanei di file

Documentazione Swagger

Quando esegui in modalità sviluppo, visita:

Risoluzione dei problemi

Problemi comuni

  1. “No active WhatsApp numbers”
  • Verifica la tua chiave API Wassenger
  • Controlla di avere un dispositivo WhatsApp connesso in Wassenger
  1. “WhatsApp number is not online”
  • Assicurati che il tuo dispositivo WhatsApp sia connesso e online nel dashboard di Wassenger
  1. Webhook che non riceve messaggi
  • Controlla che l'URL del webhook sia accessibile da Internet
  • Verifica le impostazioni del firewall
  • Controlla i log per errori nella registrazione del webhook
  1. Errori API OpenAI
  • Verifica che la tua chiave API OpenAI sia valida
  • Assicurati che il nome del modello sia corretto
  • Controlla l'utilizzo e la fatturazione del tuo account OpenAI

Modalità Debug

Abilita il logging dettagliato impostandolo in .env:

LOG_LEVEL=Debug

Oppure in appsettings.Development.json:

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

Problemi comuni con l'ambiente

  • Porta già in uso: cambia PORT nel file .env
  • Ngrok non trovato: installa ngrok o imposta NGROK_PATH
  • Versione .NET: assicurati di avere installato il .NET 8.0 SDK

Risorse

Contribuire

  1. Fai il fork del repository
  2. Crea un branch per la feature (git checkout -b feature/amazing-feature)
  3. Apporta le tue modifiche
  4. Aggiungi test se applicabile
  5. Commit delle modifiche (git commit -m 'Add some amazing feature')
  6. Push del branch (git push origin feature/amazing-feature)
  7. Apri una Pull Request

Linee guida per lo sviluppo

  • Segui le convenzioni di codifica C#
  • Usa async/await per tutte le operazioni di I/O
  • Aggiungi documentazione XML per le API pubbliche
  • Includi unit test per le nuove funzionalità
  • Aggiorna il README per le nuove funzionalità

Prestazioni e scalabilità

Questa implementazione in C# offre diversi vantaggi:

  • Alte prestazioni: ottimizzazioni del runtime .NET 8 e codice compilato
  • Efficienza di memoria: pattern di disposal corretti e gestione della memoria
  • Elaborazione concorrente: async/await e processing basato su Task
  • Scalabile: dependency injection integrata e gestione dei lifecycle dei servizi
  • Pronta per la produzione: logging, gestione degli errori e health check completi

Funzionalità di sicurezza

  • Validazione degli input: tutti gli input dei webhook sono validati
  • Rate Limiting: quote e limiti delle conversazioni integrati
  • Configurazione sicura: gestione dei segreti basata su variabili d'ambiente
  • Gestione degli errori: gestione completa delle eccezioni senza perdita di informazioni sensibili
  • Sicurezza HTTP: impostazioni di sicurezza predefinite moderne di 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