Sandbox-Schnellstart: Senden und Empfangen von WhatsApp-Nachrichten mit Python

Einführung

Möchten Sie mit Python superschnell WhatsApp-Nachrichten senden und empfangen? Egal, ob Sie einen Chatbot testen, einen Messaging-Prototypen bauen oder einfach nur die Vonage Messages API, die Vonage WhatsApp Sandbox können Sie in wenigen Minuten loslegen.

In diesem Tutorial zeigen wir Ihnen, wie Sie WhatsApp-Nachrichten in Python mit Flask, einem leichtgewichtigen Web-Framework, das sich ideal für schnelle API-Experimente eignet, senden und empfangen können. Sie müssen nicht müssen keine vollständige Vonage-Anwendung einrichten oder sich um einen WhatsApp Business Account (WABA). Dies ist der schnellste Weg, die Vonage Messages API mit WhatsApp in Python auszuprobieren!

Voraussetzungen

Sie benötigen die folgenden Tools und Konten, um mitzumachen:

• Python 3.9+

• Vonage API-Konto

• ngrok (für Webhook-Tests)

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

Einrichten der WhatsApp-Sandbox

1. Melden Sie sich an beim Vonage API Dashboard.

2. Navigieren Sie zu Nachrichten > Nachrichten-Sandbox.

3. Scannen Sie den QR-Code mit WhatsApp, um der Sandbox beizutreten.

4. Fügen Sie Ihre Telefonnummer der Liste hinzu, indem Sie die vorausgefüllte Nachricht senden.

   1. Sie erhalten eine Antwort, in der Sie darüber informiert werden, dass Ihre Nummer in die Liste aufgenommen wurde, etwa so: "Thank you! Ihre Nummer ist jetzt in der "Skid Froze Messages API Sandbox" eingerichtet.

5. Halten Sie Ihre Sandbox-Nummer bereit (normalerweise etwa 14157386102).

Als nächstes müssen Sie die Webhooks für die Sandbox einrichten, um eine Verbindung zu unserer Flask-App herzustellen. Hierfür steht uns ngrok zur Verfügung. Öffnen Sie also Ihr Kommandozeilenterminal und führen Sie aus:

ngrok http 3000

Sie haben nun eine ngrok-URL, die etwa so aussieht:

Forwarding
https://59bd32ee0a4e.ngrok-free.app -> http://localhost:3000     

Jetzt können Sie die Webhooks aktualisieren:

• Für Inbound: https://YOUR_NGROK_URL/inbound

• Für Status: https://YOUR_NGROK_URL/status

Klicken Sie dann auf die Schaltfläche "Webhaken speichern". Für weitere Hilfe, siehe Testen mit ngrok.

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

Initialisieren Sie Ihr Python-Flask-Projekt

Öffnen Sie nun eine neue Registerkarte in Ihrem Terminal, während Sie Ihren ngrok-Tunnel weiterlaufen lassen. In der zweiten Registerkarte können Sie die folgenden Befehle einfügen, um Ihr Projekt zu erstellen:

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

Erforderliche Abhängigkeiten installieren

• Flachmann: Ein leichtgewichtiges Python-Webframework, mit dem Sie Ihren WhatsApp-Webhook-Server mit minimaler Einrichtung erstellen können.

• Python-dotenv: Lädt Umgebungsvariablen aus Ihrer .env-Datei in os.environ, so dass sensible Informationen wie API-Schlüssel nicht in Ihren Quellcode gelangen.

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

Fügen Sie Ihre Umgebungsvariablen hinzu

Innerhalb von .env müssen Sie Ihre Sandbox-Telefonnummer aus dem vorherigen Schritt sowie Ihren API_KEY und API_SECRET hinzufügen, die Sie auf Ihrer API-Einstellungen Seite.

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

Siehe unseren Python Umgebungsvariablen-Leitfaden für weitere Informationen

Konfigurieren Sie Ihre Umgebung

Bevor wir mit dem Senden von Nachrichten beginnen, müssen wir unsere Umgebungsvariablen laden und den Authentifizierungs-Header für die Vonage Messages API vorbereiten.

In Ihrer config.py Datei fügen Sie Folgendes hinzu:

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

Implementieren Sie Ihre WhatsApp-Logik

Nun, da Ihr Projekt mit Anmeldeinformationen verdrahtet ist, ist es an der Zeit, Ihre Flask-App zum Leben zu erwecken. In dieser Datei definieren Sie die Kernlogik für das Senden und Empfangen von WhatsApp-Nachrichten mit der Vonage Sandbox.

Sie beginnen mit der Einrichtung von zwei Endpunkten: einer für die Verarbeitung eingehender Nachrichten (/eingehend) und einen für die Aktualisierung des Nachrichtenstatus (/status). Wenn jemand eine WhatsApp-Nachricht an Ihre Sandbox-Nummer sendet, leitet Vonage sie an Ihren Flask-Server weiter. Ihre App protokolliert den Inhalt der Nachricht auf dem Terminal und kehrt den Text spaßeshalber um und sendet ihn als Antwort zurück. Dadurch erhält Ihre App eine vollständige Schleife von WhatsApp → Flask → WhatsApp.

Fügen Sie Folgendes zu Ihrer app.py Datei hinzu, um Webhooks zu empfangen und Nachrichten zu senden:

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)

Testen Sie Ihre App

Starten Sie Ihren Flask-Server in Ihrem Nicht-Ngrok-Terminal-Tab:

export FLASK_ENV=development
python3 app.py

Sobald die Einrichtung abgeschlossen ist:

1. Senden Sie eine Nachricht von Ihrer zugelassenen WhatsApp-Nummer an die Sandbox-Nummer.

2. Ihre Flask-App empfängt den Webhook und zeigt ihn im Terminal an.

3. Es sendet eine WhatsApp-Nachricht an Ihre Nummer zurück.

Sie sollten eine Antwort wie die folgende sehen. Können Sie erraten, wie die ursprüngliche Nachricht lautete?

Example WhatsApp message showing reversed text output

Anmerkung: Die Vonage Messages Sandbox ist nur für die Entwicklung gedacht. Um in die Produktion zu wechseln, müssen Sie eine Vonage Application erstellen und ein verifizierten WhatsApp Business Account (WABA).

Schlussfolgerung

Sie haben soeben einen Echtzeit-WhatsApp-Nachrichten-Handler in Python mit Flask erstellt; kein WABA, keine JWTs, nur sofortige Zwei-Wege-Nachrichten mit der Vonage Sandbox. Dieses Setup eignet sich hervorragend zur Validierung von Webhook-Flows oder zum schnellen Ausprobieren einer Nachrichtenlogik. Aber was ist, wenn Sie das Ganze weiter ausbauen wollen?

• Lesen Sie unseren Beitrag überVerbindung von WhatsApp zu ChatGPT mit Python. Darin erfahren Sie, wie Sie Ihrer Flask-App OpenAI-gestützte Antworten hinzufügen und mit nur ein paar zusätzlichen Zeilen Code einen einfachen Konversationsassistenten erstellen können.

• WhatsApp ist leistungsstark, aber haben Sie schon von RCS-Nachrichten gehört? Wenn Ihre Nutzer Android verwenden, können Sie mit RCS reichhaltige Inhalte wie Karussells, Schaltflächen und Nachrichten mit Markenbildern versenden. UnserPython RCS-Anleitung zeigt Ihnen, wie Sie loslegen können.