Wie man SMS-Nachrichten mit Python, Flask und Vonage versendet

Dieses Tutorial zeigt Ihnen Schritt für Schritt, wie Sie SMS mit Python und Flask über die Vonage Messages API. Sie werden eine funktionierende Webanwendung erstellen, Webhooks konfigurieren und Zustellungsquittungen in Echtzeit verarbeiten. Obwohl In-App Messaging immer beliebter wird, gibt es immer noch eine Vielzahl von Anwendungsfällen für SMS, die von Terminerinnerungen über Notrufe bis hin zur Verifizierung der Identität über 2FA reichen. Am Ende dieses Tutorials werden Sie in der Lage sein, erfolgreich das Gerüst zu implementieren, das zum Senden einer SMS mit Vonage und einer Python-Flask-Anwendung.

Bevor wir mit dem Tutorial beginnen, werden wir einige der Begriffe und Technologien erläutern, die in der Beispielanwendung verwendet werden. Wenn Sie mit diesen Concepts bereits vertraut sind, können Sie zum Tutorial über das Versenden von SMS-Nachrichten mit Python übergehen.

So funktioniert das Versenden von Texten mit der Vonage Messages API

Die Vonage Messages API lässt sich mit SMS, MMS, RCS, WhatsApp, Messenger und Viber integrieren und ermöglicht so eine auf den Kanal Ihrer Wahl zugeschnittene Kommunikation. Insbesondere für SMS ermöglicht die Messages API das programmgesteuerte Senden von Texten durch eine HTTP-Anfrage an einen API-Endpunkt. Die API leitet die Nachricht an das Mobilfunknetz weiter, damit sie an das Gerät des Empfängers übermittelt werden kann. Unabhängig von der Art der Nachricht, die Sie senden, benötigt die API benötigt die folgenden Felder:

• Nachrichtentyp: Die Art der zu sendenden Nachricht, d. h, text oder image.

• Inhalt der Nachricht: Der Inhalt, der im Feld message_type Feld angegebenen Inhalte, d. h. die Textnachricht oder die öffentlich zugängliche URL des Bildanhangs.

• An: Der Empfänger der Nachricht.

• Von: Der Absender der Nachricht.

• Kanal: Der Kanal, über den die Nachricht gesendet wird, z. B, sms oder mms.

Der Text der Anfrage sieht wie folgt aus:

{
   "message_type": "text",
   "text": "Hello from Vonage",
   "to": "14155551234",
   "from": "14155551098",
   "channel": "sms",
}

A 202 Antwort enthält das Folgende:

{
   "message_uuid": "aaaaaaaa-bbbb-4ccc-8ddd-0123456789ab",
   "workflow_id": "3TcNjguHxr2vcCZ9Ddsnq6tw8yQUpZ9rMHv9QXSxLan5ibMxqSzLdx9"
}

Dabei ist message_uuid der eindeutige Bezeichner für die Nachricht ist und workflow_id bezieht sich auf die ID des Failover-Workflows - die nur vorhanden ist, wenn die Anforderung mit der Failover-Eigenschaft gesendet wurde. Weitere Informationen über diese Werte finden Sie in der Messages API-Dokumentation.

Im Vonage Python SDKwird die API wie folgt dargestellt:

from vonage_messages import Sms

message = Sms(
	from_='14155551098',
	to='14155551234',
	text='Hello from Vonage!',
)

Die SMS API vs. die Messages API

Vonage hat zwei Messages APIseine einfache und dedizierte SMS API und eine leistungsfähigere Messages API. Mit der SMS API können Sie SMS-Nachrichten programmatisch senden und empfangen. Wenn das alles ist, was Sie brauchen, wird diese API die Aufgabe erfüllen. Entwickler entscheiden sich jedoch häufig für die Messages API mit mehreren Kanälen, damit sie Nachrichten über verschiedene Kanäle, einschließlich SMS, senden und empfangen können. Mit anderen Worten: Wenn Sie heute mit der Messages API beginnen und morgen weitere Kanäle hinzufügen möchten, müssen Sie Ihre Integration nicht herausreißen und neu beginnen.

Außerdem sind die Anfragestruktur und die Webhook-Formate kanalübergreifend einheitlich. Sie unterstützt SMS, MMS, RCS, WhatsApp, Viber und Facebook Messenger. Die Messages API unterstützt auch Rich Content, so dass Ihre Nachrichten Bilder, Dateien, Vorlagen und interaktive Nachrichten auf den Kanälen enthalten können, die diese unterstützen. In diesem Tutorial werden wir die Messages API verwenden.

