# Connect AI agents to BroadNet with MCP.

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

Model Context Protocol· /developers/mcp

The BroadNet MCP server exposes the BroadNet messaging API as tools an AI agent can call. Point any MCP client that supports remote servers at one endpoint, authenticate with your BroadNet token, and the agent can send and track messages on your account.

**Endpoint**

https://mcp.broadnet.me/mcp

**Transport**

MCP Streamable HTTP

**Authentication**

Authorization: Bearer <token>

**Channels**

WhatsApp, SMS, RCS, Telegram, Push, Email, Messenger, Instagram

## What the MCP server is

The Model Context Protocol (MCP) is an open standard that lets AI assistants discover and call external tools. The BroadNet MCP server is a remote MCP server: your client connects to it over HTTPS, lists the tools it offers, and calls them on your behalf.

The tools map to the same BroadNet API documented in the API reference and the OpenAPI spec — sending messages, working with WhatsApp templates, reading delivery reports. The agent acts with the permissions of the token you give it, exactly as your own code would.

## Two MCP servers: knowledge and messaging

BroadNet runs two MCP servers. The messaging server described on this page acts on your account. The knowledge server is public: an agent can ask it about BroadNet's coverage, sender-ID rules, published list prices, regulations and company facts without a login.

Knowledge server (public)

Read-only answers from the same data as this website. No account, no token, no personal data.

**Endpoint**

https://www.broadnet.me/mcp

**Authentication**

None

**Access**

Read-only

**Tools**

search_site, get_facts, check_coverage, sender_id_rules, estimate_price, count_sms_segments, get_regulation, list_answers, get_answer, list_case_studies, get_case_study, get_changelog, get_status

**Rate limit**

60 requests per minute per IP

Messaging server (your account)

Sends and tracks messages with the permissions of your BroadNet token.

**Endpoint**

https://mcp.broadnet.me/mcp

**Authentication**

Authorization: Bearer <token>

**Access**

Acts on your account

Try the knowledge server from a terminal: the initialize handshake, then a tool call.

initialize (knowledge server)

```
curl -X POST https://www.broadnet.me/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-06-18","capabilities":{},
                 "clientInfo":{"name":"curl","version":"1.0"}}}'
```

tools/call (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":"sender_id_rules","arguments":{"country":"ae"}}}'
```

The knowledge server speaks MCP 2026-07-28 (per-request metadata, server/discover) and the earlier initialize-based revisions back to 2024-11-05. Prices it returns are indicative list rates, not quotes; regulation answers are planning guidance, not legal advice.

## Endpoint and authentication

There is one endpoint for every account: https://mcp.broadnet.me/mcp. Every request must carry your BroadNet token in an Authorization header.

You get the token from your BroadNet account. In the demo it is generated in the BroadAdmin portal under Integrations → MCP Integration with “Get temporary key”; the portal notes that a permanent key is issued by your account admin or master account.

A request without the header is refused at the protocol level — this is the server's actual reply to an unauthenticated initialize call:

response without a token

```
event: message
data: {"jsonrpc":"2.0","id":1,"error":{"code":-32001,
  "message":"Authorization bearer token is required. Connect with an
  'Authorization: Bearer <BroadNet token>' header."}}
```

## Connect an MCP client

Most MCP clients take a JSON configuration with the server URL and request headers. A typical entry looks like this:

mcp.json

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

Field names vary slightly between clients (some expect a type of "http" or "streamable-http", some read headers from a separate setting). Check your client's MCP documentation, and keep the token out of files you commit — use your client's environment-variable support where it has one.

To test the connection without a client, send the MCP initialize request yourself:

initialize handshake

```
curl -X POST https://mcp.broadnet.me/mcp \
  -H "Authorization: Bearer $BROADNET_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize",
       "params":{"protocolVersion":"2025-06-18","capabilities":{},
                 "clientInfo":{"name":"curl","version":"1.0"}}}'
```

## What the demo shows

The product team's recording walks through the whole flow in five steps, using Cursor as the MCP client:

1. 1 Sign in Log in to the BroadAdmin portal with your BroadNet account.
2. 2 Get a key and the configuration Open Integrations → MCP Integration, generate a temporary key and copy the ready-made client configuration.
3. 3 Add the server to the client In the MCP client, add a new MCP server and paste the configuration into mcp.json — URL https://mcp.broadnet.me/mcp with the Bearer header.
4. 4 Review the tools The client connects and lists the BroadNet tools, each of which can be switched on or off.
5. 5 Ask in plain language The user asks the agent to send a WhatsApp message to a number. The agent picks the WhatsApp send tool, the API answers HTTP 200 with the message accepted, and the message arrives in WhatsApp from the business account.

In the recording the client reports 380 BroadNet tools, among them send_message, post_sms_send, post_whatsapp_message_send, get_whatsapp_template_list, post_whatsapp_template_send, post_rcs_message_send, post_telegram_message_send, post_instagram_message_send, post_messenger_message_send, post_push_message_send and get_report_delivery. The exact list depends on the server version and your account.

A narrated version of the same recording adds an overview card: one MCP endpoint, the same copy-and-paste steps for every agent.

Demo recording (1 min 10 s, no sound): sign in to BroadAdmin, connect Cursor to the BroadNet MCP server, and send a WhatsApp message in plain language.

Narrated version (1 min 20 s, with voice-over) of the same flow, with an overview card at the start.

## Security notes

- The token is a send credential Anyone holding it can send messages from your account. Store it like a password, never in a shared or committed file.
- Prefer temporary keys for experiments Use a temporary key while you try things out, and ask your account admin for a permanent key only for a production agent.
- Enable only the tools you need MCP clients let you switch individual tools off. An agent that only sends SMS doesn't need template, onboarding or account tools.
- Keep a human in the loop Agents act on natural-language instructions. Have the client ask for confirmation before tools that send messages, especially to many recipients.
- Revoke a leaked token If a token is exposed, contact your account admin or BroadNet support to revoke it and issue a new one.

## Related

[API reference The REST endpoints behind the MCP tools, with Bearer auth.](https://www.broadnet.me/developers/api) [OpenAPI 3.1 spec The full machine-readable API description.](https://www.broadnet.me/developers/openapi.yaml) [Quickstart Send your first SMS with curl or the TypeScript SDK.](https://www.broadnet.me/developers/quickstart) [Guide: safe AI agents How agents send SMS and WhatsApp over MCP, and the guardrails to set first.](https://www.broadnet.me/blog/mcp-server-sms-whatsapp-ai-agents)

## Questions

### What is the BroadNet MCP server URL?

https://mcp.broadnet.me/mcp. It uses the MCP Streamable HTTP transport and requires an Authorization: Bearer header with your BroadNet token.

### Which AI clients can connect?

Any MCP client that can connect to a remote server over Streamable HTTP and send a custom Authorization header. The demo recording uses Cursor.

### Where do I get the token?

From your BroadNet account. In the BroadAdmin portal, Integrations → MCP Integration issues a temporary key; a permanent key comes from your account admin or master account.

### Can the agent send real messages?

Yes. In the demo recording the agent's WhatsApp send returns HTTP 200 and the message arrives on the phone. The tools act with your token's permissions, exactly as your own API calls would, so treat every send as real: enable only the tools the agent needs and require confirmation for sends.

## Build with BroadNet

Get an account and a token, then connect your agent or call the API directly.

[Talk to us](https://www.broadnet.me/contact) [Developer hub](https://www.broadnet.me/developers)