What each one is
SMPP (Short Message Peer-to-Peer) is a binary protocol over a persistent TCP session. A client, an ESME in the specification's terms, binds to a server as a transmitter, a receiver or a transceiver, submits messages as protocol data units (submit_sm) and receives delivery receipts and inbound messages on a bind (deliver_sm). Keep-alives (enquire_link) hold the session open. Version 3.4 is the one most deployments speak. It was designed for operators and aggregators exchanging thousands of messages per second, and it remains the wholesale protocol between them.
An HTTP API maps the same operations onto web requests: a POST creates a message, a GET reads its status, a webhook pushes the delivery receipt. Each request stands alone, carries its own key and travels over HTTPS, so any language, any server and any serverless function can use it. The SMPP glossary entry has the vocabulary.
Side by side
| Aspect | SMPP | HTTP API |
|---|---|---|
| Connection | Long-lived binds, keep-alives, window management, reconnect logic | Stateless HTTPS requests; any client works |
| Authentication | System id and password at bind time, often with IP allowlisting on both sides | A bearer key on every request, optionally limited to an IP allowlist |
| Encoding | You set the data coding, split long texts and build concatenation headers | The platform detects the encoding, splits the text and returns the segment count and price |
| Receipts | Messages on a receiver or transceiver bind, in a text format that varies by provider | Signed webhook events carrying your own reference |
| Retries | No idempotency: a lost response leaves you guessing | An idempotency key returns the original result |
| Flow control | Window size, plus throttling errors from the provider | Rate-limit headers, and Retry-After on 429 |
| Operations | Binds you run, monitor, fail over and allowlist | Calls from anywhere, including serverless functions |
The segment arithmetic is the same on both sides: 153 GSM-7 or 67 Unicode characters per part once a message is split. The difference is who does it; the encoding guide explains the sizes.
Throughput maths
On SMPP, a bind's ceiling is roughly its window divided by the round-trip time, capped by whatever rate the provider grants. Say a window of 10 and a round trip of 50 ms: 10 ÷ 0.05 = 200 PDUs per second at most. A three-part message sent with concatenation headers is three submit_sm PDUs, so the same bind carries about 67 three-part messages a second. More throughput means more binds, and every bind is a connection to keep healthy.
Over HTTP the arithmetic is simpler. The rate limit is 50 requests per second per key, and a batch of up to 1,000 messages counts as one request:
- single requests: 50 messages a second, or 50 × 3,600 = 180,000 an hour;
- batches: a submission ceiling of 50 × 1,000 = 50,000 messages a second per key;
- 300,000 reminders: 300 batch requests, which take 6 seconds at the full rate (300 ÷ 50) or a minute at a relaxed 5 requests a second.
Latency sets the concurrency you need, not the ceiling. With a 200 ms round trip, a client that waits for each answer makes 5 requests a second; reaching 50 takes about 10 requests in flight (50 × 0.2). Both protocols only govern submission: how fast messages reach handsets depends on the destination networks, whichever protocol carried them to the provider.
Delivery receipts
On SMPP you request a receipt in the registered_delivery field of each submission, and it comes back as a deliver_sm on a receiver or transceiver bind. Its text usually follows the example format in an appendix of the 3.4 specification:
id:IIIIIIIIII sub:001 dlvrd:001 submit date:YYMMDDhhmm done date:YYMMDDhhmm stat:DELIVRD err:000That format is an example, not a rule, and providers vary: the message id may be hexadecimal in the submit response and decimal in the receipt, err values differ from one network to the next, and receipts that arrive while your receiver bind is down are queued, retried or dropped according to the provider's own policy. Matching receipts to messages is code you write and maintain.
Over HTTP the receipt is a signed webhook event, message.sent, message.delivered or message.failed, carrying the reference you set on the message, and a failure comes with a plain reason and the raw carrier code. Events your endpoint misses are retried 6 times over 24 hours and can be replayed from the panel for 30 days; webhooks in production covers the handler. Neither protocol improves what the network returns: most destinations give handset receipts, a few only carrier acknowledgement, and there sent is the final positive state.
Retries and duplicates
SMPP has no idempotency. If a submit_sm times out, or the bind drops with PDUs in the window, you cannot tell whether the message was accepted: resubmitting risks a duplicate, not resubmitting risks a loss. Asking does not settle it, because query_sm needs the message id that the lost response would have carried. Throttling errors such as ESME_RTHROTTLED are the easy case: the message was refused, so back off and submit again.
Over HTTP, send an Idempotency-Key derived from your own record and reuse it on every retry. A retry with the same key returns the original result instead of sending again, so a timeout costs a second request, never a second message.
import time, requests
def send(base_url, api_key, message, idem_key):
headers = {"Authorization": "Bearer " + api_key, "Idempotency-Key": idem_key}
for attempt in range(5):
try:
r = requests.post(base_url + "/v1/messages", json=message,
headers=headers, timeout=10)
except requests.RequestException:
time.sleep(2 ** attempt) # network error: same key, try again
continue
if r.status_code == 429:
time.sleep(float(r.headers.get("Retry-After", "1")))
continue
if r.status_code >= 500:
time.sleep(2 ** attempt)
continue
return r # 2xx, or a 4xx to fix, not retry
raise RuntimeError("unconfirmed: retry later with the same idem_key")Batches add one rule. A malformed batch is refused whole, but a batch with a few bad items queues the valid ones and returns the others as rejected with their error: fix and resend only the rejected items, in a new request with a new key.
When SMPP is justified
When you are yourself an aggregator or a platform reselling traffic to partners who speak SMPP; when you sustain hundreds of messages per second around the clock and a provider grants binds sized for it; or when an existing system only speaks SMPP and replacing it is not an option. For an application sending codes, notifications and campaigns, it adds cost and failure modes without adding delivery. Three beliefs keep it in requirement documents where it does not belong:
- "SMPP delivers better." Delivery depends on the route from the provider to the operator; the protocol between you and the provider does not change it.
- "SMPP is faster." Either protocol adds milliseconds; the time a message spends in operator networks is usually far longer.
- "SMPP is cheaper." Where a provider offers both, the price per message usually follows the destination, not the protocol. What SMPP adds is the cost of running binds, and that falls on you.
Getting volume out of HTTP
Volume over HTTP comes from batching, not from parallel single requests. One batch request carries up to 1,000 messages with per-message results; at 50 requests per second that is far more than most senders will ever need. A few habits keep it smooth:
- Read
X-RateLimit-Remainingand slow down before you reach 429; on 429, wait forRetry-After. - Let the platform hold messages:
send_atfor a fixed moment and a localwindowfor local-time delivery replace timers on your side. - Receive results by webhook rather than by polling; polling 300,000 messages one by one is 300,000 requests you did not need.
- Give each sending system its own key, since the limit applies per key.
If you do need SMPP
Ask the provider before you sign:
- Which version, and is the session protected by TLS or a VPN? Plain SMPP sends the password in clear text.
- How many binds, of which types, at what throughput each, and with what window size?
- What does
data_coding0 mean on their side: GSM-7, Latin-1 or something else? - How should long messages travel: concatenation headers, SAR parameters or
message_payload? - What is the receipt format, is the message id hexadecimal or decimal, and how are error codes mapped?
- What happens to receipts while your receiver bind is down, and for how long?
- Which
enquire_linkinterval and idle timeout do they expect?
What SMSMeteor offers
A REST API with bearer keys (sk_live_ and sk_test_), send and read scopes and an optional IP allowlist per key; single messages and batches of up to 1,000; idempotency keys; scheduling with send_at, local-time windows and pacing on batches; signed webhooks with retries and replays; an OpenAPI description; and SDK samples in cURL, Python, Node, PHP and Go. Test keys validate, price and answer like live ones without sending or billing. SMPP is not offered to accounts. If your system can only speak SMPP, you need a provider that offers binds, and it is better to know that before you integrate.
Something unclear or out of date? Tell us on the support page; corrections are folded back into the guide and the update date changes.