SMS, MMS, RCS und andere Kanäle

SMS

• Steht für Short Message Service.

• Verwendet standardisierte Kommunikationsprotokolle, um kurze Textnachrichten an oder zwischen Geräten zu senden.

MMS

• Steht für Multimedia Messaging Service.

• Ermöglicht das Versenden von multimedialen Inhalten wie Bildern, Videos, Audiodateien sowie längeren Textinhalten, als sie in einer einzigen SMS versendet werden können.

• Übermittelt Nachrichten über das Mobilfunknetz, ohne dass der Empfänger eine Daten- oder Wi-Fi-Verbindung haben muss.

RCS

• Steht für Rich Communication Services.

• Ist ein Kommunikationsprotokoll zum Senden von Nachrichten an und zwischen Geräten, die an ein Mobilfunknetz angeschlossen sind.

• Sie können Text, Fotos, Videos und Dateien sowie interaktive Elemente wie Schaltflächen für Antwortvorschläge und Aktionsvorschläge enthalten.

• Es hat einige Ähnlichkeiten mit MMS-Nachrichten, aber auch einige wichtige Unterschiede in der Nachricht.

WhatsApp, Messenger, und Viber

• Erfordert eine App zum Senden und Empfangen von Nachrichten, unabhängig vom Gerät.

• Es gibt unterschiedliche Anforderungen dafür, wer Nachrichten senden darf und wie.

Ein kurzer Überblick: Webanwendungen, Webhooks und Tunneling

Was ist eine Python-Flask-App?

In diesem Tutorial erstellen wir eine Webanwendung zum Senden einer SMS mit Flaskerstellen, einem leichtgewichtigen und dennoch leistungsstarken Web-Framework für Python. Als Framework ermöglicht es Entwicklern, schnell eine Softwareanwendung mit Webtechnologien zu erstellen, die in einem Webbrowser ausgeführt werden kann. Wir haben es für dieses Tutorial wegen seiner Benutzerfreundlichkeit und seines minimalistischen Ansatzes ausgewählt - im Gegensatz zu anderen Python-Webentwicklungs-Frameworks bietet es uns nur das Wesentliche, das wir für die Erstellung einer SMS-Beispielanwendung benötigen.

Was ist ein Webhook?

Ein Webhook ist eine Methode, mit der eine webbasierte Anwendung Daten oder Ereignisbenachrichtigungen an eine andere Anwendung weiterleitet und so eine automatische Kommunikation ermöglicht, ohne dass eine Anwendung die andere ständig nach Aktualisierungen fragen muss. Im Allgemeinen bedeutet dies, dass die Interaktion über eine API mit Hilfe einer HTTP-Anfrage über das Web erfolgt. In diesem speziellen Lehrgang werden wir einen Webhook verwenden, um die Messages API Empfangsbestätigung an die Flask-Anwendung weiterzuleiten.

Was ist Tunnelbau?

In diesem Tutorial werden wir eine Webanwendung erstellen und diese lokal auf Ihrem Rechner ausführen. Da sie lokal ausgeführt wird, kann das öffentliche Internet nicht darauf zugreifen, und wenn auf Ihre Webanwendung nicht zugegriffen werden kann, kann Vonage keine Anfrage an den Webhook stellen. An dieser Stelle kommt das Tunneling ins Spiel. Durch Tunneling werden lokale Server über temporäre oder statische öffentliche URLs dem öffentlichen Internet zugänglich gemacht. ngrok ist eine Softwareplattform, die diesen Dienst anbietet.

Zusammenfassend werden wir eine Python-Flask-Webanwendung mit einem Webhook erstellen und ngrok verwenden, um Ihre lokale Anwendung über einen Tunnel zu einer öffentlichen URL zugänglich zu machen, so dass Vonage tatsächlich an einen status Webhook.

Tutorial: SMS-Nachrichten mit Python, Flask und Vonage versenden

In diesem Tutorial werden wir Flask verwenden, um eine App zu implementieren, die Textnachrichten sendet und einen Webhook definiert. Wir werden ngrok verwenden, um den Webhook dem öffentlichen Internet auszusetzen, damit Vonage Anfragen an ihn stellen kann.

Wenn Sie möchten, können Sie den Code zum Senden einer SMS von der Vonage Gemeinschaft GitHub.

Voraussetzungen

Für die Durchführung dieses Tutorials benötigen Sie Folgendes:

• Python 3.8+

