Ozeki Android SMS MCP Server

Turn your Android phone into an AI-powered SMS gateway, send text messages directly from Claude, GPT, OpenClaw, Hermes or any MCP-compatible AI agent using your own SIM card.

Table of Contents

What Is This?

The Ozeki Android SMS MCP Server (ozeki_android_mcp) is a Model Context Protocol (MCP) server that runs on any Android smartphone. It exposes SMS functionality — sending text messages and querying SIM subscriptions — as structured tools that any MCP-compatible AI agent can call.

In plain terms: once installed and configured, your AI agent (Claude, GPT, a custom LangChain agent, etc.) can send real SMS messages through your Android phone's SIM card, to any phone number in the world, with a single tool call.

This is not a cloud gateway. There are no third-party SMS APIs, no Twilio accounts, no per-message cloud fees. Your phone is the gateway.

How It Works

1. You install the Ozeki Android SMS MCP Server app on an Android device.
2. The app starts an HTTP server on your Android phone network (default port 9531).
3. Your AI agent connects to this server using the MCP protocol (JSON-RPC 2.0 over HTTP).
4. The agent calls the send_sms tool with a phone number and message text.
5. The app uses the Android SMS API to send the message via the device's SIM card.
6. The recipient receives a real SMS from your phone number.

The MCP server speaks the standard MCP protocol version 2025-11-25, making it compatible with any MCP-capable client out of the box.

Why Use an Android SMS MCP Server?

✅ No Third-Party API Required

Most SMS solutions require a paid cloud SMS gateway (Twilio, Vonage, AWS SNS, etc.). With this server, you use the SIM card already in your Android device. There are no additional accounts to create, no API keys to manage from external providers, and no per-message fees beyond your carrier plan.

✅ Works on Any Android Device

Any Android phone or tablet with an active SIM card can become an SMS gateway. Repurpose an old device, use a cheap prepaid SIM, or route messages through your primary number, the choice is yours.

✅ True Local/Private Operation

Because the HTTP server runs on your local network, messages are not routed through any third-party cloud infrastructure. This is ideal for private, on-premises, or air-gapped environments where you don't want SMS content leaving your network perimeter.

✅ Multi-SIM Support

Modern Android phones often support two SIM cards. The server exposes both subscriptions and lets you choose which SIM to use for each message, perfect for separating personal and business SMS traffic or using different carriers.

✅ Standard MCP Protocol

The server implements the official MCP specification, meaning it works immediately with Claude Code, Claude Desktop, OpenAI-compatible agents, LangChain, AutoGen, and any other framework that supports MCP tool use.

✅ Real-World Automation Use Cases

• Alerting and notifications: Have an AI agent send you an SMS when a job finishes, an error occurs, or a threshold is crossed.
• Customer communication: Integrate AI workflows that send appointment reminders, order confirmations, or status updates.
• Two-factor and verification flows: Automatically send OTP or verification codes as part of an agent workflow.
• Escalation pipelines: When an AI agent detects a critical issue, it can page a human via SMS immediately.
• Personal productivity: Ask your AI assistant to send reminders or messages to contacts directly from a conversation.

Installation

Step 1: Download the App

Download the Ozeki Android SMS MCP Server from the official website:

https://android-sms-gateway.com

Install the APK on any Android device with an active SIM card.

Step 2: Launch and Configure the App

1. Open the app on your Android device.
2. Grant the requested SMS permissions when prompted.
3. Note the local IP address and port shown in the app (e.g., 192.168.0.11:9531). This is the address your AI agent will connect to.
4. Ensure your Android device and your agent's host machine are on the same local network (or configure port forwarding if accessing remotely).

Step 3: Verify the Server Is Running

You can quickly verify the server is up by initializing the MCP session from any HTTP client:

curl -X POST http://192.168.0.11:9531/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "method": "initialize",
    "params": {
      "protocolVersion": "2025-11-25",
      "capabilities": {},
      "clientInfo": {"name": "test", "version": "1.0.0"}
    },
    "jsonrpc": "2.0",
    "id": 0
  }'

A successful response looks like:

