# Comment envoyer un SMS depuis le code : Python, PHP, Node.js, Java, Go et C# en un seul appel REST > L'envoi d'un SMS via le code consiste en un unique HTTPS POST authentifié : un jeton Bearer, un corps JSON contenant l'identifiant d'expéditeur, le numéro de destination, le message et le type de message, ainsi qu'un ID de message en retour. Voici la même requête en Python, PHP, Node.js, Java, Go et C#, accompagnée de la gestion des erreurs et de conseils pour la production. - URL canonique: https://www.broadnet.me/fr/blog/send-sms-api-python-php-nodejs-java-csharp - Langue: fr - Dernière mise à jour: 2026-09-30 - Éditeur: BroadNet (https://www.broadnet.me) - Publié le: 2026-09-28 - Auteur: BroadNet Editorial Team Pour envoyer un SMS via le code, effectuez un HTTPS POST vers https://api.broadnet.me/sms/sendSms avec un en-tête Authorization: Bearer et un corps JSON contenant senderId, destinationNumber, le message et messageType. Un appel réussi renvoie un code HTTP 200 avec l'ID du message en corps de réponse ; le résultat de la livraison arrive plus tard sous forme d'accusé de réception (DLR) sur votre webhook. Chaque langage ci-dessous utilise uniquement sa bibliothèque HTTP standard ; la seule SDK officielle est destinée à TypeScript et Node.js. ## Points clés à retenir - Point de terminaison : POST https://api.broadnet.me/sms/sendSms, corps JSON, jeton Bearer. - Champs requis : senderId, destinationNumber (format international sans le signe plus), message, messageType (TEXT). - Réponse : 200 avec l'ID du message ; conservez-le pour faire le lien avec les accusés de réception. - Erreurs : un jeton manquant ou invalide renvoie une erreur 401 de la part de la passerelle ; les erreurs API renvoient le statut, l'erreur, le message, l'errorCode et le requestUri. - Une seule SDK officielle : @broadnet/cpaas-sdk pour TypeScript/Node.js ; générez des clients pour les autres langages à partir de la spécification OpenAPI. ## De quoi avez-vous besoin avant l'envoi ? - Un jeton d'accès provenant de votre compte BroadNet, conservé dans une variable d'environnement (BROADNET_TOKEN ci-dessous), et jamais dans le code source ou une application mobile. - Un identifiant d'expéditeur autorisé pour le pays de destination ; certains pays exigent une inscription préalable. - Un numéro de destination au format international, par exemple 447700900123 (un numéro fictif du Royaume-Uni). L'accès de test est fourni par nos ingénieurs : demandez-le et vous recevrez vos identifiants de test sous un jour ouvré, et le premier message de test est généralement envoyé environ cinq minutes après. Le [quickstart](https://www.broadnet.me/developers/quickstart) vous guide pas à pas. ## À quoi ressemble la requête ? Voici la requête avec cURL. Chaque exemple ci-dessous envoie le même corps JSON. ``` curl -X POST https://api.broadnet.me/sms/sendSms \ -H "Authorization: Bearer $BROADNET_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "senderId": "BroadNet", "destinationNumber": "447700900123", "message": "Your verification code is 482913", "messageType": "TEXT" }' # 200 OK → response body is the message ID, e.g. 2603121407537573731 ``` ## Comment envoyer un SMS avec Python ? Avec la bibliothèque requests, l'argument json= configure automatiquement l'en-tête Content-Type pour vous. ``` import os, requests r = requests.post( "https://api.broadnet.me/sms/sendSms", headers={"Authorization": f"Bearer {os.environ['BROADNET_TOKEN']}"}, json={ "senderId": "BroadNet", "destinationNumber": "447700900123", "message": "Your verification code is 482913", "messageType": "TEXT", }, ) print(r.status_code, r.text) # message ID ``` ## Comment envoyer un SMS avec PHP ? L'extension curl de PHP est suffisante ; aucun package n'est nécessaire. ``` true, CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => [ "Authorization: Bearer " . getenv("BROADNET_TOKEN"), "Content-Type: application/json", ], CURLOPT_POSTFIELDS => json_encode([ "senderId" => "BroadNet", "destinationNumber" => "447700900123", "message" => "Your verification code is 482913", "messageType" => "TEXT", ]), ]); $messageId = curl_exec($ch); echo $messageId; ``` ## Comment envoyer un SMS avec Node.js ? Node.js 18 et versions ultérieures incluent fetch nativement : ``` // Node.js 18+ (fetch) const res = await fetch("https://api.broadnet.me/sms/sendSms", { method: "POST", headers: { Authorization: `Bearer ${process.env.BROADNET_TOKEN}`, "Content-Type": "application/json", }, body: JSON.stringify({ senderId: "BroadNet", destinationNumber: "447700900123", message: "Your verification code is 482913", messageType: "TEXT", }), }); console.log(await res.text()); // message ID ``` Ou utilisez l'officiel TypeScript/Node.js SDK, @broadnet/cpaas-sdk : ``` // npm install @broadnet/cpaas-sdk axios import { Configuration, SMSSMSApi } from "@broadnet/cpaas-sdk"; const sms = new SMSSMSApi( new Configuration({ basePath: "https://api.broadnet.me", accessToken: process.env.BROADNET_TOKEN!, }), ); const res = await sms.smsSendsmsPost({ sMSSmsRequest: { senderId: "BroadNet", destinationNumber: "447700900123", message: "Your verification code is 482913", messageType: "TEXT", }, }); console.log(res.data); // message ID ``` ## Comment envoyer un SMS avec Java ? Java 11 et versions ultérieures incluent java.net.http.HttpClient : ``` // Java 11+ — java.net.http is built in, nothing to install import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; public class SendSms { public static void main(String[] args) throws Exception { String json = "{" + "\"senderId\": \"BroadNet\", " + "\"destinationNumber\": \"447700900123\", " + "\"message\": \"Your verification code is 482913\", " + "\"messageType\": \"TEXT\"" + "}"; HttpRequest req = HttpRequest.newBuilder(URI.create("https://api.broadnet.me/sms/sendSms")) .header("Authorization", "Bearer " + System.getenv("BROADNET_TOKEN")) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(json)) .build(); HttpResponse res = HttpClient.newHttpClient() .send(req, HttpResponse.BodyHandlers.ofString()); System.out.println(res.statusCode() + " " + res.body()); // 200 + message ID } } ``` ## Comment envoyer un SMS avec Go ? ``` package main import ( "bytes" "fmt" "io" "net/http" "os" ) func main() { body := []byte(`{ "senderId": "BroadNet", "destinationNumber": "447700900123", "message": "Your verification code is 482913", "messageType": "TEXT" }`) req, err := http.NewRequest(http.MethodPost, "https://api.broadnet.me/sms/sendSms", bytes.NewReader(body)) if err != nil { panic(err) } req.Header.Set("Authorization", "Bearer "+os.Getenv("BROADNET_TOKEN")) req.Header.Set("Content-Type", "application/json") res, err := http.DefaultClient.Do(req) if err != nil { panic(err) } defer res.Body.Close() id, _ := io.ReadAll(res.Body) fmt.Println(res.StatusCode, string(id)) // 200 + message ID } ``` ## Comment envoyer un SMS avec C# et .NET ? .NET 6 et versions ultérieures ne nécessitent aucun package NuGet : HttpClient et System.Net.Http.Json sont intégrés. ``` // .NET 6+ console app (Program.cs) — HttpClient is built in, no NuGet package using System; using System.Net.Http; using System.Net.Http.Headers; using System.Net.Http.Json; using var http = new HttpClient(); http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue( "Bearer", Environment.GetEnvironmentVariable("BROADNET_TOKEN")); // PostAsJsonAsync sends Content-Type: application/json var res = await http.PostAsJsonAsync("https://api.broadnet.me/sms/sendSms", new { senderId = "BroadNet", destinationNumber = "447700900123", message = "Your verification code is 482913", messageType = "TEXT", }); var id = await res.Content.ReadAsStringAsync(); Console.WriteLine($"{(int)res.StatusCode} {id}"); // 200 + message ID ``` ## Quel est le retour et comment gérer les erreurs ? | Réponse | Signification | Action à entreprendre | |---|---|---| | 200 + identifiant de message | Accepté pour la livraison | Conservez l'identifiant avec votre propre enregistrement ; attendez le DLR | | 400 | Erreur de validation ou champ manquant | Corrigez la requête ; ne réessayez pas sans modification | | 401 | Jeton Bearer manquant ou invalide | Vérifiez le jeton et l'en-tête Authorization | | 500 | Erreur serveur inattendue | Réessayez avec un délai progressif ; vérifiez le statut du message avant de le renvoyer | Un code 200 signifie que la plateforme a accepté le message, pas que le terminal l'a reçu. La livraison est signalée par l'accusé de réception ; consultez [ce qu'est un DLR](https://www.broadnet.me/answers/what-is-dlr) et [les accusés de réception SMS et les codes d'erreur](https://www.broadnet.me/blog/sms-delivery-receipts-dlr-error-codes). La API ne possède pas d'en-tête d'idempotence, conservez donc l'identifiant de message renvoyé et vérifiez son statut avant de le renvoyer pour éviter les doublons. La page des [codes d'erreur](https://www.broadnet.me/developers/error-codes) répertorie les autres. ## Comment le rendre prêt pour la production ? - Conservez le jeton côté serveur. N'appelez jamais l'SMS API depuis un navigateur ou une application mobile, où le jeton pourrait être extrait ; appelez plutôt votre propre backend. - Envoyez des messages longs en toute connaissance de cause : l'GSM-7 permet 160 caractères par SMS, 70 pour l'Unicode (UCS-2), et les textes plus longs sont divisés en segments facturés. Consultez [la limite de caractères SMS](https://www.broadnet.me/answers/sms-character-limit-explained). - Mettez les envois en masse en file d'attente et respectez le débit de votre compte ; consultez les [limites de débit](https://www.broadnet.me/developers/rate-limits). - Recevez les accusés de réception via un [webhook](https://www.broadnet.me/developers/webhooks) et enregistrez le statut final. - Validez d'abord les numéros au format international ; consultez la [validation du numéro de téléphone E.164](https://www.broadnet.me/blog/e164-phone-number-validation-msisdn). Pour des volumes très élevés ou une infrastructure télécom existante, SMPP peut être plus adapté que REST ; consultez [SMPP vs REST](https://www.broadnet.me/compare/sms-api-vs-smpp). La plateforme de BroadNet gère 30 000 SMS par seconde et par nœud. ## Foire aux questions ### Quel est le moyen le plus simple d'envoyer un SMS via du code ? Un seul HTTPS POST vers une SMS API avec un jeton d'accès et un corps JSON. Avec BroadNet, il s'agit d'un POST https://api.broadnet.me/sms/sendSms incluant senderId, destinationNumber, le message et messageType. ### Existe-t-il un BroadNet SDK pour Python, PHP ou Java ? Non. Il existe un seul SDK @broadnet/cpaas-sdk officiel pour TypeScript et Node.js. Les autres langages appellent directement la REST API, comme illustré ici, ou génèrent un client à partir de la spécification OpenAPI. ### Quel doit être le format du numéro de téléphone ? Format international avec le code pays, sans signe plus ni espaces, par exemple 447700900123. ### Une réponse 200 signifie-t-elle que le SMS a été livré ? Non. Cela signifie que le message a été accepté. L'accusé de réception (DLR) indique s'il est bien parvenu au terminal. ### Puis-je envoyer SMS directement depuis une application Android ou iOS ? Pas de manière sécurisée. Effectuez l'appel API depuis votre serveur afin que le jeton d'accès ne soit jamais transmis via l'application, puis faites en sorte que l'application appelle votre serveur. ### Où trouver la référence complète de l'API ? Dans la [référence API](https://www.broadnet.me/developers/api-reference) et la [spécification OpenAPI](https://www.broadnet.me/developers/openapi). Les exemples de code sont ceux présents sur nos pages développeurs, vérifiés par rapport à la spécification OpenAPI publiée. Révisé le 28 septembre 2026. Consultez nos [normes éditoriales](https://www.broadnet.me/about/editorial-standards).