• A Vonage API-Konto

• Ein ngrok Account und Installation

Tutorial-Einrichtung

Bevor wir mit dem Bau beginnen, sollten wir alles in Ordnung bringen.

Erstellen Sie einen Account bei ngrok, installieren Sie es und erstellen Sie einen Tunnel

Die Messages API muss in der Lage sein, auf Ihren Webhook zuzugreifen, damit sie Anfragen an ihn stellen kann; daher muss die Endpunkt-URL über das öffentliche Internet zugänglich sein.

Sobald Sie ngrok installiert haben, öffnen Sie ein Terminalfenster und führen Sie es aus:

ngrok http 5000

Dieser Befehl generiert die öffentlichen URLs, zu denen Ihr lokaler Server an Port 5000 tunneln wird. Notieren Sie sich die öffentliche URL, da wir sie bei der Erstellung unserer Vonage-Anwendung verwenden werden; sie sollte etwa so aussehen:

Forwarding                	https://4647-135-180-11-118.ngrok-free.app -> http://localhost:5000

Bitte beachten Sie: Sofern Sie nicht eines der kostenpflichtigen Angebote von ngrok nutzen, sind die generierten öffentlichen URLs nicht dauerhaft. Mit anderen Worten: Jedes Mal, wenn Sie den ngrok ausführen, ändern sich die resultierenden URLs, und Sie müssen die Konfiguration Ihrer Vonage-Applikation aktualisieren. Um dies zu verhindern, lassen Sie ngrok für die Dauer des Tutorials laufen.

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.

In diesem Lernprogramm wird auch eine virtuelle Telefonnummer verwendet. Um eine zu erwerben, gehen Sie zu Rufnummern > Rufnummern kaufen und suchen Sie nach einer Nummer, die Ihren Anforderungen entspricht.

Sind Sie bereit, mit dem Bau zu beginnen?

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

Da wir die Messages API verwenden werden, müssen Sie auch Ihre Account-Einstellungen entsprechend konfigurieren. Wählen Sie in der linken Navigation im Entwickler-Dashboard API-Einstellungen. In den SMS-Einstellungen Abschnitt wählen Sie Messages API und füllen Sie die entsprechenden Eingabeaufforderungen aus, um Ihre Änderungen zu speichern.

A screenshot of the API Settings menu in the Vonage developer dashboard indicating where to configure the SMS settings to use the Messages API.Erstellen Sie eine Messages API-Anwendung und verknüpfen Sie Ihre Nummer mit ihr

Zunächst müssen Sie eine Messages API-Anwendung erstellen. Die "Anwendung", auf die wir uns hier beziehen, ist ein Container für die Konfigurations- und Sicherheitsinformationen, die Sie für die Messages API benötigen. Sie ist nicht dasselbe wie die Flask-Webanwendung, die wir ebenfalls erstellen werden.

Erstellen Sie Ihre Messages API-Anwendung im Entwickler-Dashboard indem Sie zur Seite Applications im linken Menü navigieren und auf die Schaltfläche Neue Anwendung erstellen Schaltfläche. Daraufhin wird das Menü zum Erstellen einer Anwendung geöffnet. Geben Sie Ihrer Anwendung einen Namen send-sms.

Unter dem Fähigkeiten schalten Sie die Option für NachrichtenDadurch wird eine Liste von Textfeldern angezeigt. Im Textfeld mit der Bezeichnung Status-URLgeben Sie die öffentliche ngrok-URL ein, die mit dem Webhook geändert wurde, den wir in der Flask-App definieren werden. Das sieht dann etwa so aus https://0a6ec0a950eb.ngrok-free.app/webhooks/message-status.

Da wir in diesem Tutorium keine eingehenden Nachrichten behandeln, wird die Eingehende URL nicht verwendet werden. Für die Erstellung einer Anwendung ist jedoch eine erforderlich, daher können Sie http://example.com/webhooks/inbound angeben, um diese Anforderung zu erfüllen.

Klicken Sie auf die Schaltfläche "Neuen Antrag generieren".

A screenshot of the Create an application menu in the Vonage developer dashboard indicating which options need to be configured in order to create a Messages application.Nachdem Ihr Antrag erstellt wurde, können Sie Ihre Nummer mit dem Antrag verknüpfen, indem Sie auf die Schaltfläche verknüpfen. in der Tabelle der verfügbaren Numbers klicken. Achten Sie darauf, dass Sie eine Nummer mit SMS- und MMS-Funktionen auswählen.

