Skip to content
Android SMS Gateway · v1.0.4 now live

Turn your own Android phones into an SMS gateway.

Give your spare Android phone a new job: sending and receiving business SMS. Run an SMS gateway and two-way conversations with staff or your own bot over a clean REST API, and back up, search, and export your business SMS archive. Messages go out from your own SIM under your carrier's normal terms, with no SMSKit per-message fees. The Twilio alternative that runs on hardware you already own.

POST /api/v1/sms/send returns 202 Accepted

No credit card · Free forever for 1 phone · Public app downloads are currently unavailable

per-message fees
$0
per-message fees
sends per device
200/hr
sends per device

Built for OTP, alerts & two-way SMS in production

No SMSKit per-message fees Your carrier's normal terms Your own SIM Real delivery reports REST API and webhooks Fully managed

The gateway

Your API call, delivered over your own SIM.

One REST endpoint connects your backend to the Android phones you already own. SMSKit queues, routes, and wakes a device: the SMS goes out from your own SIM under your carrier's normal terms.

1

Your app

POST /api/v1/sms/send

A clean REST API and your API key

2

SMSKit gateway

Queue, route, retry

Picks the best device and SIM

3

Your Android phone

Native SmsManager

Woken by a high-priority push

4

Delivered

Over your own SIM

From the number your customers know

Two-way conversations

Your number. Your customers. Your own bot.

Customers text the number they already know. Staff or your own bot answers through SMSKit. SMSKit carries the messages; you connect and run the bot.

  1. 1. A customer texts you.

    They send an SMS to your business's normal number.

  2. 2. SMSKit receives it.

    It reaches the Standard dashboard inbox and the signed sms:received webhook.

  3. 3. You write the answer.

    Staff reply in the inbox, or your own bot answers the customer who texted first.

  4. 4. Reply from the same number.

    Name the same phone and SIM: your bot passes the event's deviceId and simSlot; staff pick them in the dashboard reply box.

Why the usual chatbot routes hurt

  • Alphanumeric sender ID: Customers cannot reply to a sender name.
  • Short code: Carrier approval and setup fees; customer reply charges depend on the market.
  • Twilio or another aggregator: Inbound and outbound message charges, longer answers billed in segments, and local two-way number availability varies by market.
  • WhatsApp Business API: Meta business verification to scale, approved templates outside the 24-hour reply window, and template charges that depend on category; customers need WhatsApp and data.
  • GSM modem: Hardware to buy and a server to run.
  • SMSKit: Your existing phone and SIM, the number customers already text, and a flat price per phone with unlimited messages. Carrier charges and limits still apply.

Provider rules checked 13 October 2026: sender rules, SMS pricing, WhatsApp rules.

Explore two-way SMS
import hashlib, hmac, json, os, time
from urllib.request import Request, urlopen

STOP_WORDS = {"STOP", "STOPALL", "UNSUBSCRIBE", "CANCEL", "END", "QUIT"}
opted_out = set()  # In production, save this to durable storage.

def ask_bot(message):
    """Placeholder for the business's own bot."""
    raise NotImplementedError("Connect your own bot here")

def receive_sms(headers, raw_body):
    """Verify an incoming event and send its answer through the event's phone and SIM."""
    ts = headers.get("X-SMSKit-Timestamp", "")
    signature = headers.get("X-SMSKit-Signature-256", "")
    if not ts.isascii() or not ts.isdigit() or abs(time.time() - int(ts)) > 300:
        raise ValueError("Invalid webhook timestamp")
    expected = hmac.new(
        os.environ["SMSKIT_WEBHOOK_SECRET"].encode(),
        ts.encode() + b"." + raw_body, hashlib.sha256
    ).hexdigest()
    if not hmac.compare_digest(expected, signature):
        raise ValueError("Invalid webhook signature")
    event = json.loads(raw_body)
    if event["event"] != "sms:received":
        return
    sender = event["sender"]
    if event["messageBody"].strip().upper() in STOP_WORDS:
        opted_out.add(sender)  # Record the opt-out and send nothing.
        return
    if sender in opted_out:
        return
    if not event.get("deviceId") or type(event.get("simSlot")) is not int or event["simSlot"] not in (0, 1):
        raise ValueError("Missing reply phone or SIM")
    payload = {
        "recipient": sender,
        "message": ask_bot(event["messageBody"]),
        "devices": [{"deviceId": event["deviceId"], "simSlots": [event["simSlot"]]}],
        "idempotencyKey": event["eventId"]
    }
    request = Request("https://api.smskit.cloud/api/v1/sms/send",
        data=json.dumps(payload).encode(), method="POST",
        headers={"X-Api-Key": os.environ["SMSKIT_API_KEY"], "Content-Type": "application/json"})
    with urlopen(request, timeout=15) as response:
        return json.load(response)

Connect receive_sms() to your webhook route with the exact raw request bytes and headers. Set the webhook secret and API key in your environment. Replace ask_bot() with your bot. This compact example sends inline. In production, split verification from reply work: verify on receipt, durably queue the verified event and return 2xx, then let a worker answer. Retain event IDs to deduplicate retries beyond job retention.

Webhooks work on every plan, including Free's one evaluation webhook. The inbox and messages API for conversation history need Standard. Your bot handles opt-outs, consent and handoff to staff. Replies typed directly on the phone reach the archive through a later scan, without firing a webhook.

The archive

The memory behind your conversations.

The phones you connect already hold business SMS. On Standard, run a one-shot import of that history (up to 90 days and 5,000 messages), keep it with what you send and receive through SMSKit, and export it within the 30-day retention window.

