ChatGPT Intégration de WhatsApp en 5 étapes faciles (Guide d'utilisation)

Cet article a été mis à jour par Benjamin Aronov en juillet 2025

Introduction

Beaucoup de gens passent leur temps sur WhatsApp, que ce soit pour discuter avec leurs amis, leur famille ou même des entreprises. ChatGPT est devenu l'un des moyens les plus faciles de créer des expériences conversationnelles ; non seulement sur WhatsApp, mais aussi sur Facebook Messenger mais aussi sur Facebook Messenger.

Dans ce tutoriel, nous allons vous montrer comment connecter les deux : lorsque quelqu'un envoie un message sur WhatsApp, votre backend Python le transmettra à ChatGPT, obtiendra une réponse et la renverra en tant que réponse ; le tout en utilisant le bac à sable de l'API Messages API et une simple application Flask.

C'est un moyen utile de construire un assistant de base, de tester des idées de conversation, ou simplement de voir comment ces API s'articulent. Nous montrerons également comment l'étendre pour envoyer des images en utilisant l'API de génération d'images d'OpenAI (DALL-E).

À la fin, vous aurez un chatbot WhatsApp fonctionnel auquel vous pourrez parler en utilisant votre numéro de bac à sable.

Conditions préalables

Dans ce tutoriel, vous aurez besoin des prérequis suivants pour intégrer ChatGPT à WhatsApp :

• Compte API Vonage

• Compte API OpenAI

• Python 3.9+

• Flacon

• ngrok

Vonage API Account

To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.

Ready to start building?

Experience seamless connectivity, real-time messaging, and crystal-clear voice and video calls—all at your fingertips.

Étape 1 : Configurer l'Environnement de test de l'API Messages pour WhatsApp

Connectez-vous au tableau de bord du développeur Vonage. Ouvrez ensuite l'espace de travail Messages Sandbox.

Scannez le code QR pour ouvrir WhatsApp et envoyez le message prérempli. Une fois le message envoyé, cela ajoutera votre numéro de téléphone à la liste d'autorisation.

Ensuite, il faut configurer les webhooks pour que le bac à sable se connecte à notre application Flask. Pour cela, nous avons ngrok. Ouvrez donc votre terminal de ligne de commande et exécutez :

ngrok http 3000

Vous avez maintenant votre URL ngrok qui ressemble à quelque chose comme :

Forwarding   https://ed95-77-137-44-66.ngrok-free.app 
-> http://localhost:3000

Vous pouvez maintenant mettre à jour les webhooks :

• Pour les appels entrants : https://YOUR_NGROK_URL/inbound

• Pour le statut : https://YOUR_NGROK_URL/status

Pour plus d'aide, voir Tester avec ngrok.

Configuring webhook URLs for inbound messages and status updates in the WhatsApp sandbox.

Besoin d'aide avec les .env fichiers ? Consultez notre Premiers pas avec les variables d'environnement Python pour obtenir de l'aide sur la gestion sécurisée des clés d'API.

Étape 2 : Comment configurer une application Flask

Maintenant que votre bac à sable est prêt à envoyer et recevoir des messages WhatsApp, créez votre appli Flask, qui s'occupera de la logique :

mkdir whatsapp-chatgpt-bot
cd whatsapp-chatgpt-bot

Créer un environnement virtuel pour une gestion sûre des paquets et de l'environnement. Toutes les commandes suivantes doivent être exécutées à partir de l'environnement virtuel.

python3 -m venv venv
source venv/bin/activate

Créer les fichiers principaux de Flask :

touch main.py config.py .env requirements.txt

Installer les dépendances de notre projet :

pip install flask requests openai python-dotenv

Et les enregistrer dans notre fichier d'exigences :

pip freeze > requirements.txt

Ajoutez vos identifiants Vonage et OpenAI à votre fichier .env :

VONAGE_API_KEY=your_api_key
VONAGE_API_SECRET=your_secret

OPENAI_API_KEY=your_openai_key

>> Voir la page Premiers pas avec les variables d'environnement Python pour plus d'aide.

Vous pouvez alors charger vos variables d'environnement en toute sécurité dans le fichier config.py en toute sécurité. De plus, votre clé API Vonage et votre secret sont concaténés et encodés pour vous permettre de vous authentifier avec l'API Vonage.

from dotenv import load_dotenv
import os
import base64

load_dotenv()

VONAGE_API_KEY = os.getenv("VONAGE_API_KEY")
VONAGE_API_SECRET = os.getenv("VONAGE_API_SECRET")
VONAGE_SANDBOX_NUMBER = 14157386102

credentials = f"{VONAGE_API_KEY}:{VONAGE_API_SECRET}"
encoded_credentials = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
VONAGE_AUTH_HEADER = f"Basic {encoded_credentials}"

VONAGE_URL = "https://messages-sandbox.nexmo.com/v1/messages"

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

Enfin, dans notre fichier main.py créons notre serveur Flask. Ce serveur a deux points d'extrémité, /inbound et /statusqui correspondent à ceux que vous avez mis en place plus tôt dans votre bac à sable ! Ainsi, chaque fois que quelque chose se produit dans l'application Vonage, elle le transmettra à votre serveur Flask, puis la logique ici sera déclenchée.

import os
import json
import logging
from flask import Flask, request, Response
from config import *

app = Flask(__name__)
logging.basicConfig(format="%(message)s", level=logging.INFO)

@app.route('/status', methods=['POST'])
def message_status():
    data = request.get_json()
    logging.info(f"Status webhook received: {json.dumps(data)}")
    return Response(status=204)

@app.route('/inbound', methods=['POST'])
def inbound_message():
    data = request.get_json()
    logging.info(f"Inbound message: {json.dumps(data)}")

    return Response(status=200)

if __name__ == "__main__":
    port = int(os.environ.get("PORT", 3000))
    app.run(host="0.0.0.0", port=port)

Vous pouvez maintenant tester que la sandbox reçoit bien vos messages et les transmet à l'appli Flask. Dans un onglet séparé de votre ngrok, lancez votre serveur Flask :

chmod 666 main.py
export FLASK_ENV=development
export FLASK_APP=main.py
python3 main.py -p 3000

Et vous devriez voir vos messages enregistrés sur le serveur !

Étape 3 : Comment recevoir des messages WhatsApp dans Flask

Créons maintenant une logique pour analyser les messages WhatsApp entrants de Vonage, identifier l'utilisateur et le contenu du message, et envoyer une réponse dans WhatsApp.

Tout d'abord, créons un nouveau fichier pour stocker toute notre logique :

touch chatbot_utils.py

A l'intérieur chatbot_utils.py ajouter ce qui suit :

import os
import json
import requests
from   config import *
from openai import OpenAI

# OpenAI setup using SDK v1.x
client = OpenAI(api_key=OPENAI_API_KEY)

def send_whatsapp_text(to, text):
    payload = {
        "from": VONAGE_SANDBOX_NUMBER,
        "to": to,
        "channel": "whatsapp",
        "message_type": "text",
        "text": text
    }
    _post_to_vonage(payload)


def _post_to_vonage(payload):
    headers = {
        "Content-Type": "application/json",
        "Accept": "application/json",
        "Authorization": VONAGE_AUTH_HEADER
    }
    response = requests.post(VONAGE_URL, headers=headers, data=json.dumps(payload))
    response.raise_for_status()

Ensuite, mettez à jour votre fichier main.py pour importer nos nouvelles fonctions, sous les importations précédentes :

from chatbot_utils import *

Et mettre à jour le /inbound dans main.py pour obtenir l'expéditeur et utiliser notre fonction send_whatsapp_text :

@app.route('/inbound', methods=['POST'])
def inbound_message():
    data = request.get_json()
    logging.info(f"Incoming message:\n{json.dumps(data, indent=2)}")

    try:
        sender = data['from']
        text = data.get('text', '').strip()

        if not text:
            logging.warning("No text in incoming message. Skipping.")
            return Response(status=204)

       response_text = f"I've received your question! You asked: \n \n {text}"
       send_whatsapp_text(sender, response_text)

    except Exception as e:
        logging.error(f"Error processing inbound message: {e}", exc_info=True)
        return Response("Error", status=500)

    return Response(status=200)

Vous pouvez maintenant redémarrer votre serveur Flask et tester le nouveau code ! Votre question devrait vous être répétée.

A WhatsApp chat showing the Vonage Sandbox confirming receipt of a user's question about the meaning of life.

Étape 4 : Appeler l'API OpenAI et envoyer une réponse WhatsApp

Notre dernière étape consiste à appeler l'API OpenAI, en transmettant le message de l'utilisateur, puis en gérant la réponse à WhatsApp.Inside chatbot_utils.py ajoutez la fonction suivante :

def generate_chatgpt_reply(prompt):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": prompt}
        ]
    )
    return response.choices[0].message.content.strip()

