02 51 76 0 34

Accès client :  mot de passe oublié   inscription

       (oubli)

Envoyer un SMS en Rust

Mis à jour le 22 juillet 2026

Le projet Cargo complet pour envoyer un SMS depuis Rust : une seule dépendance légère (ureq, TLS rustls intégré), gestion propre des erreurs réseau et des codes retour de l'API.

1Le projet complet (main.rs + Cargo.toml)

// main.rs — Envoi de SMS professionnel via l'API 123-SMS.net
// Copyright (C) 123-Sms.net — licence MIT
// Dependance unique : ureq (TLS rustls integre, pas d'OpenSSL requis).
//
// Execution :  cargo run
// Identifiants : espace client https://www.123-sms.net > rubrique API.

const IDENTIFIANT: &str = "votre_identifiant";
const CLE_API: &str = "CLEAPI";
const API_URL: &str = "https://www.123-sms.net/http.php";

/// Envoie un SMS et renvoie le code retour de l'API (80 = envoye).
fn envoyer_sms(numero: &str, message: &str) -> Result<String, ureq::Error> {
    // POST en HTTPS : la cle API ne transite jamais en clair,
    // send_form gere l'encodage URL (accents compris).
    let reponse = ureq::post(API_URL)
        .timeout(std::time::Duration::from_secs(15))
        .send_form(&[
            ("email", IDENTIFIANT),
            ("pass", CLE_API),
            ("numero", numero),
            ("message", message),
        ])?;
    Ok(reponse.into_string()?.trim().to_string())
}

fn main() {
    match envoyer_sms("33601020304", "Bonjour, ceci est un test 123-SMS.") {
        Ok(code) => match code.as_str() {
            "80" => println!("80 : le message a ete envoye."),
            "81" => println!("81 : enregistre pour un envoi differe."),
            "82" => println!("82 : identifiants invalides."),
            "83" => println!("83 : credit insuffisant."),
            "84" => println!("84 : numero invalide."),
            autre => println!("Code retour API : {autre}"),
        },
        Err(e) => eprintln!("Erreur reseau : {e}"),
    }
}

// ---- Cargo.toml ----
[package]
name = "sms123"
version = "1.0.0"
edition = "2021"

[dependencies]
ureq = "2"

2Installation et utilisation

  • Téléchargez l'archive et décompressez-la (ou cargo new sms123 puis copiez les deux fichiers).
  • Renseignez IDENTIFIANT et CLE_API en tête de main.rs (espace client › API).
  • Lancez cargo run — le code retour s'affiche (80 = envoyé).
  • En production : lisez les identifiants avec std::env::var et intégrez envoyer_sms() à votre binaire.
La clé API se génère dans l'espace client, rubrique API › Générer Clé API. Les codes réponse et le retour des accusés de réception par HTTP sont détaillés dans la documentation technique.

Questions fréquentes

Pourquoi ureq plutôt que reqwest ?

ureq est synchrone, minuscule et embarque rustls : pas d'OpenSSL à installer, compilation rapide, idéal pour un outil en ligne de commande ou un service d'alerte. Si votre application est déjà async (tokio), le même appel se fait avec reqwest en quelques lignes.

Comment gérer proprement les erreurs ?

La fonction renvoie Result<String, ureq::Error> : les erreurs réseau (DNS, timeout, TLS) remontent dans le Err, et les codes métier de l'API (82, 83, 84…) dans le Ok — à traiter avec un match comme dans l'exemple.

Puis-je l'utiliser sur un serveur ou un objet connecté ?

Oui : le binaire compilé est autonome (cross-compilation possible vers ARM/musl), parfait pour envoyer des SMS d'alerte depuis un serveur, un NAS ou une passerelle IoT sans dépendance système.

Comment suivre la livraison des SMS ?

Le code retour est immédiat (80 = envoyé) et les accusés de réception peuvent être reçus par HTTP avec le paramètre refaccuse — détails dans la documentation technique.

Téléchargement

Projet Cargo (.zip)

Licence MIT — libre et gratuit.

🔗 Voir sur GitHub

L'essentiel

  • API HTTPS en un appel : identifiant, clé API, numéro, message.
  • Code réponse immédiat + accusés de réception par HTTP.
  • Crédits prépayés sans abonnement ni expiration.
  • Adaptations spécifiques développées gratuitement.