# Cara mengirim SMS melalui kode: Python, PHP, Node.js, Java, Go dan C# dengan satu panggilan REST

> Mengirim SMS melalui kode hanya memerlukan satu HTTPS POST terautentikasi: token Bearer, body JSON yang berisi sender ID, nomor tujuan, pesan, dan tipe pesan, serta pengembalian ID pesan. Berikut adalah permintaan yang sama dalam Python, PHP, Node.js, Java, Go dan C#, lengkap dengan penanganan kesalahan dan saran produksi.

- URL kanonis: https://www.broadnet.me/id/blog/send-sms-api-python-php-nodejs-java-csharp
- Bahasa: id
- Terakhir diperbarui: 2026-09-28
- Penerbit: BroadNet (https://www.broadnet.me)

- Diterbitkan: 2026-09-28
- Penulis: BroadNet Editorial Team

Untuk mengirim SMS dari kode, lakukan satu HTTPS POST ke https://api.broadnet.me/sms/sendSms dengan header Authorization: Bearer dan body JSON yang berisi senderId, destinationNumber, pesan, dan messageType. Panggilan yang berhasil mengembalikan HTTP 200 dengan ID pesan sebagai body respons; hasil pengiriman akan tiba kemudian sebagai laporan pengiriman (DLR) ke webhook Anda. Setiap bahasa di bawah ini hanya menggunakan pustaka HTTP standarnya; satu-satunya SDK resmi adalah untuk TypeScript dan Node.js.

## Poin penting

- Endpoint: POST https://api.broadnet.me/sms/sendSms, body JSON, token Bearer.
- Field wajib: senderId, destinationNumber (format internasional tanpa tanda plus), pesan, messageType (TEXT).
- Respons: 200 dengan ID pesan; simpan ID tersebut untuk mencocokkan laporan pengiriman.
- Kesalahan: token yang hilang atau tidak valid akan menerima 401 dari gateway; kesalahan API mengembalikan status, error, message, errorCode, dan requestUri.
- Satu SDK resmi: @broadnet/cpaas-sdk untuk TypeScript/Node.js; buat klien untuk bahasa lain dari spesifikasi OpenAPI.

## Apa yang Anda butuhkan sebelum mengirim?

- Token akses dari akun BroadNet Anda, simpan dalam variabel lingkungan (BROADNET_TOKEN di bawah), jangan pernah simpan di kode sumber atau aplikasi seluler.
- Sender ID yang diizinkan untuk negara tujuan; beberapa negara memerlukan registrasi terlebih dahulu.
- Nomor tujuan dalam format internasional, contohnya 447700900123 (nomor Inggris fiktif).

Akses uji coba diberikan oleh teknisi kami: minta aksesnya dan Anda akan mendapatkan kredensial uji coba dalam satu hari kerja, dan pesan uji coba pertama biasanya terkirim sekitar lima menit setelah itu. [Panduan cepat](https://www.broadnet.me/developers/quickstart) akan memandu Anda.

## Seperti apa bentuk permintaannya?

Berikut adalah permintaan dengan cURL. Setiap contoh di bawah ini mengirimkan bodi JSON yang sama.

```
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
```

## Bagaimana cara mengirim SMS dengan Python?

Dengan pustaka requests, argumen json= akan mengatur header Content-Type untuk Anda.

```
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
```

## Bagaimana cara mengirim SMS dengan PHP?

Ekstensi curl milik PHP sudah cukup; tidak memerlukan paket tambahan.

```
<?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;
```

## Bagaimana cara mengirim SMS dengan Node.js?

Node.js 18 dan versi setelahnya sudah memiliki fetch bawaan:

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

Atau gunakan SDK TypeScript/Node.js resmi, @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
```

## Bagaimana cara mengirim SMS dengan Java?

Java 11 dan versi setelahnya mencakup 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<String> res = HttpClient.newHttpClient()
            .send(req, HttpResponse.BodyHandlers.ofString());

        System.out.println(res.statusCode() + " " + res.body()); // 200 + message ID
    }
}
```

## Bagaimana cara mengirim SMS dengan 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
}
```

## Bagaimana cara mengirim SMS dengan C# dan .NET?

.NET 6 dan versi setelahnya tidak memerlukan paket NuGet: HttpClient dan System.Net.Http.Json sudah terintegrasi.

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

## Apa yang dikembalikan, dan bagaimana cara menangani kesalahan?

| Respons | Arti | Tindakan yang harus dilakukan |
|---|---|---|
| 200 + ID pesan | Diterima untuk pengiriman | Simpan ID tersebut bersama catatan Anda; tunggu DLR |
| 400 | Kesalahan validasi atau kolom tidak lengkap | Perbaiki permintaan; jangan mencoba kembali tanpa perubahan |
| 401 | Token Bearer hilang atau tidak valid | Periksa token dan header Authorization |
| 500 | Kesalahan server yang tidak terduga | Coba lagi dengan backoff; periksa status pesan sebelum mengirim ulang |

Kode 200 berarti platform telah menerima pesan, bukan berarti perangkat telah menerimanya. Pengiriman dilaporkan melalui laporan pengiriman; lihat [apa itu DLR](https://www.broadnet.me/answers/what-is-dlr) dan [laporan pengiriman SMS serta kode kesalahan](https://www.broadnet.me/blog/sms-delivery-receipts-dlr-error-codes). API tidak memiliki header idempotensi, jadi simpan ID pesan yang dikembalikan dan periksa statusnya sebelum mengirim ulang untuk menghindari duplikasi. Halaman [kode kesalahan](https://www.broadnet.me/developers/error-codes) mencantumkan sisanya.

## Bagaimana cara membuatnya siap untuk produksi?

- Simpan token di sisi server. Jangan pernah memanggil SMS API dari browser atau aplikasi seluler, di mana token dapat diekstraksi; sebaliknya, panggillah backend Anda sendiri.
- Kirim pesan panjang dengan penuh kesadaran: GSM-7 menampung 160 karakter per SMS, Unicode (UCS-2) 70, dan teks yang lebih panjang akan dipecah menjadi segmen yang ditagih. Lihat [batas karakter SMS](https://www.broadnet.me/answers/sms-character-limit-explained).
- Antrekan pengiriman massal dan patuhi throughput akun Anda; baca [batas kecepatan](https://www.broadnet.me/developers/rate-limits).
- Terima laporan pengiriman melalui [webhook](https://www.broadnet.me/developers/webhooks) dan simpan status akhirnya.
- Validasi nomor ke format internasional terlebih dahulu; lihat [validasi nomor telepon E.164](https://www.broadnet.me/blog/e164-phone-number-validation-msisdn).

Untuk volume yang sangat tinggi atau tumpukan teknologi telekomunikasi yang sudah ada, SMPP mungkin lebih cocok daripada REST; lihat [SMPP vs REST](https://www.broadnet.me/compare/sms-api-vs-smpp). Platform BroadNet menangani 30.000 SMS per detik per node.

## Pertanyaan yang sering diajukan

### Apa cara termudah untuk mengirim SMS melalui kode?

Satu HTTPS POST ke SMS API dengan token akses dan body JSON. Dengan BroadNet, itu adalah POST https://api.broadnet.me/sms/sendSms dengan senderId, destinationNumber, message, dan messageType.

### Apakah tersedia BroadNet SDK untuk Python, PHP, atau Java?

Tidak. Hanya ada satu SDK resmi, @broadnet/cpaas-sdk untuk TypeScript dan Node.js. Bahasa lain memanggil REST API secara langsung, seperti yang ditunjukkan di sini, atau membuat klien dari spesifikasi OpenAPI.

### Format apa yang harus digunakan untuk nomor telepon?

Format internasional dengan kode negara tanpa tanda plus atau spasi, contohnya 447700900123.

### Apakah respons 200 berarti SMS telah terkirim?

Tidak. Itu berarti pesan telah diterima. Laporan pengiriman (DLR) melaporkan apakah pesan tersebut telah sampai ke perangkat genggam.

### Bisakah saya mengirim SMS secara langsung dari aplikasi Android atau iOS?

Tidak secara aman. Letakkan panggilan API di server Anda agar token akses tidak pernah dikirim di dalam aplikasi, dan biarkan aplikasi memanggil server Anda.

### Di mana saya dapat menemukan referensi API lengkap?

Dalam [referensi API](https://www.broadnet.me/developers/api-reference) dan [spesifikasi OpenAPI](https://www.broadnet.me/developers/openapi).

Sampel kode adalah yang tersedia di halaman pengembang kami, yang telah diperiksa terhadap spesifikasi OpenAPI yang dipublikasikan. Ditinjau pada 28 September 2026. Lihat [standar editorial kami](https://www.broadnet.me/about/editorial-standards).
