SMPP & REST API Developer Hub

Production-grade SMS integration. High-throughput SMPP v3.4 binds, RESTful HTTP API, TLV support, DLR callbacks and webhook delivery receipts — everything you need to integrate at scale.

Request API Key Developer Sandbox
99.95%
Platform Uptime
< 2s
Avg. Delivery Time
10,000+
TPS SMPP Capacity
190+
Countries Covered
SMPP v3.4
Protocol Support
TLS 1.3
Encrypted Connections
Getting Started

Quick Start

Send your first SMS in under 5 minutes. All you need is your API key.

# Send an SMS via the SBS TELECOM REST API
curl -X POST https://portal.sbstelecom.net/api/v1/sms \
  -u "YOUR_API_KEY:YOUR_API_SECRET" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: order-4471-sms" \
  -d '{
    "to": "+447911123456",
    "from": "SBSTEL",
    "text": "Hello from SBS TELECOM!"
  }'

# Response — 202 Accepted
{
  "message_id": "5f3c1b9a2e444c8a9f107b2d6c1e4a33",
  "status":     "queued",
  "to":         "+447911123456",
  "from":       "SBSTEL",
  "charged":    true,
  "cost":       0.0175,
  "balance":    499.7025
}
<?php
$ch = curl_init('https://portal.sbstelecom.net/api/v1/sms');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_USERPWD        => 'YOUR_API_KEY:YOUR_API_SECRET',
    CURLOPT_HTTPHEADER     => [
        'Content-Type: application/json',
        'Idempotency-Key: order-4471-sms',
    ],
    CURLOPT_POSTFIELDS     => json_encode([
        'to'   => '+447911123456',
        'from' => 'SBSTEL',
        'text' => 'Hello from SBS TELECOM!',
    ]),
]);
$res = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $res['message_id'];
import requests

response = requests.post(
    'https://portal.sbstelecom.net/api/v1/sms',
    auth=('YOUR_API_KEY', 'YOUR_API_SECRET'),
    headers={'Idempotency-Key': 'order-4471-sms'},
    json={
        'to':   '+447911123456',
        'from': 'SBSTEL',
        'text': 'Hello from SBS TELECOM!',
    },
)
response.raise_for_status()
print(response.json()['message_id'])
const auth = Buffer.from('YOUR_API_KEY:YOUR_API_SECRET').toString('base64');

const response = await fetch('https://portal.sbstelecom.net/api/v1/sms', {
  method: 'POST',
  headers: {
    'Authorization':   `Basic ${auth}`,
    'Content-Type':    'application/json',
    'Idempotency-Key': 'order-4471-sms',
  },
  body: JSON.stringify({
    to:   '+447911123456',
    from: 'SBSTEL',
    text: 'Hello from SBS TELECOM!',
  }),
});

const { message_id, status } = await response.json();
console.log(`Sent: ${message_id} — ${status}`);
Coming Soon

Developer Sandbox

A dedicated sandbox for testing integrations without touching live traffic is on our roadmap. It is not available yet — no sandbox API endpoint, SMPP sandbox host or DLR simulation is currently offered.

Testing today

Integrate against your live account and send to a handset you control. Every message is charged at your normal rate, so testing costs are small and predictable.

Testing safely

Use an Idempotency-Key on every request while you develop. A repeated key never sends or charges twice, so re-running a test script cannot produce duplicate traffic.

Checking delivery

Poll GET /api/v1/sms/{id} for the real delivery outcome, or configure a DLR webhook in your portal to receive receipts as they arrive.

Need a sandbox?

If isolated test credentials would unblock your integration, let us know and we will factor it into the roadmap.

Contact Sales
REST API

Authentication

All API requests are authenticated with an API key and secret pair, issued in your client portal. Supply them as HTTP Basic credentials, as X-API-Key and X-API-Secret headers, or as a colon-separated bearer token.

HeaderValueRequired
AuthorizationBasic <base64 of KEY:SECRET> or Bearer <KEY>:<SECRET>Required
Content-Typeapplication/jsonRequired
Idempotency-KeyAny unique string. Re-sending the same key never delivers or charges twiceOptional
X-API-Key / X-API-SecretAlternative to Basic auth — supply the pair as two headersOptional
Security best practice: Use separate API keys for production and development. Keys can be scoped to specific IPs and rotated in your client portal without downtime.
REST API

Send SMS

POST /api/v1/sms

Request Body

ParameterTypeRequiredDescription
tostringRequiredE.164 format recipient number (+447911123456)
fromstringRequiredAlphanumeric sender ID (max 11 chars) or number
textstringRequiredMessage content. Multi-part handled automatically
Coming Soon

Bulk Messaging

A dedicated bulk/batch submission endpoint is on our roadmap. It is not available yet — there is currently no batch endpoint, and no batch identifiers or status URLs are issued.