Ein Projektverzeichnis erstellen

Führen Sie in einem neuen Terminalfenster den folgenden Befehl aus, um ein neues Projektverzeichnis zu erstellen und darin zu navigieren:

mkdir vonage-send-sms && cd vonage-send-sms 

Fangen wir an zu bauen!

Nun, da Sie alles vorbereitet haben, können Sie mit dem Bau beginnen.

Springen Sie zu einem beliebigen Abschnitt, indem Sie auf die unten stehenden Schritte klicken:

1. Erstellen und Aktivieren einer virtuellen Python-Umgebung

2. Abhängigkeiten installieren

3. Generieren Sie Ihre Anwendungs-ID und Ihren privaten Schlüssel und fügen Sie sie zu Ihren Umgebungsvariablen hinzu

4. Schreiben und Ausführen des Codes

5. Probieren Sie es aus!

1. Erstellen und Aktivieren einer virtuellen Python-Umgebung

Virtuelle Python-Umgebungen ermöglichen es Ihnen, Pakete an einem Ort zu installieren, der vom Rest Ihres Systems isoliert ist. Dies hilft, systemweites Durcheinander und Konflikte mit verschiedenen Python-Versionen und -Paketen zu vermeiden. Um mehr zu erfahren, lesen Sie unseren Blogbeitrag über virtuelle Umgebungen.

Führen Sie in Ihrem Projektverzeichnis die folgenden Befehle aus, um eine virtuelle Umgebung zu erstellen und eine virtuelle Umgebung zu aktivieren:

python3 -m venv venv && source venv/bin/activate

In der Terminal-Eingabeaufforderung sollte nun folgender Text erscheinen (venv). Um Ihre virtuelle Umgebung zu deaktivieren, führen Sie den deactivate Befehl aus.

2. Abhängigkeiten installieren

Um die Abhängigkeiten, die wir für dieses Tutorial benötigen, zu installieren, führen Sie Folgendes aus:

pip install vonage flask python-dotenv Jinja2 flask-socketio

3. Generieren Sie Ihre Anwendungs-ID und Ihren privaten Schlüssel und fügen Sie sie zu Ihren Umgebungsvariablen hinzu

Im Dashboard für Entwickler Applikationen Menüauf die Anwendung, die Sie für dieses Tutorial erstellt haben, und klicken Sie dann auf Bearbeiten. Sobald sich das Bearbeitungsfenster öffnet, klicken Sie auf die Schaltfläche "Öffentlichen und privaten Schlüssel generieren". Dadurch wird der Download Ihres privaten Schlüssels als Datei mit der Erweiterung .key. Behalten Sie diese Datei für sich und geben Sie sie nicht weiter, wo sie kompromittiert werden könnte. Wenn Sie vorhaben, diesen Code öffentlich zugänglich zu machen, fügen Sie die Datei mit dem privaten Schlüssel zu Ihrer .gitignore Datei.

Klicken Sie auf die Schaltfläche "Änderungen speichern" und notieren Sie sich Ihre Application ID.

A screenshot of the application Edit menu in the Vonage developer dashboard showing where to generate a public and private key.A screenshot of the Messages application in the Vonage developer dashboard indicating where you can find the application ID.Verschieben Sie Ihre private Schlüsseldatei in Ihr Projektverzeichnis. Erstellen Sie im selben Verzeichnis eine Datei namens .env und fügen Sie die folgenden Variablen hinzu:

APPLICATION_ID=replace-this-with-your-application-ID
PRIVATE_KEY=replace-this-with-the-name-of-your-private-key-file
VONAGE_VIRTUAL_NUMBER=replace-this-with-your-virtual-number

Sie können auch die Vorlage auf GitHub. Um mehr zu erfahren, lesen Sie unseren Blogbeitrag über Umgebungsvariablen.

4. Schreiben und Ausführen des Codes

In diesem Tutorial werden wir eine minimale Flask-Anwendung erstellen, die die Messages API nutzt, um eine SMS über ein Webformular zu versenden. Um dieses Formular zu erstellen, benötigen wir:

1. Der Python-Anwendungscode.

2. Und eine HTML-Vorlage, die in einem Browser wiedergegeben wird.

Der Python-Applikationscode

Erstellen Sie in Ihrem Projektverzeichnis eine Datei namens app.py die den folgenden Code enthält:

import os

from dotenv import load_dotenv
from flask import Flask, redirect, render_template, request, url_for
from flask_socketio import SocketIO
from vonage import Auth, Vonage
from vonage_messages import Sms

