Exclure les numéros de téléphone fixe des envois de SMS en Rust grâce à l’API Lookup v2 de Twilio

Time to read:

April 22, 2026

Rédigé par

Matthew Setter

Twilion

Révisé par

Dylan Frankcom

Twilion

Prévenir l’envoi de SMS vers des numéros fixes à l’aide de l’API Lookup v2 et de Rust

Vous disposez d’une application web développée en Rust qui connaît un succès considérable et à laquelle vous avez récemment intégré une fonctionnalité de notification par SMS. Vous êtes impatient de proposer cette nouveauté à vos utilisateurs et de procéder à sa mise en production.

Toutefois, lorsque votre application commence à envoyer les notifications par SMS soigneusement préparées à l’intention de vos utilisateurs, des erreurs intermittentes surviennent et les messages suivants s’affichent :

Distribution du message : ligne fixe ou opérateur inaccessible

Peu après, vous commencez à recevoir des demandes d’assistance ponctuelles de la part d’utilisateurs signalant qu’ils ne reçoivent pas les notifications attendues. Quelle est l’origine de ces problèmes ?

Il s’avère que votre application ne filtre pas les numéros de téléphone fixe avant de procéder à l’envoi de notifications par SMS vers ces numéros.

Comment résoudre cette situation ? Comment identifier de manière proactive les messages qui ne pourront pas être remis à leurs destinataires ? Plus précisément, comment détecter et exclure les numéros de téléphone fixe d’une liste de destinataires avant l’envoi des SMS, afin d’éviter également les frais de facturation associés aux tentatives d’envoi infructueuses ?

Ce tutoriel vous présente la procédure à suivre pour mettre en œuvre ce filtrage en Rust, à l’aide de l’l'API Lookup v2 de Twilio.

Prérequis

Vous aurez besoin des éléments suivants pour utiliser l'application :

Un compte Twilio gratuit ou payant. Un compte Twilio. Si vous ne disposez pas encore d’un compte, procédez à sa création.
Rust et Cargo. Si ces outils ne sont pas encore installés sur votre système, reportez-vous à la documentation d’installation.
Un ou plusieurs numéros de téléphone à valider, dont au moins un numéro de téléphone fixe. Privilégiez, dans la mesure du possible, des numéros vous appartenant ou appartenant à des personnes de votre entourage.
Un éditeur de code ou un environnement de développement intégré (IDE) de votre choix, tel que Neovim ou Visual Studio Code
Une connaissance élémentaire de l’utilisation du terminal, qui peut faciliter le suivi du tutoriel, sans toutefois constituer un prérequis.

Création d’un nouveau projet Rust

La première étape consiste à initialiser, à l’aide de Cargo, un nouveau projet Rust de type binaire, destiné à générer un programme exécutable. Pour cela, exécutez la commande suivante :

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

Ajouter les dépendances nécessaires

Comme tout projet dépassant le cadre d’un simple programme « Hello World », cette application nécessite plusieurs crates afin de simplifier son implémentation. Seules quelques dépendances sont nécessaires :

anyhow : fournit un type d’erreur concret et flexible permettant de simplifier la gestion des erreurs.
dotenv : permet de charger les variables d’environnement définies dans un fichier .env, notamment dans les environnements de développement et de test.
reqwest : fournit un client HTTP complet et performant.
rustlio : facilite l’intégration et l’utilisation des API Twilio au sein des applications développées en Rust.

Pour ajouter ces dépendances au projet, exécutez la commande suivante :

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

Afin d’en améliorer la lisibilité, j’ai réparti la commande ci-dessus sur plusieurs lignes. Sous Microsoft Windows, remplacez le caractère de continuation de ligne \ par le caractère ^.

Définir les variables d’environnement nécessaires

L’étape suivante consiste à configurer les deux variables d’environnement nécessaires à l’authentification des requêtes adressées à l’API Twilio Lookup v2.

Ces variables seront définies dans un fichier .env, puis chargées à l’aide de la crate dotenv. Dans le répertoire racine du projet, créez un fichier .env et insérez-y la configuration présentée ci-dessous.

TWILIO_ACCOUNT_SID=
TWILIO_AUTH_TOKEN=

Accédez ensuite à la Console Twilio depuis votre navigateur web et copiez les valeurs Account SID et Auth Token disponibles dans la section informations du compte, conformément à la capture d’écran ci-dessous.

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

Dans le fichier .env, affectez ces valeurs respectivement aux variables TWILIO_ACCOUNT_SID et TWILIO_AUTH_TOKEN.

Il est également possible de définir ces variables d’environnement lors de l’exécution du programme ou de transmettre les valeurs correspondantes à l’application en tant qu’arguments de ligne de commande. Vous pouvez retenir la méthode de configuration de votre choix.

Mettre à jour le code principal de l’application

Il est maintenant temps de passer au cœur de notre application et d’en écrire le code principal. Rassurez-vous, il n’y en a pas beaucoup ! Remplacez le code existant dans src/main.rs par le code présenté ci-dessous.

Remplacez ensuite l’emplacement prévu à cet effet dans le code ci-dessus <YOUR PHONE NUMBERS> par une liste de chaînes de caractères séparées par des virgules. Il s’agit des numéros de téléphone que vous souhaitez vérifier à l’aide de l’API Lookup v2, au format E.164, par exemple "+614912345678", "+61402987654". Veillez à inclure au moins un numéro fixe.

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(())
}

