BroadNet
Il giornaleIngegneria
Ingegneria

Come inviare SMS tramite codice: Python, PHP, Node.js, Java, Go e C# con una singola chiamata REST

Inviare un SMS tramite codice consiste in un'unica richiesta POST HTTPS autenticata: un token Bearer, un body JSON con ID mittente, numero di destinazione, messaggio e tipo di messaggio, e un ID messaggio in risposta. Ecco la stessa richiesta in Python, PHP, Node.js, Java, Go e C#, oltre alla gestione degli errori e ai consigli per la produzione.

9 min di lettura
Ingegneria · Numero 28
9 min di lettura

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.

snippet
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

Come si invia un SMS con Python?

Utilizzando la libreria requests, l'argomento json= imposta automaticamente l'header Content-Type.

snippet
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

Come si invia un SMS con PHP?

L'estensione curl di PHP è sufficiente; non è necessario alcun pacchetto aggiuntivo.

snippet
<?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:

snippet
// 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

Oppure utilizza l'ufficiale SDK TypeScript/Node.js, @broadnet/cpaas-sdk:

snippet
// 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

Come si invia un SMS con Java?

Java 11 e versioni successive includono java.net.http.HttpClient:

snippet
// 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<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?

snippet
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.

snippet
// .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

Cosa viene restituito e come si gestiscono gli errori?

RispostaSignificatoCosa fare
200 + ID messaggioAccettato per la consegnaSalvare l'ID con il proprio record; attendere il DLR
400Errore di validazione o campo mancanteCorreggere la richiesta; non riprovare senza modifiche
401Token Bearer mancante o non validoControllare il token e l'header Authorization
500Errore server imprevistoRiprovare 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.

È stato utile?

Come scriviamo e revisioniamo i contenuti

Scritto da

Team editoriale di BroadNet

Il team editoriale pubblica il blog di BroadNet. Gli articoli sono scritti con i team BroadNet di affari regolatori, prodotto, ingegneria, ricerche di settore e soluzioni per gli operatori, e rivisti secondo i nostri standard editoriali.

La rivista, via e-mail

Un saggio al mese. Nient'altro.

Iscriviti e ti invieremo il prossimo articolo – su ingegneria, regolamentazione o industria – il giorno stesso della sua pubblicazione. Nessuna campagna di email marketing, nessuna presentazione di prodotti, nessuna condivisione con terze parti. Puoi disiscriverti con un solo clic.

Inviamo un'email al mese. Puoi disiscriverti in qualsiasi momento. Consulta la nostra informativa sulla privacy.

Cosa otterrai
  • Articolo di lunga durata, non un semplice titolo acchiappa-link.
    Da sei a undici minuti di scrittura mirata su un singolo argomento.
  • Scritto dagli operatori
    Ingegneri, responsabili degli aspetti normativi e redattori di prodotto interni.
  • Consapevole della regione
    Una prospettiva basata sulla regione MENA in merito a regolatori, operatori e mix di canali.
  • Una volta al mese
    Niente campagne a goccia. Un solo saggio quando ce n'è uno da condividere.
Smetti di leggere. Inizia a spedire.

Gran parte di ciò che scriviamo l'abbiamo imparato durante la produzione.

Se questo articolo ti ha fatto annuire, probabilmente dovremmo parlarne. Descrivi il caso d'uso, i volumi, i mercati: ti forniremo informazioni su come procedere, sui prezzi e su un cliente di riferimento che potrai contattare.

$ curl -X POST https://api.broadnet.me/sms/sendSms