load_dotenv()

APPLICATION_ID = os.getenv("APPLICATION_ID")
PRIVATE_KEY = os.getenv("PRIVATE_KEY")
VONAGE_VIRTUAL_NUMBER = os.getenv("VONAGE_VIRTUAL_NUMBER")

if not APPLICATION_ID or not PRIVATE_KEY or not VONAGE_VIRTUAL_NUMBER:
	raise RuntimeError("Missing APPLICATION_ID, PRIVATE_KEY, or VONAGE_VIRTUAL_NUMBER env vars")

client = Vonage(Auth(application_id=APPLICATION_ID, private_key=PRIVATE_KEY))

app = Flask(__name__)
socketio = SocketIO(app)


@app.route('/')
def index():
	return render_template('index.html')


@app.route("/delivery_receipt/<message_uuid>")
def delivery_receipt(message_uuid):
	return render_template("delivery_receipt.html", message_uuid=message_uuid)


@app.route("/webhooks/message-status", methods=["POST"])
def message_status():
	data = request.get_json(silent=True) or {}
	message_uuid = data.get("message_uuid")
	status = data.get("status")

	if not message_uuid or not status:
    	return {"error": "missing message_uuid/status"}, 400

	payload = {"message_uuid": message_uuid, "status": status}

	err = data.get("error")
	if isinstance(err, dict):
    	payload["info"] = f"{err.get('title', 'Error')} : {err.get('detail', '')}"

	print(f"Status update uuid={message_uuid} status={status}")

	socketio.emit("status_update", payload)

	return "200", 200

@app.route("/send_sms", methods=["POST"])
def send_sms():
	to_number = (request.form.get("to_number") or "").strip()
	message = (request.form.get("message") or "").strip()

	print(f"To number is ===> {to_number}")

	if not to_number or not message:
    	return {"error": "to_number and message are required"}, 400

	response = client.messages.send(
    	Sms(
        	from_=VONAGE_VIRTUAL_NUMBER,
        	to=to_number,
        	text=message,
    	)
	)

	message_uuid = response.message_uuid
	print(f"Message UUID is ===> {message_uuid}")

	return redirect(url_for('delivery_receipt', message_uuid=message_uuid))


if __name__ == '__main__':
	socketio.run(app)

Schauen wir uns an, was hier passiert.

Der wichtigste Teil des Codes ist die send_sms Route und die Funktion. Hier verwenden wir die Messages API, um eine SMS zu versenden. In diesem Beispiel verwenden wir ein Online-Formular, um unsere Nachrichtendetails einzugeben und eine Anfrage an die Messages API auszulösen. Sobald das Formular abgeschickt ist, leitet die Anwendung zu einer delivery_receipt Seite.

Der nächste Block, auf den Sie achten müssen, ist die message_status Route und Funktion. Dies ist der Webhook, den wir für die Status-URL in unserer Nachrichten-Anwendung im Entwickler-Dashboard konfiguriert haben. Hier sendet Vonage Updates über den Status der von der App gesendeten Nachricht.

Normalerweise wird für die Aktualisierung des Nachrichtenstatus eine Datenbank oder ein Polling verwendet, aber da es sich um eine minimale Demo-Anwendung handelt, werden wir WebSocket verwenden. WebSocket ist ein Protokoll, das die Kommunikation zwischen dem Server und dem Browser ermöglicht. Es hat einen Vorteil gegenüber RESTful HTTP, da die Kommunikation sowohl bidirektional als auch in Echtzeit erfolgt. So kann der Server den Client jederzeit benachrichtigen, anstatt dass der Client in regelmäßigen Abständen nach Aktualisierungen fragt.

Dieses spezielle Beispiel verwendet die socketio Bibliothek um einen Kommunikationskanal einzurichten. Diese Statusaktualisierungen werden auf der Seite "Zustellungseingang" angezeigt. So können Sie den Status und alle zusätzlichen Informationen in Echtzeit sehen, selbst wenn die Nachricht aufgrund von Vorschriften oder aus anderen Gründen fehlschlägt.

Die HTML-Vorlagen

Erstellen Sie in Ihrem Projektverzeichnis ein Verzeichnis mit dem Namen templates. A templates Verzeichnis ist eine Flask-Konvention: Flask ist so konfiguriert, dass es nach einem templates Verzeichnis zu suchen, wenn HTML für das Frontend einer Webanwendung gerendert wird.

