Integration

httpSMS integration

httpSMS turns your own Android phone (running the httpSMS app) into an SMS gateway. Send single or bulk SMS (MMS when attachments are given) from a phone number registered in your account, schedule messages up to 20 days ahead, read conversations and messages, manage contacts, send schedules (allowed sending windows), webhooks for incoming and delivery events, and read phone heartbeats and monthly usage. Messages leave from the phone at its configured rate (10 per minute by default, at most 29), so a send is queued, not instant; you are responsible for the recipients' consent to receive SMS. Not exposed: the routes the Android app itself calls (receive, heartbeat, outgoing queue, message events, FCM token, phone registration), CSV or Excel uploads, the dashboard message search, phone API keys, API key rotation, webhook updates (a webhook update replaces its signing key, which is never returned; delete and recreate instead), Discord and 3CX integrations, subscription and invoice management and account deletion; MMS attachment links, phone push tokens, the account API key, webhook target URLs and webhook signing keys are not returned. Authentication is the API key from the httpSMS settings page, sent in the x-api-key header.

Connect httpSMS How integrations work

Ask it in chat

Say what should happen.
The workflow builds itself.

When this happens, do that in httpSMS.Built from the 29 httpSMS tools below, on the connection you add once.

What you can do with httpSMS

Each of these is one operation on one endpoint, available both as a workflow step and as a tool an AI agent can call on its own. Nothing bundles several operations into one action, so what a run did stays readable afterwards.

Most endpoints run on the free plan. A few, mainly the ones that publish on your behalf, need a paid plan.

Contact, 4 operations

create_contactsCreate contactsPOSTCreates one or many contacts in your httpSMS address book. Each item needs name and phone_numbers (E.164); emails and properties are optional.
delete_contactDelete contactDELETEPermanently deletes a contact from your httpSMS address book.
list_contactsList contactsGETLists your saved contacts (name, phone numbers, emails, custom properties). total is the count matching the filter, for paging with skip and limit.
update_contactUpdate contactPUTUpdates a contact. name and phone_numbers are required; read the contact with list_contacts first and send its current emails and properties back with your change.

Message thread, 4 operations

delete_message_threadDelete message threadDELETEPermanently deletes a conversation (thread) and all the messages in it from httpSMS.
get_message_threadGet message threadGETReturns one conversation (thread) of your account by id, with its last message, unread count and the matching saved contact when there is one.
list_message_threadsList message threadsGETLists conversations (threads) of one of your phone numbers, newest first, with the last message and unread count. Use the thread contact with list_messages.
update_message_threadUpdate message threadPUTArchives or unarchives a conversation, or sets its unread count. Send only the fields to change.

Send schedule, 4 operations

create_send_scheduleCreate send schedulePOSTCreates a send schedule (weekly sending windows in a timezone). Attach it to a phone in the httpSMS app settings.
delete_send_scheduleDelete send scheduleDELETEPermanently deletes a send schedule.
list_send_schedulesList send schedulesGETLists your send schedules: named weekly windows (in a timezone) during which a phone may send queued messages.
update_send_scheduleUpdate send schedulePUTReplaces a send schedule's name, timezone and windows (all three required): read it with list_send_schedules first and send the full set back with your change.

Message, 3 operations

delete_messageDelete messageDELETEPermanently deletes a message from httpSMS and removes its content from the thread list. It does not unsend an SMS already sent.
get_messageGet messageGETReturns one message by id: content, direction (type), status (pending, scheduled, sending, sent, delivered, failed, expired, received) and its timestamps.
list_messagesList messagesGETLists messages exchanged between one of your phone numbers (owner) and one contact number, newest first. Page with skip and limit.

Webhook, 3 operations

create_webhookCreate webhookPOSTCreates a webhook: httpSMS will POST the chosen events (received SMS, delivery, failures, phone offline) for your numbers to url, starting now. To change one, delete it and create a new one.
delete_webhookDelete webhookDELETEPermanently deletes a webhook; its events stop being delivered.
list_webhooksList webhooksGETLists your webhooks: id, subscribed events and phone numbers (target URLs are not returned). Page with skip and limit.

Billing usage, 2 operations

get_billing_usageGet billing usageGETReturns this month's usage summary for the account: counts of sent and received messages and the period start and end.
list_billing_usage_historyList billing usage historyGETLists past monthly usage records (sent and received message counts per period), newest first. Page with skip and limit.

Phone, 2 operations

delete_phoneDelete phoneDELETERemoves a registered phone from your httpSMS account; it can no longer send or receive through httpSMS until registered again in the app.
list_phonesList phonesGETLists the Android phones registered in your account with their number, SIM, send rate (messages_per_minute), retry and expiry settings and send schedule.

Sms, 2 operations

send_bulk_messagesSend bulk messagesPOSTSends the same real SMS to up to 1000 recipients from your Android phone, spaced at the phone's send rate. Returns one message per recipient.
send_messageSend messagePOSTSends a real SMS from your Android phone (queued at the phone's send rate). Set send_at to schedule it. Returns the message; read its status later with get_message.

User, 2 operations

get_current_userGet current userGETReturns the authenticated account: id (the userID other tools need), email, timezone, active phone, subscription and notification settings.
update_current_userUpdate current userPUTUpdates the account's timezone and active phone. Both are required: read get_current_user first and send the current value of the one you keep.

Bulk message order, 1 operation

list_bulk_message_ordersList bulk message ordersGETLists the last 10 bulk message orders with per-status counts (pending, scheduled, sent, delivered, failed, expired). request_id identifies the order.

Notification settings, 1 operation

update_notification_settingsUpdate notification settingsPUTSets the account's email notification switches. All four are required: read get_current_user (notification_* fields) first and send back the ones you keep.

Phone heartbeat, 1 operation

list_phone_heartbeatsList phone heartbeatsGETLists heartbeats (pings) sent by the Android phone for a number, newest first: use it to check the phone is online and charging, and which app version runs.

Use httpSMS from Claude Code, Cursor or Codex

Connect httpSMS in LiveContext, create an API key in Settings, then add the LiveContext MCP server to your client. Its httpSMS operations become tools the client can call, next to every other integration you connected.

Claude Code

claude mcp add --transport http livecontext https://livecontext.ai/mcp --header "X-API-Key: YOUR_API_KEY"

Codex (~/.codex/config.toml)

[mcp_servers.livecontext]
url = "https://livecontext.ai/mcp"

[mcp_servers.livecontext.http_headers]
"X-API-Key" = "YOUR_API_KEY"

Cursor, Claude Desktop and other JSON configs

{
  "mcpServers": {
    "livecontext": {
      "type": "http",
      "url": "https://livecontext.ai/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Set up the MCP server step by step

How to connect httpSMS

Create your workspace
Sign up free. Nothing to install.
Connect httpSMS once
Add your httpSMS connection in Settings. Every tool from this integration reuses it, and secrets are encrypted at rest and visible only to you.
Describe the job in chat
The workflow builds itself in front of you and picks the endpoints it needs. Drag the steps yourself on the canvas whenever you would rather be explicit.