Send your first test SMS five minutes after you get credentials.
Request test access and we reply within one business day with your test credentials. Then take the token, install the TypeScript SDK and call smsSendsmsPost. Your first test message reaches your own verified number about five minutes after you have credentials. Every sample below is ready to copy, and step 5 covers what to check before production.
One path to your first message, with the clock on every step.
- 01
Request test access
Reply within 1 business dayA messaging engineer replies with your test credentials and books a 30-minute call on your countries, volumes and use case.
- 02
First test message
About 5 minutes after credentialsSend a test message to your own verified number with the quickstart code. The delivery receipt comes back to your webhook.
- 03
Integration
2–5 business daysBuild and test with your test credentials against the same endpoint as the code samples. A BroadNet engineer pairs with you on REST or SMPP.
- 04
Approval
3–10 business daysSender identity, traffic purpose and destination rules are reviewed, and sender IDs are registered with each regulator, in parallel with your integration.
- 05
Production
Cutover dayProduction access and routes are switched on for your account. Your integration already calls https://api.broadnet.me.
Overall: 5–15 business days from request to production for most markets; longer where a regulator's sender-ID lead time is longer.
- Your applicationSends over the REST API or SMPP
- BroadNet platformValidates, routes and bills each message
- Operator SMSCDirect operator connection
- Subscriber handsetThe message is delivered
Get your access token.
Your access token comes with your test credentials: request test access and we reply within one business day. Store it in the BROADNET_TOKEN environment variable and send it in an Authorization: Bearer header on every call. Every sample on this page uses the production base URL, https://api.broadnet.me.
Send a test SMS to your own verified number with POST /sms/sendSms. A 200 OK whose body is a message ID confirms the token works before you write any other code.
Install the SDK.
BroadNet has one official SDK, for TypeScript and Node.js: npm install @broadnet/cpaas-sdk axios. It is generated from the BroadNet OpenAPI specification. In any other language, call the REST API with your usual HTTP library, or generate a client from the OpenAPI spec.
npm install @broadnet/cpaas-sdk axios
export BROADNET_TOKEN=your_access_tokenImport Configuration and SMSSMSApi from @broadnet/cpaas-sdk. If the import resolves and type-checks, you're ready to send.
Send your first message.
Create an SMSSMSApi with your base URL and token, call smsSendsmsPost with senderId, destinationNumber, message and messageType, and log the result. The response body is the message ID; keep it to match delivery status later.
// 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 IDHTTP/1.1 200 OK
2603121407537573731Check the phone in your hand. If you got the SMS, you're done with the hard part — everything below is operational polish.
Receive delivery status.
BroadNet pushes delivery status to the webhook URL configured on your account: SUBMITTED, SENT, DELIVERED, READ on channels that report reads, or FAILED and REJECTED. Store each update, reply with a 2xx quickly, and process it asynchronously.
import express from "express";
const app = express();
app.post("/webhooks/broadnet", express.json(), async (req, res) => {
// Store the status update first, then acknowledge with a 2xx.
// Statuses: SUBMITTED, SENT, DELIVERED, READ, FAILED, REJECTED.
await db.statusUpdates.insert({ receivedAt: new Date(), body: req.body });
res.sendStatus(200);
});Confirmed on the handset. Earlier updates, SUBMITTED and SENT, arrive as the message moves through the network.
Opened by the recipient, on channels that report reads, such as WhatsApp.
Not delivered. Check the number format and your sender ID before you send again.
Send a message to your phone, then check your server log for the DELIVERED status update.
Before production.
Production opens once approval is done: sender identity, traffic purpose and sender IDs, 3–10 business days, in parallel with your integration. Once approved, the same code sends production traffic. Before that, keep the token out of source control, wire up delivery-status webhooks and decide your retry policy.
- 01Move secrets to your environment
Keep BROADNET_TOKEN in an environment variable or your secrets manager, never in source control or client-side code. Replace it immediately if it ever leaks.
- 02Retry safely and watch your balance
Retry network errors and 5xx responses with exponential backoff. Every accepted send returns a message ID, so store it and check delivery status rather than re-sending blindly. Bulk sends report your remaining credits in every response.
- 03Pin the SDK version
Pin @broadnet/cpaas-sdk to an exact version in package.json and upgrade deliberately. API paths carry no version prefix, so follow changes in the changelog and the OpenAPI spec.
- 04Handle errors by status code
Errors return an HTTP status code and an ExceptionResponse body with status, error, message, errorCode and requestUri. Fix 400 and 401 errors; retry 5xx errors with backoff.
- 05Decide your retry policy
Default: exponential backoff on 5xx and network errors, never on 4xx. After a timeout, check delivery status before you resend, because the first request may already have been accepted.
Run the checklist below against your code. When every box is ticked, your integration is ready for production as soon as approval is done.
The same code paths handle 300M+ messages a day.
Your test traffic isn't a mock. Every request, key, and webhook you wired up in the steps above runs through the same routing, billing, and compliance stack that carries our enterprise traffic — audited annually under the certifications below.
Quickstart questions
Send POST https://api.broadnet.me/sms/sendSms with an Authorization: Bearer header and a JSON body of senderId, destinationNumber, message and messageType (TEXT or UNICODE). The response is the message ID. The legacy HTTP API under /websmpp is still available for SMPP-era integrations.
Request test access at /signup, and a BroadNet engineer replies within one business day with your test credentials: the access token you send in an Authorization: Bearer header, and where to send test traffic. Your first test message can go out about five minutes after you receive them.
One official SDK: @broadnet/cpaas-sdk for TypeScript and Node.js, on npm. In any other language, call the REST API directly over HTTPS, or generate a client from the OpenAPI spec (/developers/openapi.yaml).
Question not here? Ask our engineering team
Five steps down.
One key to go.
Test against your own verified numbers, ship the integration, then promote to live traffic from the same console. Same SDK, same endpoints, same SLAs that carry 300M+ messages a day.