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.
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
SMSKit OTP
+254 712 345 678
Built for OTP, alerts & two-way SMS in production
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.
Your app
POST /api/v1/sms/send
A clean REST API and your API key
SMSKit gateway
Queue, route, retry
Picks the best device and SIM
Your Android phone
Native SmsManager
Woken by a high-priority push
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. A customer texts you.
They send an SMS to your business's normal number.
2. SMSKit receives it.
It reaches the Standard dashboard inbox and the signed sms:received webhook.
3. You write the answer.
Staff reply in the inbox, or your own bot answers the customer who texted first.
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 SMSimport 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
Pair a phone
Public app downloads are currently unavailable. Existing installations can pair through Devices in the dashboard.
- 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
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
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.
Pricing
One price, per phone.
Free
For testing and small projects.
Free forever
- 1 phone
- 50 SMS / day
- 1 SIM
- 1-day history
- 1 webhook (all events)
- 1 API client
- Community support
Standard
Most popularFor production. Add as many phones as you need.
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.