Le programme commence par charger vos identifiants Twilio (utilisateur et mot de passe) depuis le fichier .env. Il initialise ensuite un client HTTP bloquant avec Reqwest pour envoyer des requêtes à l’API Lookup, puis crée un vecteur (Vec) contenant les numéros de téléphone à vérifier.

J’ai volontairement choisi d’utiliser un client bloquant dans ce tutoriel, par souci de simplicité. Dans une application destinée à être déployée en production, vous utiliseriez probablement un client asynchrone pour améliorer la réactivité de votre application.

Passons maintenant à la partie la plus intéressante ! Commençons par transformer notre liste de numéros de téléphone phone_number_list en itérateur grâce à la méthode into_iter(). Nous allons ensuite utiliser filter() pour faire le tri et ne conserver que les numéros qui ne sont pas associés à des lignes fixes. Vous ne connaissez pas encore cette méthode ? Pas de problème, voyons comment elle fonctionne :

Elle crée un itérateur qui s’appuie sur une fermeture (closure) pour déterminer si chaque élément doit être renvoyé. La fermeture reçoit un élément en argument et doit retourner une valeur booléenne (true ou false). L’itérateur résultant ne produit que les éléments pour lesquels la fermeture retourne true.

Pour chaque numéro de téléphone, la fermeture fournie exécute donc les opérations suivantes :

Elle appelle la fonction lookup_phone_data_with_line_type pour tenter de récupérer les informations associées au numéro, y compris les données Line Type Intelligence fournies par l’API Lookup v2.
Si les informations sont disponibles, la fonction renvoie une instance de la structure PhoneNumber dont les champs sont renseignés. À défaut, elle renvoie une instance vide ou initialisée avec les valeurs par défaut.
Si le type de ligne associé au numéro de téléphone renvoyé possède la valeur landline, le numéro est exclu des éléments produits par l’itérateur.

L’itérateur retourné par la méthode filter() est ensuite converti en un vecteur (Vec) grâce à la méthode collect(). Enfin, les numéros de téléphone conservés à l’issue du filtrage sont affichés dans le terminal.

Ce tutoriel ne comporte pas de code consacré à l’envoi de SMS, son objectif étant spécifiquement de présenter une méthode permettant d’identifier et d’exclure les numéros de téléphone fixe d’une liste. Pour apprendre à envoyer des SMS en Rust à l’aide de Twilio, reportez-vous à ce tutoriel disponible sur le blog Twilio.

Tester le bon fonctionnement de l’application

Une fois le code implémenté, l’étape suivante consiste à vérifier que l’application fonctionne conformément aux attentes. Pour effectuer ce test, exécutez la commande suivante :

cargo run

Une fois le code compilé et exécuté, le terminal doit afficher un résultat similaire à l’exemple ci-dessous.

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

Éviter l’envoi de SMS vers des numéros fixes à l’aide de Rust et de l’API Lookup v2 de Twilio

En combinant les fonctionnalités de la bibliothèque standard de Rust avec celles de l’API Lookup v2 de Twilio, vous pouvez empêcher l’envoi de SMS vers des numéros de téléphone fixe depuis vos applications Rust. Cette approche permet de limiter les frais associés aux tentatives d’envoi infructueuses et d’améliorer l’expérience globale de vos utilisateurs.

Approfondir vos connaissances

Vous souhaitez continuer à explorer tout ce que vous pouvez réaliser avec Rust et Twilio ? Voici quelques tutoriels qui devraient vous intéresser :

Matthew Setter est rédacteur spécialisé PHP, Go et Rust au sein de l’équipe Twilio Voices. Il est également développeur dans chacun de ces trois langages. Il développe également des applications dans chacun de ces langages et a publié deux ouvrages Mezzio Essentials et Deploy with Docker Compose. Il est joignable à l’adresse msetter[at]twilio.com et présent sur LinkedIn et GitHub.

L’icône représentant un téléphone a été réalisée par Freepik et est disponible sur Flaticon. L’illustration de Ferris provient du site rustacean.net.

Résumé généré par l’IA

Filtrez les numéros de téléphone fixe avant l’envoi de SMS afin de prévenir les erreurs.
Configurez un projet Rust et exploitez l’API Lookup v2 de Twilio pour identifier les différents types de numéros de téléphone.
Utilisez vos identifiants Twilio pour accéder aux fonctionnalités permettant d’éviter l’envoi de messages non distribuables.

Ce résumé a été généré par l’IA.

Articles associés

Ressources connexes

Twilio Docs

Des API aux SDK en passant par les exemples d'applications

Documentation de référence sur l'API, SDK, bibliothèques d'assistance, démarrages rapides et didacticiels pour votre langage et votre plateforme.

Centre de ressources

Les derniers ebooks, rapports de l'industrie et webinaires

Apprenez des experts en engagement client pour améliorer votre propre communication.

Ahoy

Le hub de la communauté des développeurs de Twilio

Meilleures pratiques, exemples de code et inspiration pour créer des expériences de communication et d'engagement numérique.