SMS Mobile API MCP for AI. Send, track, and read all texts from your gateway.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
SMS Mobile API connects your AI client directly to a physical Android gateway. It lets you send SMS, MMS, and WhatsApp messages using your own phone number, all through natural conversation.
You can also pull in incoming data—read new SMS messages or list missed calls—and check device connectivity status on the fly.
This tool makes your mobile messaging system part of your AI workflow.
What your AI can do
List sent messages
Lists a history of messages (SMS, MMS) that you have successfully sent out.
Send mms
Sends an MMS message, supporting the inclusion of media attachments like photos or videos.
Get received sms
Pulls a list of recent incoming SMS messages that were received by the gateway.
Sends a message via the connected WhatsApp account on your Android gateway.
Sends traditional Short Message Service (SMS) text messages from your device number.
Pulls the latest received SMS messages directly into your AI conversation context.
Retrieves a summary of all recorded missed phone calls on the gateway device.
Gets current account information, including usage quotas and billing details.
Ask an AI about this
Waiting for input…
SMS Mobile API MCP Server: 11 Tools for Messaging Ops
These tools let you manage every aspect of mobile communication, from sending a single WhatsApp message to auditing account usage and listing missed calls.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using SMS Mobile API on VinkiusList Sent Messages
Lists a history of messages (SMS, MMS) that you have successfully sent out.
Send Mms
Sends an MMS message, supporting the inclusion of media attachments like photos or...
Get Received Sms
Pulls a list of recent incoming SMS messages that were received by the gateway.
List Connected Devices
Shows all mobile gateways currently linked to your account, confirming connectivity...
List Missed Calls
Retrieves the log detailing all calls that came in but were not answered by the...
Get Account Info
Retrieves your account usage statistics and general information about the service.
Get Delivery Status
Checks if a previously sent message successfully reached its destination phone.
Get Device
Provides specific operational details for one connected mobile gateway device.
List Contacts
Reads and returns a list of all saved phone numbers and names available on the...
Send Sms
Sends a standard text message (SMS) from the phone number linked to your account.
Send Whatsapp
Sends a message through WhatsApp using the connected device's credentials.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with SMS Mobile API, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by SMS Mobile API. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 11 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manual message handling wastes time. You shouldn't have to check multiple dashboards just to read logs.
Today, reviewing communications means logging into the carrier portal, then checking your CRM for call notes, and finally opening WhatsApp to see unread chats. It’s a painful process of context switching and copy-pasting data between three different systems just to get one answer: what happened?
With this MCP server, you ask the agent once: 'What's new?' The system runs `get_received_sms` and pulls in missed calls via `list_missed_calls`. You get a clean summary of all incoming activity—texts, calls, and who they were from—all without leaving your chat interface.
SMS Mobile API: Send messages directly using the `send_sms` tool.
Used to send a personalized notification, you’d have to manually copy the number into the messaging app and write out the message. If you needed an attachment, you'd switch to a different platform entirely.
Now, your agent just uses `send_sms` or `send_whatsapp`. You tell it 'Send this,' and it handles the connection, formatting, and sending process through the live gateway. It’s that simple.
What your AI can actually do with this
You connect this SMS Mobile API server to your AI client—your agent—and it turns that agent into a full-blown messaging hub. It treats your physical Android gateway like another service endpoint, letting you handle all outgoing messages and keeping the chat synced with incoming communications.
When you use send_sms, you're shooting off a standard text message (SMS) right from the number linked to your account. Need to send something bigger? Use send_mms for Multi-Media Messaging Service (MMS), which supports attaching photos or videos. For WhatsApp, you just call send_whatsapp; it sends the message through the connected device's credentials.
You can pull in a whole bunch of data about conversations that happened on the gateway. If someone texts you, your agent uses get_received_sms to pull those latest incoming SMS messages right into the conversation context. You can also check up on missed calls using list_missed_calls, which pulls a log of every call that came in but wasn't answered by the device.
To keep track of what you sent, your agent runs list_sent_messages to show a history of all successful SMS and MMS messages. For contact info, it uses list_contacts to read out every saved name and number stored on the physical phone.
Monitoring everything is where this thing gets powerful. You can check if any message actually made it through by calling get_delivery_status. It confirms whether a previously sent text reached its destination phone. To see what's happening with your hardware, you run list_connected_devices to show every mobile gateway currently linked, confirming their connectivity status.
If you need deep operational details on just one specific gateway, you use get_device, which provides those exact technical specs for that single connected device.
For account visibility, the agent uses get_account_info to retrieve your usage statistics and general service information. You can also get a running tally of all gateways linked to your subscription using list_connected_devices. This setup makes sure that everything—sending messages via send_sms, handling media attachments with send_mms, or checking the status of an old message with get_delivery_status—is managed directly by your AI client in a natural conversation flow.
019dd162-a934-7375-b94b-07c14239a862 Here's how it actually works
The bottom line is: you connect your physical phone number to an API endpoint, letting your AI agent send and read messages as if it were running the apps itself.
Subscribe to the SMS Mobile API server on Vinkius.
Input your unique API key from your mobile dashboard into your AI client's settings.
Your agent can then call any tool, like send_sms or get_received_sms, using natural language prompts.
Who is this actually for?
This is for small business owners who can't afford dedicated call centers. It’s also for support teams drowning in message logs, or developers building custom workflows that need reliable mobile communication without writing boilerplate networking code.
Sends personalized customer notifications (e.g., 'Your order is ready') using their own phone plan directly through the AI agent.
Automates the process of reviewing incoming SMS messages and missed calls, ensuring no support query gets missed between shifts.
Integrates local mobile messaging capabilities (SMS, WhatsApp) into complex custom agent workflows for automated business processes.
What Changes When You Connect
Automatic Message Logging: You don't have to jump between apps. Use get_received_sms or list_missed_calls, and your AI agent pulls that data straight into the chat context for immediate action.
End-to-End Visibility: Need proof a message went through? Call get_delivery_status. You get real-time confirmation on whether SMS, MMS, or WhatsApp actually landed in the recipient's inbox.
Unified Communication Channels: Instead of having separate APIs for texting and chat apps, you manage both. Use dedicated tools like send_sms and send_whatsapp from one place.
Device Health Monitoring: Don't get locked out. Run list_connected_devices to verify the gateway is online before starting a critical campaign. Know your status before you send.
See it in action
Handling customer support inquiries after hours
A small shop owner gets a call and texts at 10 PM. Instead of manually checking the phone, they prompt their agent: 'Check for messages.' The agent runs get_received_sms and reports back on all new queries, allowing the owner to respond immediately without opening the native app.
Running a mass notification campaign
A company needs to alert 50 clients about maintenance. They use send_sms in bulk mode and then run list_sent_messages. The agent tracks the delivery percentage, showing exactly which numbers failed so they can retry only those contacts.
Auditing a marketing outreach effort
A sales team sends 20 appointment reminders. They use send_sms and then check the results using get_delivery_status for each number. This confirms that the message didn't fail due to an invalid phone number.
Syncing call data into a CRM workflow
A field manager wants to know which clients called while they were out. They ask the agent to run list_missed_calls and cross-reference those numbers with their existing client list via list_contacts. The agent reports who needs calling back.
The honest tradeoffs
Assuming a single API handles everything
Trying to send an attachment and also check delivery status with just one call. It's complex, and the API will fail or give incomplete data.
Break it into steps. First, use send_mms for media content. Then, wait a moment and immediately run get_delivery_status to confirm receipt.
Ignoring device status before sending
Launching a critical broadcast message right after an update or network hiccup, only to find out the gateway was offline.
Always check connectivity first. Start by calling list_connected_devices. If the primary gateway isn't listed, stop and troubleshoot before running any sending tools.
Forgetting contact details
Asking the agent to send a message but forgetting which numbers are valid or if they need to use MMS instead of SMS.
Run list_contacts first. This lets you verify the phone number format and ensures your target list is accurate before using send_sms.
When It Fits, When It Doesn't
Use this server if your core business process relies on reliable, two-way communication via SMS or WhatsApp from a physical mobile device. You need to send messages and read incoming history in the same workflow.
Don't use it if you only need to integrate with email (use an email API instead). Don't use it if your messaging needs are purely internal and don't involve external phone numbers (a database tool is better).
It excels when you combine list_contacts (who) -> send_sms (what) -> and then immediately follow up with get_delivery_status (if it worked). It’s a mobile communication backbone, not just a messaging sender.
Questions you might have
Can I check if an SMS message actually got delivered using send_sms? +
Yes. After calling send_sms, you can immediately run get_delivery_status. This tool confirms the delivery status, letting you know if it was successfully received or why it failed.
Does list_contacts work with MMS messages? +
No. list_contacts only reads saved names and numbers from the device's directory. You must use the dedicated send_mms tool if you need to send media attachments.
How do I see all my sent messages? +
You run the list_sent_messages tool. It provides a full, structured history of every text and MMS message that was dispatched from your account gateway.
Is this only for SMS texts or can I use WhatsApp? +
It handles both. You have separate tools: send_sms for standard texts, and send_whatsapp when you need to send via the connected WhatsApp account.
What if my gateway device is offline? How do I know? +
Check with list_connected_devices. If the status reported by this tool isn't 'Online,' don't run any sending tools, because your messages won't go out.
How do I check my usage limits or remaining credits using the `get_account_info` tool? +
The get_account_info tool provides real-time metrics on your account status. You get total messages sent, current billing cycle data, and any accrued costs directly in the response payload.
If I use `send_sms` to an invalid or undeliverable number, how does the system report the failure? +
The client handles message failures by returning specific status codes. The API tells you exactly why the send failed—whether it's an 'invalid recipient,' a temporary network error, or if the line is blocked.
What technical details can I retrieve about my connected gateways using `get_device`? +
The get_device function retrieves deep operational data for a specific gateway. You find its unique hardware ID, current network status (online/offline), and the last recorded connection timestamp.
How do I find my SMSMobileAPI Key? +
Log in to the SMS Mobile API web dashboard or open the Android app and navigate to the Settings or Help section to find your unique API Key.
We've already built the connector for SMS Mobile API. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 11 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.