er inviare un SMS tramite codice, effettuare una POST HTTPS verso https://api.broadnet.me/sms/sendSms con un header Authorization: Bearer e un body JSON contenente senderId, destinationNumber, il messaggio e messageType. Una chiamata riuscita restituisce HTTP 200 con l'ID messaggio nel corpo della risposta; il risultato della consegna arriverà successivamente come ricevuta di consegna (DLR) al vostro webhook. Ogni linguaggio sottostante utilizza solo la propria libreria HTTP standard; l'unica SDK ufficiale è per TypeScript e Node.js.
Punti chiave
- Endpoint: POST https://api.broadnet.me/sms/sendSms, body JSON, token Bearer.
- Campi obbligatori: senderId, destinationNumber (formato internazionale senza il segno più), messaggio, messageType (TEXT).
- Risposta: 200 con l'ID messaggio; conservatelo per riconciliare le ricevute di consegna.
- Errori: un token mancante o non valido restituisce un 401 dal gateway; gli errori API restituiscono status, error, message, errorCode e requestUri.
- Un unico SDK ufficiale: @broadnet/cpaas-sdk per TypeScript/Node.js; generare i client per gli altri linguaggi partendo dalla specifica OpenAPI.
Cosa serve prima di procedere con l'invio?
- Un token di accesso del tuo account BroadNet, da conservare in una variabile d'ambiente (BROADNET_TOKEN qui sotto) e mai nel codice sorgente o in un'app mobile.
- Un ID mittente autorizzato per il paese di destinazione; alcuni paesi richiedono una registrazione preventiva.
- Un numero di destinazione in formato internazionale, ad esempio 447700900123 (un numero fittizio del Regno Unito).
L'accesso per i test viene fornito dai nostri ingegneri: richiedilo e riceverai le credenziali di test entro un giorno lavorativo; solitamente il primo messaggio di prova viene inviato circa cinque minuti dopo. La guida rapida spiega come procedere.
Com'è strutturata la richiesta?
Ecco la richiesta con cURL. Ogni esempio qui sotto invia lo stesso corpo 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. 2603121407537573731Come si invia un SMS con Python?
Utilizzando la libreria requests, l'argomento json= imposta automaticamente l'header Content-Type.
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 IDCome si invia un SMS con PHP?
L'estensione curl di PHP è sufficiente; non è necessario alcun pacchetto aggiuntivo.
<?php$ch = curl_init("https://api.broadnet.me/sms/sendSms");curl_setopt_array($ch, [ CURLOPT_POST => 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;Come si invia un SMS con Node.js?
Node.js 18 e versioni successive hanno fetch integrato:
// 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 IDOppure utilizza l'ufficiale SDK TypeScript/Node.js, @broadnet/cpaas-sdk:
// npm install @broadnet/cpaas-sdk axiosimport { 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 IDCome si invia un SMS con Java?
Java 11 e versioni successive includono java.net.http.HttpClient:
// Java 11+ — java.net.http is built in, nothing to installimport 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<String> res = HttpClient.newHttpClient() .send(req, HttpResponse.BodyHandlers.ofString()); System.out.println(res.statusCode() + " " + res.body()); // 200 + message ID }}Come si invia un SMS con 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}Come si invia un SMS con C# e .NET?
.NET 6 e versioni successive non richiedono pacchetti NuGet: HttpClient e System.Net.Http.Json sono integrati.
// .NET 6+ console app (Program.cs) — HttpClient is built in, no NuGet packageusing 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/jsonvar 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 IDCosa viene restituito e come si gestiscono gli errori?
| Risposta | Significato | Cosa fare |
|---|---|---|
| 200 + ID messaggio | Accettato per la consegna | Salvare l'ID con il proprio record; attendere il DLR |
| 400 | Errore di validazione o campo mancante | Correggere la richiesta; non riprovare senza modifiche |
| 401 | Token Bearer mancante o non valido | Controllare il token e l'header Authorization |
| 500 | Errore server imprevisto | Riprovare con backoff; controllare lo stato del messaggio prima di reinviare |
Un codice 200 indica che la piattaforma ha accettato il messaggio, non che sia stato ricevuto dal dispositivo. La consegna è confermata dalla delivery receipt; consultare cos'è una DLR e le delivery receipt e i codici di errore SMS. La API non dispone di un header di idempotenza, pertanto è necessario conservare l'ID del messaggio restituito e verificarne lo stato prima di un eventuale nuovo invio, per evitare duplicati. La pagina dei codici di errore elenca tutti gli altri.
Come si prepara l'integrazione per la produzione?
- Conservare il token lato server. Non chiamare mai la API SMS da un browser o da un'app mobile, dove il token potrebbe essere estratto; utilizzare invece il proprio backend.
- Gestione messaggi lunghi: la GSM-7 prevede 160 caratteri per SMS, 70 per Unicode (UCS-2), e i testi più lunghi vengono suddivisi in segmenti fatturabili. Consultare il limite di caratteri SMS.
- Mettere in coda gli invii massivi e rispettare la capacità di throughput del proprio account; consultare i limiti di frequenza.
- Ricevere le delivery receipt tramite un webhook e memorizzare lo stato finale.
- Validare prima i numeri in formato internazionale; consultare la validazione del numero di telefono E.164.
Per volumi molto elevati o per un'infrastruttura telecom esistente, SMPP potrebbe essere più adatto rispetto a REST; consultare SMPP vs REST. La piattaforma di BroadNet gestisce 30.000 SMS al secondo per nodo.
Domande frequenti
Qual è il modo più semplice per inviare un SMS tramite codice?
Una singola richiesta POST HTTPS a un SMS API con un token di accesso e un corpo JSON. Con BroadNet si tratta di una POST https://api.broadnet.me/sms/sendSms con senderId, destinationNumber, il messaggio e messageType.
Esiste un BroadNet SDK per Python, PHP o Java?
No. Esiste un unico SDK @broadnet/cpaas-sdk ufficiale per TypeScript e Node.js. Altri linguaggi chiamano direttamente l'REST API, come mostrato qui, o generano un client dalla specifica OpenAPI.
In quale formato deve essere il numero di telefono?
Formato internazionale con il prefisso del paese, senza segno più o spazi, ad esempio 447700900123.
Una risposta 200 significa che l'SMS è stato consegnato?
No. Significa che il messaggio è stato accettato. La ricevuta di consegna (DLR) indica se il messaggio è stato consegnato al dispositivo.
Posso inviare SMS direttamente da un'app Android o iOS?
Non in modo sicuro. Sposta la chiamata API sul tuo server, in modo che l'access token non venga mai inviato all'interno dell'app, e fai in modo che l'app richiami il tuo server.
Dove posso trovare il riferimento completo dell'API?
Nel riferimento API e nello spec OpenAPI.
Gli esempi di codice sono quelli presenti sulle nostre pagine per sviluppatori, verificati rispetto allo spec OpenAPI pubblicato. Revisionato il 28 settembre 2026. Consulta i nostri standard editoriali.
