Démarrage rapide du bac à sable : Envoyer et recevoir des messages WhatsApp avec Python

Introduction

Vous souhaitez envoyer et recevoir des messages WhatsApp à l'aide de Python très rapidement ? Que vous testiez un chatbot, que vous construisiez un prototype de messagerie ou que vous exploriez simplement l Vonage Messages APIl'API de Vonage Messages Vonage WhatsApp Sandbox vous permet de démarrer en quelques minutes.

Dans ce tutoriel, nous verrons comment envoyer et recevoir des messages WhatsApp en Python à l'aide de Flask, un framework web léger idéal pour les expériences rapides d'API. Vous ne n'aurez pas Vous n'aurez pas besoin de mettre en place une application Vonage complète ou de vous soucier d'un compte d'entreprise WhatsApp (WABA). WhatsApp Business Account (WABA). C'est le moyen le plus rapide d'essayer l'API Messages de Vonage avec WhatsApp en Python !

Conditions préalables

Vous aurez besoin des outils et des Account suivants pour nous suivre :

• Python 3.9+

• Compte API Vonage

• ngrok (pour tester les webhooks)

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.

Configurer l'Environnement de test WhatsApp

1. Connectez-vous au tableau de bord de l'API de Vonage.

2. Naviguez vers Messagerie > Messages Sandbox.

3. Scannez le code QR avec WhatsApp pour rejoindre le bac à sable.

4. Ajoutez votre numéro de téléphone à la liste d'autorisation en envoyant le message pré-rempli.

   1. Vous recevrez une réponse vous informant que votre numéro a été inscrit sur la liste des numéros autorisés, quelque chose comme "Nous vous remercions ! Votre numéro est maintenant configuré sur le skid froze Messages API Sandbox."

5. Gardez votre numéro de bac à sable à portée de main (généralement quelque chose comme 14157386102).

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://59bd32ee0a4e.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

Cliquez ensuite sur le bouton "Enregistrer les webhooks". Pour plus d'aide, voir Tester avec ngrok.

Example of configured webhooks for inbound messages and status updates using ngrok URLs

Initialiser votre projet Python Flask

Maintenant, ouvrez un nouvel onglet dans votre terminal, tout en continuant à laisser tourner votre tunnel ngrok. Dans le second onglet, vous pouvez coller les commandes suivantes pour créer votre projet :

mkdir quickstart-whatsapp-python
cd quickstart-whatsapp-python
python3 -m venv venv
source venv/bin/activate
touch app.py config.py .env

Installer les dépendances requises

• Bouteille: Un cadre web léger en Python utilisé pour créer votre serveur WhatsApp webhook avec une configuration minimale.

• Python-dotenv: Charge les variables d'environnement de votre fichier .env dans os.environ, en gardant les informations sensibles comme les clés d'API hors de votre code source.

pip install python-dotenv flask
pip install requests
pip freeze > requirements.txt

Ajoutez vos variables d'environnement

A l'intérieur .env vous devrez ajouter le numéro de téléphone de l'Environnement de test que vous avez obtenu à l'étape précédente, ainsi que votre API_KEY et API_SECRET qui se trouvent dans votre page page Paramètres de l'API.

VONAGE_API_KEY=your-vonage-api-key
VONAGE_API_SECRET=your-vonage-api-secret
VONAGE_SANDBOX_NUMBER=your-vonage-sandbox-number
PORT=3000

Voir notre Guide des variables d'environnement Python pour plus d'informations

Configurer votre environnement

Avant de commencer à envoyer des messages, nous devons charger nos variables d'environnement et préparer l'en-tête d'authentification pour l'API Messages de Vonage.

Dans votre fichier config.py ajoutez ce qui suit :

import os
import base64
from dotenv import load_dotenv

load_dotenv()

VONAGE_API_KEY = os.getenv("VONAGE_API_KEY")
VONAGE_API_SECRET = os.getenv("VONAGE_API_SECRET")
VONAGE_SANDBOX_NUMBER = os.getenv("VONAGE_SANDBOX_NUMBER")
VONAGE_URL = "https://messages-sandbox.nexmo.com/v1/messages"

