So verhindern Sie in Rust mit der Twilio Lookup v2 API den SMS-Versand an Festnetznummern

Time to read:

April 22, 2026

Autor:in:

Matthew Setter

Twilion

Prüfer:in:

Dylan Frankcom

Twilion

KI-generierte Zusammenfassung

Filtern Sie Festnetznummern vor dem SMS-Versand heraus, um Fehler zu vermeiden.
Richten Sie ein Rust-Projekt ein und nutzen Sie die Twilio Lookup v2 API, um den Telefonnummern-Typ zu prüfen.
Nutzen Sie Ihre Twilio-Zugangsdaten, um den Versand unzustellbarer Nachrichten zu verhindern.

Diese Zusammenfassung wurde mithilfe von KI erstellt.

So verhindern Sie mit der Lookup v2 API und Rust den SMS-Versand an Festnetznummern

Sie haben eine äußerst erfolgreiche Web-App auf Rust-Basis und vor Kurzem SMS-Benachrichtigungen integriert. Jetzt möchten Sie die neue Funktion Ihren Nutzern vorstellen und in Produktion bringen.

Doch sobald die Anwendung die sorgfältig formulierten SMS verschickt, treten sporadisch Fehler mit folgender Meldung auf:

Nachrichtenzustellung – Festnetz oder nicht erreichbarer Netzbetreiber.

Kurz darauf erreichen Sie immer wieder Supportanfragen von Nutzern, die wissen möchten, warum sie keine Benachrichtigungen erhalten. Was läuft hier schief?

Der Grund: Die Anwendung filtert Festnetznummern nicht heraus, bevor sie SMS-Benachrichtigungen an diese Nummern sendet.

Was können Sie also tun? Wie können Sie unzustellbare Nachrichten schon im Vorfeld erkennen? Oder noch besser: Wie filtern Sie Festnetznummern aus einer Liste von Telefonnummern, bevor Sie Nachrichten senden, und vermeiden gleichzeitig Kosten für fehlgeschlagene SMS?

In diesem Beitrag erfahren Sie, wie das in Rust mit der Twilio Lookup v2 API funktioniert.

Voraussetzungen

Für die Anwendung benötigen Sie Folgendes:

ein kostenloses oder kostenpflichtiges Twilio-Konto Erstellen Sie ein Konto, falls Sie noch keines haben.
Rust und Cargo. Falls beides noch nicht installiert ist, folgen Sie der Installationsanleitung.
eine oder mehrere Telefonnummern, die Sie validieren möchten, darunter mindestens eine Festnetznummer, idealerweise eigene Nummern oder Nummern von Personen, die Sie kennen
einen Code-Editor oder eine IDE Ihrer Wahl, etwa neovim oder Visual Studio Code
Grundkenntnisse im Umgang mit dem Terminal sind hilfreich, aber nicht erforderlich.

Neues Rust-Projekt erstellen

Initialisieren Sie zunächst mit Cargo ein neues Rust-Binärprojekt. Führen Sie dazu folgenden Befehl aus:

cargo new filter-landlines-with-rust --bin
cd filter-landlines-with-rust

Erforderliche Crates hinzufügen

Wie jedes gute Projekt, das über „Hello World“ hinausgeht, benötigt auch diese Anwendung einige Crates, die die Entwicklung vereinfachen. Es sind nur wenige:

anyhow: stellt einen flexiblen konkreten Fehlertyp bereit
dotenv: lädt Umgebungsvariablen aus einer .env-Datei und eignet sich ideal für Entwicklungs- und Testumgebungen
reqwest: stellt einen leistungsfähigen HTTP-Client bereit
rustlio: vereinfacht die Arbeit mit Twilio-APIs in Rust-Anwendungen

Führen Sie folgenden Befehl aus, um die Crates zum Projekt hinzuzufügen:

cargo add \
    anyhow \
    dotenvy \
    rustlio \
    reqwest --features reqwest/blocking --features reqwest/json

Zur besseren Lesbarkeit habe ich den Befehl auf mehrere Zeilen verteilt. Unter Microsoft Windows ersetzen Sie den Backslash durch ein Caret-Zeichen (^).

Erforderliche Umgebungsvariablen festlegen

Als Nächstes legen Sie zwei Umgebungsvariablen fest, die für authentifizierte Anfragen an die Twilio Lookup v2 API erforderlich sind.

Speichern Sie beide in einer Datei namens .env und laden Sie sie mit dem dotenv-Crate. Erstellen Sie im Stammverzeichnis des Projekts eine neue Datei namens .env und fügen Sie die folgende Konfiguration ein.

TWILIO_ACCOUNT_SID=
TWILIO_AUTH_TOKEN=

Öffnen Sie anschließend die Twilio Console in einem Browser Ihrer Wahl und kopieren Sie unter Account Info die Account SID und das Auth Token, wie im folgenden Screenshot gezeigt.

Screenshot of Twilio console displaying account SID, auth token, and phone number.

Tragen Sie die kopierten Werte nun in .env bei TWILIO_ACCOUNT_SID bzw. TWILIO_AUTH_TOKEN ein.

Alternativ können Sie die Umgebungsvariablen beim Ausführen des Codes festlegen oder der Anwendung als Befehlszeilenargumente übergeben. Wählen Sie einfach die Variante, die Ihnen lieber ist.