{
  "id": 0,
  "result": {
    "protocolVersion": "2025-11-25",
    "capabilities": {"tools": {"listChanged": false}},
    "serverInfo": {
      "name": "ozeki_android_mcp",
      "version": "1.0.0",
      "title": "Ozeki Android SMS MCP server"
    }
  },
  "jsonrpc": "2.0"
}

Tools Reference

The server exposes two tools via the MCP tools/list endpoint.

send_sms

Sends an SMS message to a specified phone number using the Android device's SIM card.

Parameters:

Example raw MCP call:

Example response:

get_sms_subscriptions

Returns the list of active SMS subscriptions (SIM cards) currently available on the Android device. Use this before calling send_sms on a multi-SIM device to find the correct subscription_id.

Parameters: None

Example raw MCP call:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "get_sms_subscriptions",
    "arguments": {}
  }
}

Example response:

{
  "id": 2,
  "result": {
    "content": [
      {
        "text": "{\"count\":2,
          \"subscriptions\":[
            {\"subscription_id\":14,
            \"sim_slot_index\":0,
            \"carrier_name\":\"vodafone UK\",
            \"display_name\":\"Orange F\"},
            {\"subscription_id\":17,
            \"sim_slot_index\":1,
            \"carrier_name\":\"EE | Yettel HU\",
            \"display_name\":\"Yettel HU\"}]}",
        "type": "text"
      }
    ]
  },
  "jsonrpc": "2.0"
}

Parsed subscription object:

Configuration Guide

Replace 192.168.0.11:9531 in all examples below with the IP address and port shown in your Ozeki Android SMS MCP Server app.

Configure with Claude Code

Claude Code supports MCP servers via its configuration file. Add the Android SMS server as an HTTP-based MCP endpoint.

Option A — Add via CLI:

claude mcp add android-sms --transport http --url http://192.168.0.11:9531/mcp

Option B — Edit ~/.claude/mcp.json manually:

{
  "mcpServers": {
    "android-sms": {
      "type": "http",
      "url": "http://192.168.0.11:9531/mcp"
    }
  }
}

After saving, restart Claude Code. You can verify the tools are available by asking:

"What MCP tools do you have available?"

Claude will list send_sms and get_sms_subscriptions. You can then say things like:

"Send an SMS to +44 7700 900123 saying 'The report is ready.'"

Configure with Claude Desktop

Claude Desktop (the claude.ai desktop app) reads MCP server configuration from a JSON file.

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Add the following entry inside the mcpServers object:

{
  "mcpServers": {
    "android-sms": {
      "type": "http",
      "url": "http://192.168.0.11:9531/mcp",
      "headers": {}
    }
  }
}

Restart Claude Desktop. The SMS tools will appear in Claude's tool panel. You can now ask Claude conversationally to send SMS messages.

Configure with OpenAI / OpenClaw Agents

Any agent framework that supports MCP over HTTP can connect to this server. For OpenAI-based agents and OpenClaw, configure an MCP client pointing to the server's HTTP endpoint.

Example using the openai-agents SDK with MCP:

from openai import OpenAI
from agents import Agent, MCPClient

client = OpenAI()

# Connect to the Android SMS MCP server
sms_mcp = MCPClient(
    base_url="http://192.168.0.11:9531/mcp",
    protocol_version="2025-11-25"
)

agent = Agent(
    name="SMS Agent",
    model="gpt-4o",
    mcp_clients=[sms_mcp]
)

# The agent can now call send_sms and get_sms_subscriptions
response = agent.run("Send a confirmation SMS to +442079460000")
print(response)

For OpenClaw or similar frameworks, provide the MCP server URL as an HTTP transport endpoint in the agent tool configuration. The server uses standard JSON-RPC 2.0 over HTTP POST to /mcp, with the mcp-protocol-version: 2025-11-25 header.

Configure with Python

Use httpx or requests to call the MCP server directly from Python scripts or agent frameworks.

Install dependencies:

pip install httpx

Full Python example:

import httpx
import json

MCP_URL = "http://192.168.0.11:9531/mcp"
HEADERS = {
    "Content-Type": "application/json",
    "Accept": "application/json, text/event-stream",
    "mcp-protocol-version": "2025-11-25"
}

def mcp_call(method: str, params: dict = None, call_id: int = 1) -> dict:
    payload = {
        "jsonrpc": "2.0",
        "id": call_id,
        "method": method,
        "params": params or {}
    }
    response = httpx.post(MCP_URL, headers=HEADERS, json=payload)
    response.raise_for_status()
    return response.json()

# Step 1: Initialize
mcp_call("initialize", {
    "protocolVersion": "2025-11-25",
    "capabilities": {},
    "clientInfo": {"name": "my-agent", "version": "1.0.0"}
}, call_id=0)

# Step 2: List available SIM subscriptions
subs = mcp_call("tools/call", {
    "name": "get_sms_subscriptions",
    "arguments": {}
}, call_id=1)
subscriptions = json.loads(subs["result"]["content"][0]["text"])
print("Active SIMs:", subscriptions)

# Step 3: Send an SMS
result = mcp_call("tools/call", {
    "name": "send_sms",
    "arguments": {
        "to_phone_number": "+447911123456",
        "sms_text": "Hello from my AI agent!",
        "subscription_id": subscriptions["subscriptions"][0]["subscription_id"]
    }
}, call_id=2)
print(result["result"]["content"][0]["text"])
# Output: SMS sent to +447911123456

Configure with Node.js

npm install node-fetch

const fetch = require('node-fetch');

const MCP_URL = 'http://192.168.0.11:9531/mcp';
const HEADERS = {
  'Content-Type': 'application/json',
  'Accept': 'application/json, text/event-stream',
  'mcp-protocol-version': '2025-11-25'
};

async function mcpCall(method, params = {}, id = 1) {
  const response = await fetch(MCP_URL, {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify({ jsonrpc: '2.0', id, method, params })
  });
  return response.json();
}

(async () => {
  // Initialize
  await mcpCall('initialize', {
    protocolVersion: '2025-11-25',
    capabilities: {},
    clientInfo: { name: 'my-node-agent', version: '1.0.0' }
  }, 0);

  // Get subscriptions
  const subsResult = await mcpCall('tools/call', {
    name: 'get_sms_subscriptions',
    arguments: {}
  }, 1);
  const subs = JSON.parse(subsResult.result.content[0].text);
  console.log('Active SIMs:', subs.subscriptions);

  // Send SMS
  const sendResult = await mcpCall('tools/call', {
    name: 'send_sms',
    arguments: {
      to_phone_number: '+447911123456',
      sms_text: 'Hello from Node.js agent!',
      subscription_id: subs.subscriptions[0].subscription_id
    }
  }, 2);
  console.log(sendResult.result.content[0].text);
})();

Usage Examples

Example 1: AI Agent Sends an Alert SMS

A monitoring agent detects high CPU usage and sends an SMS alert:

Prompt to Claude: "If the server CPU is above 90%, send me an SMS at +447911123456."

Claude calls send_sms with:

{
  "to_phone_number": "+447911123456",
  "sms_text": "Alert: Server CPU at 94%. Please investigate."
}

Example 2: Choosing a SIM on a Dual-SIM Phone

Prompt: "Send the message 'Meeting in 10 mins' to +33785880347 using the Vodafone SIM."

Claude first calls get_sms_subscriptions to find the Vodafone subscription ID, then calls send_sms:

{
  "to_phone_number": "+33785880347",
  "sms_text": "Meeting in 10 mins",
  "subscription_id": 14
}

Example 3: Bulk Notification Workflow

An agent script sends appointment reminders to a list of customers:

contacts = [
    ("+447700900001", "Alice, your appointment is at 10 AM tomorrow."),
    ("+447700900002", "Bob, your appointment is at 2 PM tomorrow."),
    ("+447700900003", "Carol, your appointment is at 4 PM tomorrow."),
]

for phone, message in contacts:
    result = mcp_call("tools/call", {
        "name": "send_sms",
        "arguments": {"to_phone_number": phone, "sms_text": message}
    })
    print(result["result"]["content"][0]["text"])

Multi-SIM Support

If your Android device has two SIM cards, the server will expose both as separate subscriptions. Each has a unique subscription_id.

Call get_sms_subscriptions first to discover available subscriptions:

{
  "count": 2,
  "subscriptions": [
    {
      "subscription_id": 14,
      "sim_slot_index": 0,
      "carrier_name": "vodafone UK",
      "display_name": "Orange F"
    },
    {
      "subscription_id": 17,
      "sim_slot_index": 1,
      "carrier_name": "EE | Yettel HU",
      "display_name": "Yettel HU"
    }
  ]
}

Then pass the desired subscription_id to send_sms. If you omit subscription_id on a multi-SIM device, the system default SIM will be used.

Practical use cases for multi-SIM:

• Route business messages through a business SIM, personal alerts through a personal SIM.
• Use a cheaper international SIM for messages to specific country codes.
• Implement fallback: if one carrier has issues, switch to the other.

Security Considerations

The MCP server runs an unencrypted HTTP server on your local network. Before deploying in any environment beyond your home/office LAN, review the following:

Network exposure:

• By default the server binds to your device's local IP. Keep this behind a firewall and do not expose port 9531 to the public internet unless you have additional authentication in place.
• If you need remote access, use a VPN (WireGuard, Tailscale, etc.) to tunnel traffic securely rather than forwarding the port directly.

No authentication by default:

• The default configuration does not require credentials. Anyone on your local network who knows the server's IP and port can send SMS messages using your SIM.
• Check the Ozeki app documentation for options to enable basic authentication or IP allowlisting.

Message content:

• SMS messages are sent in plaintext over the carrier network. Do not transmit sensitive data (passwords, personal identification numbers, financial information) via SMS.

SIM costs:

• AI agents can generate many tool calls. Ensure your carrier plan covers the expected volume of messages, or implement rate-limiting in your agent logic to avoid unexpected charges.

Troubleshooting

Connection refused / cannot reach the server

• Confirm the Ozeki app is running and the HTTP server is started (check the app's status screen).
• Verify your agent machine and the Android device are on the same Wi-Fi network.
• Check that your router or firewall is not blocking port 9531.
• Try pinging the Android device's IP from your machine: ping 192.168.0.11.

SMS sent confirmation but message not received

• Check the Android device has signal and the SIM is active.
• Confirm the recipient number is in correct international format (e.g., +447911123456, not 07911123456).
• Check the Ozeki app's outbox for error messages from the carrier.

Wrong SIM used on dual-SIM device

• Call get_sms_subscriptions first and pass the correct subscription_id explicitly.

Messages longer than 160 characters

• Standard SMS supports 160 characters. Longer texts are split into concatenated SMS segments by the carrier and may be billed as multiple messages. Keep sms_text to 160 characters or fewer.

MCP initialization fails

• Ensure the Content-Type: application/json header is included.
• Use protocolVersion: "2025-11-25" — this is the version the server supports.

FAQ

Q: Does this require a rooted Android device?
A: No. The app uses standard Android SMS APIs and does not require root access.

Q: Which Android versions are supported?
A: The app supports Android 8.0 (Oreo) and later. Check the official download page for the current minimum version.

Q: Can I use a tablet without a SIM?
A: No. The device must have an active SIM card with SMS capability. Tablets that are Wi-Fi only cannot send SMS.

Q: Can I send MMS or multimedia messages?
A: The current version supports SMS (text only, up to 160 characters per message). MMS support may be added in future versions, check the official website for updates.

Q: Is the server available over the internet or only on LAN?
A: By default, LAN only. For internet access, use a VPN or reverse proxy with proper authentication. Direct internet exposure without authentication is strongly discouraged.

Q: Can multiple AI agents connect to the same server simultaneously?
A: Yes. The HTTP server handles multiple concurrent connections. Each connection is stateless, there is no session concept beyond the optional MCP initialization handshake.

Q: Are there rate limits?
A: The server itself does not impose rate limits. Your mobile carrier may throttle or block accounts that send large volumes of SMS in a short period. Implement application-level rate limiting in your agent if you expect high volumes.

Q: Where can I get support?
A: Visit https://android-sms-gateway.com for documentation, FAQs, and community support.