Sending at volume today

Submit each message with POST /api/v1/sms and send concurrently. Your account’s throughput allowance governs the rate; the API returns 429 with a Retry-After header when you exceed it.

Making retries safe

Send an Idempotency-Key with every request. Re-sending the same key never delivers or charges twice, which makes a failed batch safe to replay in full.

Very high volumes

For sustained high-throughput traffic, our SMPP v3.4 binds are the supported route today and are documented below.

Need batch submission?

Tell us about your use case — customer demand shapes what we build next.

Contact Sales
REST API

DLR Webhooks

SBS TELECOM posts real-time delivery receipts to the webhook URL configured in your client portal, via HTTP POST. Respond with 200 OK to acknowledge.

# Incoming DLR webhook POST payload
{
  "message_id":    "5f3c1b9a2e444c8a9f107b2d6c1e4a33",
  "batch_id":      "batch_01HX9A2B3C4D5E6F7G8H",
  "to":            "+447911123456",
  "from":          "SBSTEL",
  "status":        "DELIVRD",
  "err_code":      0,
  "err_desc":      "Message delivered",
  "submitted_at":  "2026-03-26T10:00:00Z",
  "delivered_at":  "2026-03-26T10:00:01Z",
  "network":       "EE UK",
  "mcc":           "234",
  "mnc":           "30"
}
StatusDescription
DELIVRDMessage delivered to handset
ACCEPTDAccepted by carrier, delivery pending
UNDELIVUndeliverable — invalid number or network error
REJECTDRejected by carrier — content or sender ID issue
EXPIREDValidity period elapsed before delivery
UNKNOWNNo DLR received from downstream carrier
Webhook security: Validate the X-SBS-Signature header (HMAC-SHA256) against your webhook secret to verify authenticity of all incoming DLR callbacks.
REST API

Error Codes

HTTPCodeDescription
400INVALID_NUMBERRecipient number is not valid E.164 format
400INVALID_SENDERSender ID exceeds 11 chars or uses disallowed chars
400TEXT_TOO_LONGMessage exceeds 1600 characters (10 SMS parts)
401INVALID_API_KEYAPI key missing, expired or revoked
402INSUFFICIENT_CREDITAccount balance below minimum threshold
403COUNTRY_BLOCKEDDestination country not enabled on your account
429RATE_LIMITEDToo many requests — back-off and retry with exponential delay
503GATEWAY_UNAVAILABLETemporary upstream issue — retry after Retry-After seconds
SMPP Protocol

SMPP v3.4 Overview

SBS TELECOM operates a purpose-built SMPP infrastructure supporting both SMPP v3.3 and v3.4. Designed for high-throughput platforms — fintechs, enterprise aggregators and OTP-heavy applications.

High-Throughput Binds

Up to 10,000 TPS per transceiver bind. Multiple concurrent binds supported for horizontal scaling.

TLS Encryption

All SMPP connections support TLS 1.2/1.3 on port 2776. Plain-text on port 2775 for legacy clients.

TLV Support

Full optional parameter (TLV) support including receipted_message_id, message_state, network_error_code and custom tags.

Unicode & Long SMS

GSM7, UCS-2 (Unicode) and 8-bit binary. Automatic segmentation and reassembly using SAR TLVs or UDH.

SMPP Protocol

Connection Parameters

ParameterValueNotes
Hostsmpp.sbstelecom.co.ukProduction endpoint
Port (plain)2775Standard SMPP — legacy clients only
Port (TLS)2776Recommended — TLS 1.2 / 1.3
ProtocolSMPP v3.3 / v3.4v3.4 recommended
system_idProvided on account creationUsed for bind authentication
passwordMax 8 charactersRotatable in client portal
system_typeSMS or leave blankAccount-specific value if required
enquire_linkEvery 30 secondsRequired — idle connections terminated after 60s
Encodingdata_coding=0 (GSM7), 8 (UCS-2)See encoding table
SMPP Protocol

Bind Types

bind_transmitter

MO only — outbound SMS submission. Use when you only need to send messages and handle DLRs via HTTP webhook rather than SMPP deliver_sm.

command_id: 0x00000002

bind_receiver

Inbound only — receive DLR callbacks and inbound SMS (MO) over the SMPP connection as deliver_sm PDUs.

command_id: 0x00000001

bind_transceiver Recommended

Bidirectional — send and receive on a single connection. Recommended for high-throughput deployments and OTP platforms requiring low-latency DLRs.

command_id: 0x00000009
SMPP Protocol

TLV (Optional) Parameters

SBS TELECOM supports the full SMPP v3.4 optional parameter set. Key TLVs for enterprise integrations:

TagHexDirectionDescription
receipted_message_id0x001EDLROriginal message ID in delivery receipts. Use to correlate DLRs with submissions
message_state0x0427DLRFinal delivery state: 1=ENROUTE, 2=DELIVERED, 3=EXPIRED, 5=UNDELIVERABLE, 6=ACCEPTED
network_error_code0x0423DLR3-byte field: network type byte + 2-byte error code from carrier
sar_msg_ref_num0x020CSubmitReference number for long message segmentation (SAR). Use with sar_total_segments / sar_segment_seqnum
sar_total_segments0x020ESubmitTotal number of segments in a concatenated message
sar_segment_seqnum0x020FSubmitSequence number of this segment (1-based)
dest_addr_subunit0x0005SubmitFlash SMS: set to 0x01 for Class 0 (display-only) messages
user_message_reference0x0204SubmitYour internal reference ID. Echoed back in DLR deliver_sm
callback_num0x0381SubmitReply-to number for MO responses

TLV Example — DLR Parsing

# Python: Parse TLV fields from deliver_sm DLR
def parse_dlr_tlvs(pdu):
    msg_id   = pdu.get_tlv(0x001E)  # receipted_message_id
    state    = pdu.get_tlv(0x0427)  # message_state (1=delivered, 5=undeliverable)
    err_code = pdu.get_tlv(0x0423)  # network_error_code

    if state == 2:
        mark_delivered(msg_id)
    elif state == 5:
        net_type = err_code[0]
        net_err  = int.from_bytes(err_code[1:3], 'big')
        mark_failed(msg_id, net_type, net_err)
SMPP Protocol

DLR & Callbacks over SMPP

Request DLRs on submit_sm by setting registered_delivery. Receipts arrive as deliver_sm PDUs on your receiver or transceiver bind.

registered_deliveryBehaviour
0x00No DLR requested
0x01DLR on final delivery or failure only
0x02DLR on delivery failure only
0x03DLR on delivery success only
0x10Intermediate DLRs (enroute state updates)
0x11All DLRs — success, failure and intermediate (recommended for OTP)
# submit_sm field summary for OTP with full DLR
submit_sm:
  source_addr:          "SBSBANK"
  dest_addr:            "+447911123456"
  short_message:        "Your OTP is 482910. Valid for 5 minutes."
  data_coding:          0          # GSM7
  registered_delivery:  0x11       # All DLRs
  validity_period:      "000000000005000R"  # 5 minute expiry
  TLVs:
    user_message_reference: "TXN-98765-OTP"   # your internal ref
SMPP Protocol

Throughput & Window Sizing

Window Size

Default window size is 10 outstanding PDUs. Enterprise accounts can request up to 100 PDUs per bind for maximum throughput.

Multiple Binds

Scale horizontally by opening multiple transceiver binds. Each bind runs independently — ideal for load-balanced microservices.

Throughput Limits

Standard accounts: 100 TPS. Enterprise: 10,000 TPS per bind. Contact sales for high-volume OTP or financial alerting requirements.

enquire_link: Send an enquire_link PDU every 30 seconds on idle connections. Connections without activity for 60 seconds will be closed by the server. Implement automatic reconnect with exponential back-off.
Code Samples

PHP — Send with DLR Webhook

<?php
/**
 * SBS TELECOM — Send SMS with DLR webhook (PHP)
 * $apiCreds is your API key and secret as "KEY:SECRET".
 */
function sbstelSendSMS(string $apiCreds, array $params): array {
    $ch = curl_init('https://portal.sbstelecom.net/api/v1/sms');
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode($params),
        CURLOPT_HTTPHEADER     => [
            "Authorization: Bearer {$apiCreds}",
            'Content-Type: application/json',
        ],
        CURLOPT_TIMEOUT        => 10,
    ]);
    $body     = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode !== 200) {
        throw new \RuntimeException("SMS API error {$httpCode}: {$body}");
    }
    return json_decode($body, true);
}

// Usage
$result = sbstelSendSMS('YOUR_API_KEY:YOUR_API_SECRET', [
    'to'           => '+447911123456',
    'from'         => 'SBSTEL',
    'text'         => 'Your verification code is 482910',
]);
echo "Sent: {$result['message_id']}";

// DLR webhook handler
$dlr = json_decode(file_get_contents('php://input'), true);
$sig = $_SERVER['HTTP_X_SBS_SIGNATURE'] ?? '';
$expected = hash_hmac('sha256', file_get_contents('php://input'), 'YOUR_WEBHOOK_SECRET');

if (!hash_equals($expected, $sig)) {
    http_response_code(403); exit;
}

if ($dlr['status'] === 'DELIVRD') {
    markDelivered($dlr['message_id']);
}
http_response_code(200);

Ready to Build?

Get your API credentials, explore the sandbox and integrate in minutes. Our engineering team is available for technical onboarding calls.