Kernanwendung aktualisieren

Jetzt kommt der eigentliche Anwendungscode. Viel ist es nicht. Ersetzen Sie den vorhandenen Code in src/main.rs durch den folgenden Code.

Ersetzen Sie anschließend <YOUR PHONE NUMBERS> durch eine kommagetrennte Liste von String-Literalen. Tragen Sie dort die Telefonnummern im E.164-Format ein, die Sie mit der Lookup v2 API prüfen möchten, zum Beispiel "+614912345678" und "+61402987654". Mindestens eine davon sollte eine Festnetznummer sein.

use anyhow::Result;
use rustlio::twilio::lookup;
use std::env;

fn main() -> Result<()> {
    dotenvy::dotenv()?;
    let user = env::var("TWILIO_ACCOUNT_SID")?;
    let pass = env::var("TWILIO_AUTH_TOKEN")?;
    let client = reqwest::blocking::Client::new();

    let phone_number_list = vec!["<YOUR PHONE NUMBERS>"];
    let non_landlines: Vec<&str> = phone_number_list
        .into_iter()
        .filter(|number| {
            let data = lookup::lookup_phone_data_with_line_type(
                number, 
                &client, 
                &user, 
                &pass
            );
            let phone_number = data.unwrap_or_default();
            phone_number.get_line_type() != "landline"
        })
        .collect::<Vec<&str>>();

    if non_landlines.is_empty() {
        println!("No non-landlines are available.");
    } else {
        println!("Available phone numbers: {:?}", non_landlines);
    }
    Ok(())
}

Der Code lädt zunächst die Twilio-Zugangsdaten (user und pass) aus .env. Anschließend erstellt er einen blockierenden Reqwest-Client für die Anfrage an die Lookup API sowie einen Vektor mit den zu prüfenden Telefonnummern.

In diesem Tutorial verwende ich bewusst einen blockierenden Client, da es sich um ein einfaches Beispiel handelt. In einer Produktionsanwendung würden Sie für eine bessere Reaktionsfähigkeit wahrscheinlich einen asynchronen Client verwenden.

Jetzt kommt der interessante Teil. Mit into_iter() wird aus den Telefonnummern in phone_number_list ein Iterator erstellt. Die Funktion filter beschränkt diesen anschließend auf Telefonnummern, die keine Festnetznummern sind. Falls Sie mit der Funktion nicht vertraut sind:

Sie erstellt einen Iterator, der mithilfe einer Closure entscheidet, ob ein Element ausgegeben wird. Für jedes Element muss die Closure true oder false zurückgeben. Der Iterator gibt nur die Elemente zurück, für die die Closure true liefert.

Für jede Telefonnummer führt die Closure also folgende Schritte aus:

Sie versucht mit lookup_phone_data_with_line_type, die Details der Telefonnummer einschließlich der Line Type Intelligence-Informationen aus der Lookup v2 API abzurufen.
Sind Details zur Telefonnummer verfügbar, wird eine vollständig ausgefüllte PhoneNumber-Struktur zurückgegeben. Andernfalls wird eine leere Standardstruktur verwendet.
Ist der Leitungstyp der zurückgegebenen Telefonnummer auf "landline" gesetzt, wird die Nummer herausgefiltert.

Der von filter() zurückgegebene Iterator wird anschließend mit collect() in einen Vektor umgewandelt. Zum Schluss werden die verbleibenden Telefonnummern im Terminal ausgegeben.

Code zum Versenden von SMS habe ich bewusst weggelassen, da sich dieses Tutorial darauf konzentriert, Festnetznummern aus einer Liste von Telefonnummern herauszufiltern. Wie Sie mit Rust und Twilio SMS versenden, erfahren Sie in diesem Tutorial im Twilio Blog.

Prüfen, ob alles wie erwartet funktioniert

Der Code ist fertig. Jetzt können Sie prüfen, ob er wie erwartet funktioniert. Führen Sie dazu folgenden Befehl aus.

cargo run

Nach dem Kompilieren und Ausführen sollte im Terminal eine Ausgabe ähnlich der folgenden erscheinen.

Available phone numbers: ["+614912345678", "+61402987654"]

So verhindern Sie mit der Twilio Lookup v2 API und Rust den SMS-Versand an Festnetznummern

Mit der Rust-Standardbibliothek und der Twilio Lookup v2 API können Sie verhindern, dass Ihre Rust-Anwendungen SMS an Festnetznummern senden. So vermeiden Sie Kosten für fehlgeschlagene SMS und bieten Ihren Nutzern gleichzeitig ein besseres Gesamterlebnis.

Noch einen Schritt weiter

Wenn Sie mehr darüber erfahren möchten, wie Sie Rust mit Twilio einsetzen können, finden Sie in den folgenden Tutorials weitere Beispiele:

Matthew Setter ist Redakteur für PHP, Go und Rust im Twilio Voices-Team und entwickelt selbst in allen drei Sprachen. Außerdem ist er Autor von Mezzio Essentials und Deploy with Docker Compose. Sie erreichen ihn unter msetter[at]twilio.com sowie auf LinkedIn und GitHub.

Das Telefonsymbol stammt von Freepik auf Flaticon und die besonders niedliche Ferris-Krabbe von rustacean.net.