# Messaging and voice for AI agents.

- Canonical URL: https://www.broadnet.me/developers/ai-agents
- Language: en
- Last updated: 2026-10-21
- Publisher: BroadNet (https://www.broadnet.me)
- Markdown version of the page above, generated from the rendered page.

For AI agents· /developers/ai-agents

Give an AI agent a safe way to look up coverage, rules and prices, and to send SMS, WhatsApp and one-time passcodes on your BroadNet account. Use whichever surface fits your stack: two MCP servers, the REST API, the TypeScript SDK or plain machine-readable files.

[Request test access](https://www.broadnet.me/signup) Copy the MCP config

## Pick the way in

Agents usually need two things: facts to plan with, and a way to act. BroadNet keeps them apart. The knowledge server answers questions without an account; sending always needs your token.

Knowledge MCP server

Public, read-only answers from the same data as this website: coverage, sender-ID rules, indicative list prices, regulations, segment counts, answers, case studies, the changelog and status.

https://www.broadnet.me/mcp

**Authentication:**

None

**Access:**

Read-only · 13 tools, 60 requests per minute per IP

**Best for:**

Planning, research and pre-sales questions, before any account exists.

Messaging MCP server

The BroadNet messaging API exposed as MCP tools. The agent sends and tracks messages with the permissions of the token you give it.

https://mcp.broadnet.me/mcp

**Authentication:**

Bearer <token>

**Access:**

Acts on your account

**Best for:**

Assistants and agents that send on a user's request, with a person confirming each send.

REST API

Bearer-token REST, one path family per channel, described by an OpenAPI 3.1 spec. Your agent decides; your code makes the call.

https://api.broadnet.me

**Authentication:**

Bearer <token>

**Access:**

Your code calls the API · OpenAPI 3.1

**Best for:**

Production agents where your backend owns retries, logging and limits.

TypeScript SDK

The one official SDK, @broadnet/cpaas-sdk, generated from the OpenAPI spec. Other languages call the REST API or generate a client.

npm i @broadnet/cpaas-sdk

**Authentication:**

Bearer <token>

**Access:**

Your code calls the API · TypeScript / Node.js

**Best for:**

Node.js agent frameworks and tool definitions with full types.

## What an agent can send

The same rules apply whichever surface the agent uses: a registered sender, a consented recipient and content that fits the channel.

SMS

One message per request, or a bulk job from a file. Billing is per segment, so long or non-Latin texts cost more: count them first.

**REST API**

`POST /sms/sendSms` (JSON) `POST /sms/sendbulk` (multipart)

**Messaging MCP**

SMS send tools, for example `post_sms_send`

WhatsApp

Free-form messages inside the 24-hour service window; outside it, only approved templates. Templates are listed and sent by name.

**REST API**

`POST /whatsapp/message/sendbulk` (multipart)

**Messaging MCP**

`post_whatsapp_message_send` `get_whatsapp_template_list` `post_whatsapp_template_send`

OTP

Your system generates the code; the agent sends it in an SMS or a WhatsApp authentication template. The public API has no separate verify endpoint, so checking the code stays in your system.

**REST API**

`POST /sms/sendSms` with the code in the message

**Messaging MCP**

The same SMS and WhatsApp template tools

Voice

Voice OTP, text-to-speech callouts and IVR are provisioned through your account team. The public OpenAPI spec and the MCP tools cover the messaging channels, not voice calls. For AI-driven outbound calling, see DialerBee.

**REST API**

Provisioned per account

**Messaging MCP**

No voice tools

## A worked example: an agent plans an OTP launch

A user asks an agent to plan one-time passcodes to the UAE. The agent calls four tools on the public knowledge server. The results below are the server's real output, trimmed to the fields the agent uses.

User

We want to send about 50,000 login codes a month to customers in the UAE. What do we need, and what will it cost?

1. 1 Tool call `check_coverage` Is the UAE covered, on which operators? → `{"country":"UAE"}` Result (trimmed) `{ "country": "UAE", "regulator": "TDRA (Telecommunications and Digital Government Regulatory Authority)", "channels": { "sms": "Live", "otp": "Live", "whatsapp": "Live", "rcs": "Available", "voice": "Live" }, "operators": [ { "name": "Etisalat / e&", "status": "Direct" }, { "name": "du", "status": "Direct" }, { "name": "Virgin Mobile", "status": "Operator-grade" } ] }`
2. 2 Tool call `sender_id_rules` What does a sender ID need there? → `{"country":"ae"}` Result (trimmed) `{ "typicalLeadTime": "5-7 business days", "requirements": [ { "format": "Alphanumeric (Latin or Arabic), up to 11 chars. AD- prefix mandatory on promotional senders.", "preRegistration": "Required — one sender ID per legal entity per use case" } ], "marketingRules": { "quietHours": "TDRA's spam policy bars marketing text messages between 21:00 and 07:00 GST. Transactional OTP and alerts are 24/7." } }`
3. 3 Tool call `count_sms_segments` How many segments is the message? → `{"text":"Your MyShop code is 482913. It expires in 5 minutes. Never share it."}` Result (trimmed) `{ "encoding": "GSM-7", "units": 68, "segments": 1 }`
4. 4 Tool call `estimate_price` What is the indicative price? → `{"country":"UAE","channel":"sms","volume":50000}` Result (trimmed) `{ "country": "UAE", "unitPriceUsd": 0.0123, "unit": "per SMS segment", "estimatedMonthlyUsd": 615, "ratesReviewed": "2026-09-24", "note": "Indicative list rate, excluding taxes and sender-ID fees. Volume pricing available; a written quote confirms per-operator pricing." }`

Agent

The UAE is covered operator-direct (Etisalat / e& · du). Your sender ID needs pre-registration with the TDRA, typically 5–7 business days. Your code message is 1 SMS segment. At the indicative list rate of $0.0123 per segment, 50,000 codes come to about $615 a month, excluding taxes and sender-ID fees. This is not a quote.

Next step: request test access at broadnet.me/signup. Once you have a token, I can send one test code to your own verified number through the messaging server. Shall I prepare that message for you to confirm?

Built from the live tool output on every deploy

## Copy and paste

The examples use fictional numbers only. Read the token from an environment variable; never paste it into a chat or a committed file.

mcp.json — both servers

```
{
  "mcpServers": {
    "broadnet-knowledge": {
      "type": "http",
      "url": "https://www.broadnet.me/mcp"
    },
    "broadnet": {
      "type": "http",
      "url": "https://mcp.broadnet.me/mcp",
      "headers": {
        "Authorization": "Bearer ${BROADNET_TOKEN}"
      }
    }
  }
}
```

Field names vary slightly between clients (some expect "streamable-http" as the type, some read headers from a separate setting). Add only the knowledge entry if you have no token yet.

tools/call estimate_price (knowledge server)

```
curl -X POST https://www.broadnet.me/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2025-06-18" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call",
       "params":{"name":"estimate_price",
                 "arguments":{"country":"UAE","channel":"sms","volume":50000}}}'
```

send one SMS (REST API)

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

HTTP 200 returns the message ID. The API has no idempotency header: after a network error or a 5xx, check the message status by its ID before sending again.

the same send with the TypeScript 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
```

send an approved WhatsApp template (REST API)

```
# Send an approved WhatsApp template
curl -X POST https://api.broadnet.me/whatsapp/message/sendbulk \
  -H "Authorization: Bearer $BROADNET_TOKEN" \
  -F batchId=0 \
  -F campaignName=order-updates \
  -F destinationNo=447700900123 \
  -F messageType=TEMPLATE \
  -F templateName=order_update \
  -F templateLanguage=en_US \
  -F bodyTemplateVariables=INV-400

# 200 OK → the response carries the batchId; per-recipient status
# (SUBMITTED → SENT → DELIVERED → READ) arrives on your webhook.
```

Templates work outside the 24-hour service window; free-form text needs an open window.

## Machine-readable entry points

Agents that browse rather than connect can read everything from plain files. None of them need a login.

- [llms.txt `/llms.txt` The site index for language models, with a section on agent access and constraints, plus one file per language.](https://www.broadnet.me/llms.txt)
- [Agent skills `/.well-known/agent-skills/index.json` Five SKILL.md runbooks: coverage and price, sender-ID registration, a first test SMS, test access, and connecting to the MCP servers.](https://www.broadnet.me/.well-known/agent-skills/index.json)
- [A2A agent card `/.well-known/agent-card.json` An Agent2Agent card for the same read-only knowledge tools, served over JSON-RPC at /a2a.](https://www.broadnet.me/.well-known/agent-card.json)
- [API catalog `/.well-known/api-catalog` An RFC 9727 linkset pointing to the OpenAPI spec, the API docs, both MCP servers and the status page.](https://www.broadnet.me/.well-known/api-catalog)
- [MCP server card `/.well-known/mcp.json` The server card describing both MCP servers, their transport and authentication.](https://www.broadnet.me/.well-known/mcp.json)
- [OpenAPI 3.1 `/developers/openapi.yaml` The full REST API description: download it, or generate a typed client from it.](https://www.broadnet.me/developers/openapi.yaml)
- [Markdown twins `/pricing/sms/uae.md` Add .md to most page URLs, or send Accept: text/markdown, for a clean Markdown copy of the page.](https://www.broadnet.me/pricing/sms/uae.md)
- [Data files `/data/coverage.json` Coverage, published prices and regulations for every market as JSON (CSV for coverage and pricing).](https://www.broadnet.me/data/coverage.json)
- [Status JSON `/status/api/v2/summary.json` Measured reachability of the website, API gateway and both MCP endpoints, in the Statuspage v2 summary shape.](https://www.broadnet.me/status/api/v2/summary.json)

## Rules an agent must follow

An agent that sends messages acts for your brand with your credentials. Build these rules into its instructions and its tools.

- Consent before content Send marketing only to recipients who opted in, and keep the opt-in record. The sender_id_rules tool returns each market's opt-in rules.
- Honour opt-outs Promotional messages carry the market's opt-out keyword, such as STOP. An agent never messages a number that opted out.
- Registered sender IDs only Many markets require pre-registration of alphanumeric sender IDs. The agent uses the sender IDs approved on your account, never an invented one.
- Respect quiet hours Several markets bar marketing at night. sender_id_rules returns the sourced quiet hours; OTP and alerts are usually allowed around the clock.
- Guard OTP flows against pumping Bots can trigger OTP sends to numbers they profit from. Rate-limit code requests per number, IP and device, and block destinations you do not serve. MyOTP ships these protections on by default.
- A person confirms every send Have the client ask before any tool that sends, especially to many recipients, and enable only the tools the agent needs.
- Test on your own number With test credentials, send only to your own verified number. Examples and prompts use fictional numbers.
- Keep the token out of the chat The token is a send credential. Load it from an environment variable, never from a prompt, and revoke it if it leaks.

## Related

[MCP servers Both servers in detail: endpoints, authentication, client setup and the demo.](https://www.broadnet.me/developers/mcp) [Quickstart From test access to a first SMS with curl or the TypeScript SDK.](https://www.broadnet.me/developers/quickstart) [API reference Every channel's send endpoint, Bearer auth and the error format.](https://www.broadnet.me/developers/api) [Safe retries How to retry without sending a message twice.](https://www.broadnet.me/developers/idempotency) [SMS segment counter Encoding and segment count for any message text.](https://www.broadnet.me/developers/sms-counter) [BroadNet Inference Arabic speech-to-text and vision models for voice and document agents.](https://www.broadnet.me/products/inference) [DialerBee Multilingual AI outbound dialer for contact centres.](https://www.broadnet.me/dialerbee) [What is SMS pumping? How OTP fraud works and the defences that stop it.](https://www.broadnet.me/answers/what-is-sms-pumping)

## Questions

### Can an AI agent send SMS and WhatsApp messages through BroadNet?

Yes. Connect it to the messaging MCP server at https://mcp.broadnet.me/mcp with your BroadNet token, or have your code call the REST API at https://api.broadnet.me. Either way the agent acts with your token's permissions, so require a person to confirm each send.

### Does an agent need an account to ask about coverage or prices?

No. The knowledge MCP server at https://www.broadnet.me/mcp is public and read-only. It returns coverage, sender-ID rules, indicative list prices and regulations from the same data as the website. Prices are indicative list rates, not quotes.

### How does an agent send a one-time passcode?

Your system generates the code and the agent sends it in an SMS with POST /sms/sendSms, or in a WhatsApp authentication template. The public API has no separate verify endpoint, so checking the code stays in your system.

### Can an agent place voice calls?

Voice OTP, text-to-speech callouts and IVR are provisioned through your BroadNet account team. They are not in the public OpenAPI spec or the MCP tools. DialerBee is BroadNet's AI outbound dialer for contact centres.

### How do I get a token?

Request test access at /signup. BroadNet replies within one business day with test credentials. There is no instant self-serve key.

## Connect your agent to BroadNet

Start with the public knowledge server today. Request test access when your agent is ready to send.

[Request test access](https://www.broadnet.me/signup) [MCP server guide](https://www.broadnet.me/developers/mcp)