textbee MCP Server vs Twilio MCP: Which SMS MCP Server Should Your AI Agent Use?

TL;DR

• Use Twilio's MCP when you already run on Twilio and want your agent working across its whole product surface at carrier scale. Use the textbee MCP server when you want the agent texting from your own number through an Android phone you own, on a flat plan, with a three-tool surface that is easy to constrain.
• The two are not the same kind of thing. Twilio's hosted MCP server at mcp.twilio.com/docs is read-only API documentation search and does not send anything. The Twilio server that actually calls the API is the Twilio Labs alpha package @twilio-alpha/mcp, which you run locally.
• textbee's server exposes exactly three tools: send_sms, get_messages, list_devices. Twilio's alpha server generates tools from Twilio's OpenAPI specs across roughly 1,800 endpoints, so you filter it down with flags before an agent can use it sanely.
• Cost shape differs more than cost level. Twilio bills $0.0083 per US outbound segment plus carrier fees plus $1.15/month per number (checked October 2026). textbee has no per-message API fee: messages ride your existing SIM plan.
• Both are open to run yourself. Only textbee lets the agent send from the number people already have saved for you.

What each MCP server actually exposes

There are three servers in this comparison, not two, and mixing them up is the most common mistake. One is a docs index, one is a full-account API bridge, one is a small SMS tool set. Only two of them can send a message.

Twilio's hosted MCP server lives at https://mcp.twilio.com/docs. Twilio's docs describe it as Public Beta, requiring no authentication and no Twilio account, because it indexes public API specifications only. It exposes two tools, twilio__search (natural-language query, returns ranked API operations) and twilio__retrieve (returns full parameter schemas for operations found by search), covering over 1,800 endpoints across 30+ products. Twilio states plainly that it "does not execute API calls on your behalf". It makes your coding agent better at writing Twilio code. It does not give your agent a phone. Source: twilio.com/docs/ai/mcp, checked October 2026.

The Twilio Labs alpha server is the one that executes. It is published as @twilio-alpha/mcp from github.com/twilio-labs/mcp, whose description is "Exposing all of Twilio's API as MCP Tools". Tools are generated dynamically from Twilio's OpenAPI specs, so the surface is Twilio's public API surface. It runs locally over stdio through npx, and it takes your Account SID, API Key SID, and API Secret. Twilio's own launch post says the API is close to 2,000 endpoints and that this "can quickly exceed token limits", which is why the server takes --services and --tags filters. It carries the Twilio Alpha label. Whether it graduates to GA, and whether the hosted server later gains authenticated execute tools, is not something the current pages commit to, so treat it as alpha.

The textbee MCP server is published as @textbee/mcp and does one thing. send_sms sends to one or more recipients, with optional device_id, sim_subscription_id, and scheduled_at. get_messages reads across every device on the account with direction, search, sms_batch_id, device, and time-window filters, plus cursor pagination so a polling agent never misses or repeats a message. list_devices lists the phones. That is the whole surface. Full detail is in the MCP docs.

Comparison table

Here is the practical side by side. The Twilio column below describes the alpha server, since that is the one that can actually send an SMS.

Twilio prices are US long code, from twilio.com/en-us/sms/pricing/us, checked October 2026. Carrier fees are separate and vary by carrier, and US A2P 10DLC traffic carries registration fees on top.

And the standard provider view:

Setup: textbee MCP in Claude Code and Cursor

Get an API key from the dashboard and pair the Android app first. The free tier is enough to test with.

Claude Code, one command:

claude mcp add textbee -s user -e TEXTBEE_API_KEY=your-key -- npx -y @textbee/mcp

Cursor (~/.cursor/mcp.json) and Claude Desktop (claude_desktop_config.json) take the same object:

{
  "mcpServers": {
    "textbee": {
      "command": "npx",
      "args": ["-y", "@textbee/mcp"],
      "env": { "TEXTBEE_API_KEY": "your-key" }
    }
  }
}

Self-hosting textbee? Add TEXTBEE_BASE_URL with your instance URL to the env block. The /api/v1 suffix is optional and added automatically. For clients that cannot launch a local process, such as claude.ai on the web, add https://mcp.textbee.dev/mcp as a custom connector, click Connect, and paste your API key on the sign-in page. Same three tools, same plan limits.

Setup: Twilio MCP

Two different setups, because there are two servers. Both snippets below are from Twilio's own pages, checked October 2026.

For the hosted docs server, Twilio's docs give this for Claude Code:

claude mcp add --transport http twilio-docs https://mcp.twilio.com/docs

and this for Cursor:

{
  "mcpServers": {
    "twilio-docs": {
      "url": "https://mcp.twilio.com/docs"
    }
  }
}