Et vous pouvez maintenant l'utiliser en mettant à jour le /inbound endpoint :

@app.route('/inbound', methods=['POST'])
def inbound_message():
    data = request.get_json()
    logging.info(f"Incoming message:\n{json.dumps(data, indent=2)}")

    try:
        sender = data['from']
        text = data.get('text', '').strip()

        if not text:
            logging.warning("No text in incoming message. Skipping.")
            return Response(status=204)

        # Generate reply using ChatGPT
        reply = generate_chatgpt_reply(text)
        logging.info(f"ChatGPT reply: {reply}")

        # Send response via WhatsApp
        send_whatsapp_text(sender, reply)

    except Exception as e:
        logging.error(f"Error processing inbound message: {e}", exc_info=True)
        return Response("Error", status=500)

    return Response(status=200)

Étape 5 : Tester l'intégration de ChatGPT et WhatsApp

Vous pouvez maintenant (re)démarrer votre serveur Flask :

chmod 666 main.py
export FLASK_ENV=development
export FLASK_APP=main.py
python3 main.py -p 3000

Et envoyez une question au numéro de téléphone de WhatsApp Sandbox. Vous recevrez alors une réponse de ChatGPT !

WhatsApp chatbot responds to a user question with a detailed explanation generated by ChatGPT.