Im Verzeichnis templates Verzeichnis erstellen Sie zwei Dateien: index.html und delivery_receipt.html. Kopieren und fügen Sie den entsprechenden Code aus dem GitHub-Repositorium.

Jetzt haben Sie alles, was Sie brauchen, um den Code auszuführen. Um Ihre Webanwendung lokal bereitzustellen, führen Sie den folgenden Befehl im Stammverzeichnis des Projekts aus:

flask run

Dadurch wird ein Server auf http://127.0.0.1:5000. Navigieren Sie in einem Webbrowser zu diesem Ort, und Sie sollten etwa Folgendes sehen:

A screenshot of the web app created for the tutorial with a form to send an SMS.5. Probieren Sie es aus!

Füllen Sie das Formular aus und geben Sie die Telefonnummer (mit Landesvorwahl) an, an die Sie eine SMS senden möchten, sowie eine Nachricht, die Sie senden möchten.

Je nach den SMS-Bestimmungen in Ihrer Region erhalten Sie eine Textnachricht von Ihrer virtuellen Vonage-Nummer unter Verwendung der von Ihnen im Formular angegebenen Informationen. Da der Versand einer SMS von einer virtuellen Nummer von Vonage jedoch in verschiedenen Ländern eingeschränkt sein kann, wird die Flask-App unabhängig davon, ob die Nachricht erfolgreich ist oder nicht, eine Echtzeit-Zustellungsbestätigung von Vonage erstellen.

A screenshot of the web app created for the tutorial showing a message delivery receipt.Bitte beachten Sie: Aufgrund der weltweit unterschiedlichen SMS-Vorschriften kann es vorkommen, dass Sie einen Fehlercode von Vonage erhalten, wenn Sie versuchen, eine SMS von einer virtuellen Vonage-Nummer zu senden. Sie können Protokolle im Entwickler-Dashboard einsehen durch Auswahl von Protokolle in der Navigation auf der linken Seite auswählen. Wenn Sie mehr über die SMS-Bestimmungen erfahren möchten - insbesondere, wenn Sie eine 10-stellige US-Nummer verwenden - lesen Sie diesen Blogbeitrag über was Sie über 10DLC wissen müssen.

Zusammenfassung

Dieses Tutorial führt Sie durch den Prozess des Versendens von SMS-Nachrichten mit Python, Flask und der Vonage Messages API. SMS spielt weiterhin eine wichtige Rolle in verschiedenen Anwendungen, von Warnungen bis zur Authentifizierung, und dieser Leitfaden bietet einen praktischen Ansatz für die Erstellung einer SMS-fähigen Webanwendung.

Sie haben gelernt, wie Sie eine Flask-Anwendung einrichten, die Vonage-API integrieren und ngrok nutzen, um Ihren lokalen Server dem Internet auszusetzen und so Echtzeit-Nachrichten zu ermöglichen. Das Tutorial behandelte wesentliche Komponenten wie API-Konfigurationen, Webhook-Verarbeitung für Nachrichtenstatus-Updates und die Erstellung eines benutzerfreundlichen Webformulars für den Versand von SMS.

Darüber hinaus wurde das Verständnis der SMS-Bestimmungen und ihrer Auswirkungen hervorgehoben, um konforme Messaging-Praktiken zu gewährleisten und zu erklären, warum Vonage eine Nachricht möglicherweise nicht senden kann. Auch wenn diese Einschränkung bedeutet, dass Ihre App nicht voll funktionsfähig ist, haben Sie zumindest eine Grundlage, auf der Sie aufbauen können, sowie ein grundlegendes Verständnis für die Messages API. Von hier aus können Sie die API und andere Messaging-Kanäle weiter erforschen, um die Textkommunikation für Ihre Geschäftsanforderungen zu nutzen.

Weitere Lektüre und referenzierte Ressourcen

• Wie man eine SMS mit Python empfängt

• Ausgehende SMS-Zustellungsbestätigungen mit Python empfangen

• Vonage Messages API (SMS und MMS)

• Was Sie über 10DLC wissen müssen

• Vonage Server SDK für Python. API-Unterstützung für Voice, SMS, WhatsApp, Verify (2FA), Video Meetings und mehr.

• SMS Messages API-Leitfaden

• Verbinden Sie Ihren lokalen Entwicklungsserver mit der Vonage-API über einen Ngrok-Tunnel

• Vonage Application API Übersicht

• Python Umgebungsvariablen (Env Vars): Eine Fibel

• SMS-Nachrichten mit Python, Flask und Vonage auf GitHub versenden