# SMS Mobile API MCP

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

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** android-gateway, whatsapp-automation, mobile-messaging, api-integration, call-tracking

## Description

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.

## Tools

### 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.

### list_connected_devices
Shows all mobile gateways currently linked to your account, confirming connectivity status.

### list_missed_calls
Retrieves the log detailing all calls that came in but were not answered by the gateway.

### 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 device.

### 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.

## Prompt Examples

**Prompt:** 
```
Send an SMS to +1234567890: 'Your order is ready for pickup!'.
```

**Response:** 
```
SMS triggered successfully! I've sent the pickup notification through your connected Android device via SMS Mobile API.
```

**Prompt:** 
```
Send an SMS notification to all customers about our system maintenance window tonight.
```

**Response:** 
```
SMS broadcast sent. Recipients: 234 customers. Message: "System maintenance tonight 11 PM - 3 AM EST. Services may be briefly unavailable. We apologize for any inconvenience. Status page: status.yourapp.com". Delivery: 229 delivered (97.9%), 3 undeliverable (invalid numbers), 2 pending. Character count: 148 (1 SMS segment). Cost: $11.70 ($0.05/msg). Device used: Primary Gateway (iPhone, device_001). Delivery receipts will be available within 30 minutes.
```

**Prompt:** 
```
Show me all received SMS messages and missed calls from the last 48 hours.
```

**Response:** 
```
Received SMS (last 48h): 34 messages. Support requests: 12 (keywords: "help", "issue", "broken"). Order confirmations: 8 (auto-forwarded to CRM). Appointment confirmations: 6 ("YES" replies). Opt-out requests: 3 ("STOP" - auto-processed). General inquiries: 5. Missed calls: 8 total. From known contacts: 5 (3 customers, 2 suppliers). Unknown numbers: 3. Peak incoming: yesterday 10 AM (7 messages in 1 hour). Auto-responses sent: 15 (after-hours acknowledgment).
```

## Capabilities

### Send WhatsApp messages
Sends a message via the connected WhatsApp account on your Android gateway.

### Send standard SMS texts
Sends traditional Short Message Service (SMS) text messages from your device number.

### Retrieve incoming SMS history
Pulls the latest received SMS messages directly into your AI conversation context.

### List missed calls log
Retrieves a summary of all recorded missed phone calls on the gateway device.

### Check account usage and stats
Gets current account information, including usage quotas and billing details.

## Use Cases

### 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.

## Benefits

- **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.

## How It 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.

1. Subscribe to the SMS Mobile API server on Vinkius.
2. Input your unique API key from your mobile dashboard into your AI client's settings.
3. Your agent can then call any tool, like `send_sms` or `get_received_sms`, using natural language prompts.

## Frequently Asked Questions

**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**](https://smsmobileapi.com/dashboard) or open the Android app and navigate to the Settings or Help section to find your unique API Key.