# Create Base64 encoded auth header
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}"

Mettez en œuvre votre logique WhatsApp

Maintenant que votre projet est connecté avec des informations d'identification, il est temps de donner vie à votre application Flask. Dans ce fichier, vous définirez la logique de base pour l'envoi et la réception de messages WhatsApp à l'aide de la Sandbox de Vonage.

Vous commencerez par mettre en place deux points d'extrémité : l'un pour gérer les messages entrants (/inbound) et un autre pour les mises à jour de l'état des messages (/status). Lorsque quelqu'un envoie un message WhatsApp à votre numéro de bac à sable, Vonage le transmet à votre serveur Flask. Votre application enregistrera le contenu du message dans le terminal, et pour s'amuser, elle inversera le texte et le renverra en guise de réponse. Cela donne à votre application une boucle complète de WhatsApp → Flask → WhatsApp.

Ajoutez ce qui suit à votre app.py pour recevoir des webhooks et envoyer des messages :

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

app = Flask(__name__)
logging.basicConfig(level=logging.INFO)

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

    headers = {
        "Content-Type": "application/json",
        "Authorization": VONAGE_AUTH_HEADER,
    }

    response = requests.post(VONAGE_URL, headers=headers, data=json.dumps(payload))
    response.raise_for_status()

@app.route("/inbound", methods=["POST"])
def inbound():
    data = request.get_json()
    sender = data.get("from")
    text = data.get("text", "").strip()

    logging.info(f"\n📩 Received message from {sender}:\n{text}\n")

    if sender and text:
        reversed_text = text[::-1]
        reply = f"Thank you for your message! Here's what it looks like in reverse:\n\n{reversed_text}"
        try:
            send_whatsapp_reply(sender, reply)
        except Exception as e:
            logging.error(f"Failed to send message: {e}", exc_info=True)
            return Response("Failed to send message", status=500)

    return Response(status=200)

@app.route("/status", methods=["POST"])
def status():
    data = request.get_json()
    logging.info(f"📬 Status webhook received:\n{json.dumps(data, indent=2)}\n")
    return Response(status=200)

if __name__ == "__main__":
    port = int(os.getenv("PORT", 3000))
    app.run(port=port)

Testez votre application

Démarrez votre serveur Flask dans votre onglet de terminal non-ngrok :

export FLASK_ENV=development
python3 app.py

Une fois la configuration terminée :

1. Envoyez un message depuis votre numéro WhatsApp sur liste autorisée vers le numéro de la sandbox.

2. Votre application Flask recevra le webhook et l'affichera dans le terminal.

3. Il renvoie un message WhatsApp à votre numéro.

Vous devriez voir apparaître une réponse comme celle ci-dessous. Pouvez-vous deviner quel était le message d'origine ?

Example WhatsApp message showing reversed text output

Remarque : Le bac à sable de Vonage Messages est réservé au développement. Pour passer à la production, vous devrez créer une Applications Vonage et utiliser un compte d'entreprise WhatsApp vérifié (WABA).

Conclusion

Vous venez de construire un gestionnaire de messages WhatsApp en temps réel en Python à l'aide de Flask ; pas de WABA, pas de JWT, juste une messagerie bidirectionnelle instantanée avec la Sandbox de Vonage. Cette configuration est idéale pour valider les flux des webhooks ou pour tester rapidement la logique des messages. Mais qu'en est-il si vous souhaitez aller plus loin ?

• Consultez notre article sur connecter WhatsApp à ChatGPT en utilisant Python. Vous apprendrez comment ajouter des réponses alimentées par OpenAI à votre application Flask et créer un assistant conversationnel simple en seulement quelques lignes de code supplémentaires.

• WhatsApp est puissant, mais avez-vous entendu parler de la messagerie RCS ? Si vos utilisateurs sont sous Android, RCS vous permet d'envoyer du contenu riche comme des carrousels, des boutons et des messages d'images de marque. Notre guide RCS Python vous explique comment démarrer.