Import what already exists

Pull the inbox and sent history already on your phone into your account: the messages that predate SMSKit, and the texts sent from the phone's own app.

One searchable timeline

Received, SMSKit-sent, and imported messages merge into a single two-way thread per contact, with numbers resolved to names and the SMSKit-sent ones marked.

Export & retain

Keep a portable record for the retention period on your plan (30 days on Standard). Bulk-export it to NDJSON or CSV, or pull it over the API.

Aggregator SMS is expensive, slow, and gets filtered.

You pay per message, even when it fails.

Twilio and aggregators bill every send, delivered or not. Costs scale with every OTP.

Registration adds a wait.

Business texting on aggregator numbers needs carrier registration, and approval takes time before you can send.

Short codes get flagged.

Shared sender IDs land in spam. Your OTP arrives late, or never. Conversions drop.

There's a simpler path: send from a real phone, on a real SIM, that carriers already trust.

How it works

From API call to delivered SMS in four steps.

  1. 1

    Pair a phone

    Public app downloads are currently unavailable. Existing installations can pair through Devices in the dashboard.

  2. 2

    Call the API

    From your backend, POST /api/v1/sms/send with a recipient and a message, authenticated by your API key. We queue the message and pick the best device and SIM.

  3. 3

    We wake your phone

    A high-priority push (FCM) wakes the app even if it's idle. It pulls the job and sends the SMS through Android's native SmsManager over your real SIM.

  4. 4

    Track everything

    The phone reports back: sent, delivered, or failed. See it in the dashboard, poll the job-status endpoint, and receive webhooks. Replies come back as sms:received.

Developers

Send your first SMS in three lines.

Send JSON to one REST endpoint and get a job id back. The same API call works from any language; these examples show three.

curl https://api.smskit.cloud/api/v1/sms/send \
  -H "X-Api-Key: sk_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{ "recipient": "+254712345678", "message": "Your code is 123456" }'

Features

Everything you need to run SMS in production.

Multi-device & multi-SIM routing

Spread sends across every phone and SIM you connect.

Two-way messaging

Connect your own chatbot for replies; use the Standard inbox for staff conversations. Name the phone and SIM to reply from the same number.

Webhooks

Events for sms:sent, sms:delivered, sms:failed and sms:received, with retries and backoff.

Delivery reports

Check delivery status for each carrier and SIM as well as acceptance status.

Retry and dead-letter

Failed sends retry across devices. Exhausted jobs land in a dead-letter queue.

Per-device throttling

Set an hourly send limit for each device to control your sending rate. Carrier restrictions still apply.

Real-time dashboard

Watch devices, jobs, and inboxes update live.

Idempotency keys

While the original job is retained, reuse its idempotency key to retry without creating another job. Delivery retries can still produce duplicate SMS.

Priority routing

Push OTPs ahead of bulk traffic (priority 0–10).

Business SMS archival

Back up, search, and export your phone's existing inbox and sent history, plus what you send and receive through SMSKit (Standard plan).

Built like infrastructure.

Observability included.

Production monitoring includes Prometheus metrics, health checks, and PII-masked structured logging.

Fully managed, zero ops.

No servers to run, nothing to deploy. We operate the backend, push, routing, and dashboard; you bring Android phones and send.

Your own SIM, not a shared short code.

Aggregators (Twilio, etc.)SMSKit
Cost Per message, forever $5/phone/month, unlimited sends
Registration Carrier registration for business texting, then a wait Your carrier's normal terms for your own SIM
Sender Shared short code (dedicated numbers cost extra) Your real phone number
Deliverability Depends on route: can be filtered or flagged Sent from your own number as a normal text

SMSKit is built for your own controlled volume: ideal for OTP, alerts, and two-way, not unsolicited mass marketing.

Read the full SMSKit vs Twilio comparison

Pricing

One price, per phone.

Free

For testing and small projects.

$0

Free forever

  • 1 phone
  • 50 SMS / day
  • 1 SIM
  • 1-day history
  • 1 webhook (all events)
  • 1 API client
  • Community support

Standard

Most popular

For production. Add as many phones as you need.

$5 / month

per phone · billed monthly

  • Unlimited phones: $5 each
  • Unlimited messages *
  • Unlimited SIMs
  • 30-day history
  • Two-way inbox
  • Webhooks (full, with retries)
  • Unlimited API clients
  • Priority support

Questions, answered.

What is A2P 10DLC, and does it apply to me?

A2P 10DLC is US carrier registration for business texting on 10-digit numbers. SMSKit sends from your own SIM under your carrier's terms. SMSKit does not promise any exemption, and carriers can still filter business traffic. Check your carrier's rules for your use.

What does it cost?

$5 per phone per month, unlimited messages. A free tier covers 1 phone for testing.

Do I need a new phone?

No. A compatible phone you already own can do the job. It needs Android 8.0 or newer, a working SIM and an internet connection.

Can I receive replies?

Yes. Two-way messaging and conversation threading are on the Standard plan, and sms:received webhooks work on every plan.

Is there a limit on how many SMS I can send?

No account-level cap on a paid phone. A per-device hourly limit (default 200/hr) controls your sending rate. Carrier restrictions still apply.

Can I back up the messages already on my phone?

Yes, on the Standard plan. Business SMS Archival syncs new SMS after phone consent and imports older inbox and sent history into your account, merges it with the messages you send and receive through SMSKit into one searchable timeline, and lets you export it (NDJSON/CSV) or pull it over the API.

Explore SMSKit

Read the documentation or use your existing account. Public app downloads are currently unavailable.