For the alpha server that executes API calls, the twilio-labs repo gives:

{
  "mcpServers": {
    "twilio": {
      "command": "npx",
      "args": [
        "-y",
        "@twilio-alpha/mcp",
        "YOUR_ACCOUNT_SID/YOUR_API_KEY:YOUR_API_SECRET"
      ]
    }
  }
}

Twilio's launch post shows the same command narrowed with a service filter, for example --services twilio_api_v2010, and the repo documents --tags for individual endpoint groups such as Api20100401IncomingPhoneNumber. Use them. An unfiltered load of Twilio's API surface is what blows the context window.

Agent safety: why a small tool surface matters

Every tool you hand an agent is a thing it might call. A three-tool server can only send a message, read messages, and list phones. A server generated from a full public API can do whatever that API can do, and Twilio's API can buy phone numbers, change messaging service configuration, and edit account settings. The Api20100401IncomingPhoneNumber tag that Twilio documents as a filter example is, unfiltered, a number-purchasing capability sitting in your agent's tool list.

That is not a Twilio flaw. It is the honest consequence of exposing 1,800 endpoints as tools, and it is why Twilio ships --services and --tags and why the server is labeled alpha. If you use it, filter it down to the minimum service set your agent needs, and treat those API key credentials as full-account credentials, because that is what the current setup passes to the server.

On the textbee side, be clear about what is and is not a guarantee. The tool surface is small, and plan limits are enforced server-side, so a looping agent cannot send more than your plan allows. The API key itself is an account key: revoke it from the dashboard if it leaks, and create a dedicated key per client so you can revoke just that one. Neither product gives you a send-only credential today.

When Twilio's MCP is the right choice

Choose Twilio when the account already exists and the agent's job is to operate it. If you are debugging a Studio flow, provisioning numbers, checking Verify, or wiring Messaging Services, the alpha server's breadth is the entire point. A three-tool SMS server cannot help you there.

Choose the hosted docs server, separately and always, if your coding agent writes Twilio code. It needs no account and no key, it is read-only, and it stops the agent inventing parameter names. It pairs fine with a sending server, including textbee's.

Choose Twilio for sending when you need carrier-grade throughput, a short code, guaranteed deliverability across many countries, or an SLA. textbee sends through an Android phone and its SIM, which means the carrier sets your ceiling: hundreds to low thousands of messages per day per device, not hundreds per second. Bulk marketing blasts are Twilio's job, not textbee's. The full comparison covers that side in more detail.

When textbee's MCP is the right choice

Choose textbee when the agent should text from the number your recipients already know, and when the message volume is transactional rather than campaign scale: build alerts, appointment confirmations, on-call pings, OTP reads, customer replies. Recipients see your real local number instead of a rented one, so replies land back in the same thread and get read.

Choose it when you want the cost flat and predictable. There is no per-segment API fee and no number rental, because the number is yours already. At Pro's 5,000 messages a month the entire bill is the subscription. Compare that with per-segment billing plus carrier fees plus number rental and the arithmetic favors textbee well past the point where most side projects and small businesses live.

Choose it when you want the tool surface bounded by construction rather than by a flag you remembered to set, and when self-hosting matters: the whole stack is open source and TEXTBEE_BASE_URL points the same MCP server at your own instance. The first-run guide and the Claude walkthrough cover the practical setup end to end.

Frequently asked questions

Can I use both MCP servers at once?

Yes, and for coding agents it is a reasonable setup: Twilio's hosted docs server for API reference, textbee's server for actually sending. Keep credentials separated per server, give each server only the key it needs, and only install servers you trust.

Does textbee's MCP server work with hosted claude.ai?

Yes. claude.ai runs in a browser and cannot launch a local process, so add the hosted endpoint at https://mcp.textbee.dev/mcp as a custom connector, click Connect, and paste your API key on the sign-in page. It also works in the Claude mobile apps. It exposes the same three tools and the same plan limits. Your key does pass through textbee's server on each request in that mode, so prefer the local npx server wherever your client can run it.

What about receiving replies?

get_messages reads inbound messages across every device on the account, with direction=received as the default, plus search and time-window filters and cursor pagination. That is how an agent waits for a reply or picks up a verification code without re-reading old messages. If you want push instead of polling, textbee also has webhooks.

What happens at volume?

textbee's throughput is bounded by the phone and the carrier, so plan on hundreds to low thousands of messages per day per device. You can add devices on paid plans to raise that ceiling, but it stays a phone-and-SIM ceiling. If you need tens of thousands of messages an hour, a short code, or per-country routing, use Twilio. Being wrong about this is expensive in delivery delays, not in dollars.