• 228 destinations
  • No KYC, ever
  • Bitcoin, Monero, USDT and 4 more

DevelopersIntermediate7 min readUpdated 18 October 2026

SMPP vs HTTP API: which one do you actually need?

SMPP or an HTTP SMS API? Protocol differences, throughput maths, delivery receipts, retries and the few cases where running a bind is worth it.

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

AspectSMPPHTTP API
ConnectionLong-lived binds, keep-alives, window management, reconnect logicStateless HTTPS requests; any client works
AuthenticationSystem id and password at bind time, often with IP allowlisting on both sidesA bearer key on every request, optionally limited to an IP allowlist
EncodingYou set the data coding, split long texts and build concatenation headersThe platform detects the encoding, splits the text and returns the segment count and price
ReceiptsMessages on a receiver or transceiver bind, in a text format that varies by providerSigned webhook events carrying your own reference
RetriesNo idempotency: a lost response leaves you guessingAn idempotency key returns the original result
Flow controlWindow size, plus throttling errors from the providerRate-limit headers, and Retry-After on 429
OperationsBinds you run, monitor, fail over and allowlistCalls 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:

SMPP
id:IIIIIIIIII sub:001 dlvrd:001 submit date:YYMMDDhhmm done date:YYMMDDhhmm stat:DELIVRD err:000

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

Python
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-Remaining and slow down before you reach 429; on 429, wait for Retry-After.
  • Let the platform hold messages: send_at for a fixed moment and a local window for 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_coding 0 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_link interval 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.

Put it into practice.An email address opens the account. Rates are public, payment is crypto, and the test key is free.
Start sending

Something unclear or out of date? Tell us on the support page; corrections are folded back into the guide and the update date changes.