Bonus : Génération d'images

Génial ! Vous avez ajouté la génération de texte avec un LLM en utilisant le modèle GPT-4o d'OpenAI. Mais vous pouvez également générer et envoyer des images IA en utilisant le modèle DALL-E d'OpenAI. Étendons notre application en détectant lorsqu'un utilisateur envoie un message commençant par "IMAGE :"Nous pouvons appeler DALL-E pour générer une image, puis la renvoyer à l'utilisateur sur WhatsApp avec une légende.

Dans votre fichier chatbot_utils.py ajoutez les deux fonctions suivantes, send_whatsapp_image et generate_image_from_prompt :

def send_whatsapp_image(to, image_url, caption="Image"):
    payload = {
        "from": VONAGE_SANDBOX_NUMBER,
        "to": to,
        "channel": "whatsapp",
        "message_type": "image",
        "image": {
            "url": image_url,
            "caption": caption
        }
    }
    _post_to_vonage(payload)


def generate_image_from_prompt(prompt):
    response = client.images.generate(
        model="dall-e-3",
        prompt=prompt,
        size="1024x1024",
        n=1
    )
    return response.data[0].url

Enfin, nous devrons mettre à jour notre point d'accès /inbound pour déchiffrer si l'utilisateur a envoyé une demande d'image ou une question normale :

@app.route('/inbound', methods=['POST'])
def inbound_message():
    data = request.get_json()
    logging.info(f"Incoming message:\n{json.dumps(data, indent=2)}")

    try:
        sender = data['from']
        text = data.get('text', '').strip()

        if not text:
            logging.warning("No text in incoming message. Skipping.")
            return Response(status=204)

        if text.upper().startswith("IMAGE:"):
            prompt = text[6:].strip()
            logging.info(f"Image prompt: {prompt}")
            image_url = generate_image_from_prompt(prompt)
            send_whatsapp_image(sender, image_url, caption=prompt)
        else:
            reply = generate_chatgpt_reply(text)
            logging.info(f"ChatGPT reply: {reply}")
            send_whatsapp_text(sender, reply)

    except Exception as e:
        logging.error(f"Error processing inbound message: {e}", exc_info=True)
        return Response("Error", status=500)

    return Response(status=200)

Redémarrez votre serveur et essayez de générer des images d'IA !

A DALL·E-generated image sent in response to the prompt 'What is the meaning of life?' via Vonage WhatsApp Sandbox

Conclusion

Beau travail ! Réussir à construire un chatbot WhatsApp fonctionnel qui se connecte à ChatGPT pour des réponses en texte naturel et qui génère même des images à l'aide de DALL-E, c'était génial ! C'était un excellent point de départ pour expérimenter avec les LLM.

À partir de là, vous pouvez ajouter des messages-guides personnalisés, enregistrer les entrées des utilisateurs pour la formation, gérer des commandes plus structurées ou même acheminer des messages vers des agents humains. La combinaison d'OpenAI et de l'API Messages de Vonage ouvre de nombreuses possibilités.

Vous voudrez également sortir du bac à sable et passer à une application Vonage complète. Remplacez les appels directs à l'API par le SDK Python de Vonage pour une meilleure gestion des erreurs et une meilleure maintenabilité. Cela vous permettra d'ajouter facilement une validation pour les webhooks entrants afin de vous assurer qu'ils proviennent réellement de Vonage, évitant ainsi d'éventuelles vulnérabilités en matière de sécurité.

Si vous construisez quelque chose de cool, nous voulons en entendre parler ! Rejoignez-nous dans le Slack des développeurs de Vonageou marquez-nous sur X (anciennement Twitter).