SMS Gateway API India: The Complete Developer Integration Guide 2026
- TechTo Networks
- Jul 1, 2025
- 15 min read
Every time a user logs into your app, completes a payment, or receives a delivery update in India, an SMS Gateway API is doing the work invisibly in the background.
But not all SMS Gateway APIs are built the same — and in India, the gap between a well-integrated API and a poorly chosen one shows up as OTP failures, blocked promotional messages, DLT rejections, and delivery delays that cost you conversions you will never see in your analytics.
This is the complete developer guide to SMS Gateway API integration in India for 2026. It covers how SMS gateway APIs work at the protocol level, the difference between REST, HTTP, and SMPP, how to pass DLT-compliant parameters correctly, how to handle delivery webhooks, how to read and respond to error codes from Indian telecom operators, and how to integrate TechTo Networks' SMS API in Python, Node.js, PHP, and Java — with working code you can run today.
What Is an SMS Gateway API?
An SMS Gateway API is a programmatic interface that allows your application to send and receive SMS messages by making HTTP or SMPP requests to a provider's gateway server, which then routes the message to the correct telecom operator and delivers it to the subscriber's mobile device.
The "gateway" sits between your application and India's telecom networks — Jio, Airtel, Vodafone Idea, and BSNL. Without a gateway, your application has no way to communicate with these operator networks directly. The gateway handles the complexity of operator connections, DLT compliance validation, message routing, delivery tracking, and failover — exposing a clean, simple API to your application.
At the network layer, an SMS travels through the following path:
Your Application
↓ (API call over HTTPS)
SMS Gateway (TechTo Networks)
↓ (DLT validation: entity ID, template ID, header)
TRAI DLT Registry
↓ (Route selection: Tier-1 SMPP bind)
Telecom Operator SMSC (Jio / Airtel / Vi / BSNL)
↓ (Network delivery to tower)
Subscriber's Mobile Device
↑ (Delivery receipt back through the chain)
Your Webhook Endpoint
Understanding this path is critical because each step has specific requirements and potential failure points. The DLT validation step — unique to India — is where most integration failures originate for businesses new to the Indian SMS market.
SMS Gateway API Protocols: REST vs HTTP vs SMPP
There are three protocols through which you can connect to an SMS gateway. Choosing the wrong one for your use case has real consequences on delivery speed, throughput, and cost.
REST API (Recommended for 95% of Use Cases)
A REST (Representational State Transfer) SMS API communicates over standard HTTPS using JSON request and response bodies. It is stateless — each API call is independent — and uses standard HTTP verbs (POST for sending, GET for status checks).
Best for: Web applications, mobile backends, CRM integrations, serverless functions, microservices. Throughput: Up to 100–300 messages per second depending on your plan. Latency per call: 100–400ms API response time. Authentication: API key in HTTP header or Bearer token. Why choose it: Easy to implement in any language, works with standard HTTP libraries, no persistent connection management required.
HTTP GET/POST API (Legacy, Simpler)
An HTTP API sends SMS parameters as URL query strings (GET) or form-encoded POST body. It is simpler than REST but less flexible — no JSON, no structured error responses, limited webhook support.
Best for: Legacy PHP applications, simple notification scripts, WordPress plugins, quick prototypes. Throughput: Up to 50–100 messages per second. Why choose it: Easiest to implement with basic curl or file_get_contents. Why avoid it: Query string parameters are logged in server access logs, exposing your API key. Use REST for anything in production.
SMPP (Short Message Peer-to-Peer)
SMPP is a binary protocol that creates a persistent, stateful TCP connection directly to the gateway's SMSC. It is the protocol used by telecom operators themselves and offers the highest possible throughput and lowest latency.
Best for: High-volume transactional systems (>500 TPS), OTP platforms sending millions of messages daily, telco-grade applications. Throughput: 500–3,000+ messages per second per bind. Latency: 50–150ms end-to-end. Why choose it: Lowest latency, highest throughput, most direct operator path. Why avoid it: Requires persistent TCP connection management, heartbeat/enquire_link handling, complex error handling. Overkill for most businesses.
Feature | REST API | HTTP API | SMPP |
Protocol | HTTPS/JSON | HTTP GET/POST | Binary TCP |
Throughput | 100–300 TPS | 50–100 TPS | 500–3,000+ TPS |
Latency | 100–400ms | 100–400ms | 50–150ms |
Implementation complexity | Low | Very Low | High |
Persistent connection | No | No | Yes |
Best for | Most use cases | Legacy apps | High volume |
DLT parameter support | Full | Full | Full |
Webhook support | Yes | Limited | Via bind |
Recommended | ✅ Yes | Legacy only | High volume only |
TechTo Networks recommendation: Use the REST API unless you are sending more than 500 OTPs per second at peak. At that volume, contact our team to set up an SMPP bind on a dedicated IP.
DLT-Compliant SMS API: India-Specific Parameters
This is the section that separates a working Indian SMS API integration from one that sends silently and delivers nothing.
TRAI's DLT (Distributed Ledger Technology) system requires three mandatory parameters in every SMS API call in India — for transactional, promotional, and OTP messages alike. Missing or incorrect values in any of these three fields result in silent message blocking at the operator level.
The Three Mandatory DLT Parameters
1. entity_id (Principal Entity ID) This is the unique ID assigned to your business when you complete DLT entity registration. It is a 19-digit numeric string. Every SMS you send must carry your entity ID so the operator can trace the message back to your registered business.
Example: dlt_entity_id: "1100XXXXXXXXXXXXXXX"
2. header (Sender ID) This is the 6-character alphanumeric sender ID registered on your DLT account. It must be registered under your entity ID and approved by the telecom operator before use. It appears as the "From" identifier on the recipient's phone.
Example: sender_id: "TECHTO"
3. template_id (DLT Template ID) Every message template must be pre-registered and approved on the DLT portal before use. The template ID is a 19-digit numeric string assigned upon approval. Your live message must exactly match the registered template structure — static text must be identical, and variable fields must match the {#var#} placeholders in position and count.
Example: template_id: "1107XXXXXXXXXXXXXXX"
Common DLT Integration Errors
Error | Cause | Fix |
Message delivered via API but not received | Template ID not registered or rejected | Re-register template; check DLT portal status |
TELECO_ERROR: DLT_TEMPLATE_MISMATCH | Live message text does not match registered template | Ensure static text is character-for-character identical |
TELECO_ERROR: ENTITY_NOT_FOUND | Entity ID incorrect or registration pending | Confirm 19-digit entity ID from DLT portal |
TELECO_ERROR: HEADER_INACTIVE | Sender ID deregistered or suspended | Re-activate header on DLT portal |
Message blocked for DND numbers | Transactional route not selected | Set message_type: "transactional" in API call |
Template approved but message still blocked | Template registered under wrong entity | Ensure template and header are under the same entity ID |
TechTo Networks SMS Gateway API: Full Integration Reference
Base URL: https://api.techtonetworks.com/v1 Authentication: API Key passed in X-API-Key header Format: JSON request and response bodies TLS: 1.2 and 1.3 supported; 1.0 and 1.1 blocked
Send a Single SMS
Endpoint: POST /sms/send
POST /v1/sms/send HTTP/1.1
Host: api.techtonetworks.com
Content-Type: application/json
X-API-Key: YOUR_API_KEY
{
"to": "919876543210",
"sender_id": "TECHTO",
"message": "Your order #ORD-4821 has been dispatched. Track at techto.in/track. - TECHTO",
"message_type": "transactional",
"dlt_entity_id": "1100XXXXXXXXXXXXXXX",
"template_id": "1107XXXXXXXXXXXXXXX",
"unicode": false,
"flash": false
}
Response:
{
"status": "success",
"message_id": "TN-MSG-20260601-948271",
"to": "919876543210",
"credits_used": 1,
"submitted_at": "2026-06-01T14:22:31+05:30"
}
Send Bulk SMS (Multiple Recipients)
Endpoint: POST /sms/bulk
POST /v1/sms/bulk HTTP/1.1
Host: api.techtonetworks.com
Content-Type: application/json
X-API-Key: YOUR_API_KEY
{
"messages": [
{
"to": "919876543210",
"message": "Hi Rahul, your appointment is confirmed for June 5 at 10:00 AM. - TECHTO",
"template_id": "1107XXXXXXXXXXXXXXX"
},
{
"to": "918765432109",
"message": "Hi Priya, your appointment is confirmed for June 5 at 11:30 AM. - TECHTO",
"template_id": "1107XXXXXXXXXXXXXXX"
}
],
"sender_id": "TECHTO",
"message_type": "transactional",
"dlt_entity_id": "1100XXXXXXXXXXXXXXX"
}
Response:
{
"status": "queued",
"batch_id": "TN-BATCH-20260601-3821",
"total_messages": 2,
"credits_reserved": 2,
"estimated_delivery": "2026-06-01T14:22:45+05:30"
}
Schedule an SMS Campaign
Endpoint: POST /sms/schedule
POST /v1/sms/schedule HTTP/1.1
Host: api.techtonetworks.com
Content-Type: application/json
X-API-Key: YOUR_API_KEY
{
"to": ["919876543210", "918765432109", "917654321098"],
"sender_id": "TECHTO",
"message": "TechTo Networks Flash Sale: 30% off all plans today only. Visit techtonetworks.com - TECHTO",
"message_type": "promotional",
"dlt_entity_id": "1100XXXXXXXXXXXXXXX",
"template_id": "1107XXXXXXXXXXXXXXX",
"schedule_time": "2026-06-05T10:00:00+05:30"
}
Check Message Delivery Status
Endpoint: GET /sms/status/{message_id}
GET /v1/sms/status/TN-MSG-20260601-948271 HTTP/1.1
Host: api.techtonetworks.com
X-API-Key: YOUR_API_KEY
Response:
{
"message_id": "TN-MSG-20260601-948271",
"to": "919876543210",
"status": "delivered",
"operator": "Airtel",
"submitted_at": "2026-06-01T14:22:31+05:30",
"delivered_at": "2026-06-01T14:22:34+05:30",
"delivery_time_ms": 3240,
"error_code": null
}
API Request Parameters Reference
Parameter | Type | Required | Description |
to | string / array | Yes | Mobile number(s) with country code (91XXXXXXXXXX) |
sender_id | string | Yes | DLT-registered 6-char alphanumeric header |
message | string | Yes | SMS text. Max 160 chars per segment |
message_type | string | Yes | transactional, promotional, or otp |
dlt_entity_id | string | Yes | 19-digit DLT Principal Entity ID |
template_id | string | Yes | 19-digit DLT Template ID |
unicode | boolean | No | Set true for Hindi/regional language SMS |
flash | boolean | No | Set true for Class 0 flash messages |
schedule_time | ISO8601 | No | Future timestamp for scheduled send |
callback_url | string | No | Webhook URL for delivery receipt |
short_url | boolean | No | Auto-shorten URLs in message body |
SDK Integration: 4 Languages
Python
import requests
import json
class TechToSMS:
BASE_URL = "https://api.techtonetworks.com/v1"
def __init__(self, api_key):
self.api_key = api_key
self.headers = {
"Content-Type": "application/json",
"X-API-Key": api_key
}
def send_sms(self, to, message, sender_id, template_id,
entity_id, message_type="transactional"):
payload = {
"to": to,
"sender_id": sender_id,
"message": message,
"message_type": message_type,
"dlt_entity_id": entity_id,
"template_id": template_id
}
response = requests.post(
f"{self.BASE_URL}/sms/send",
headers=self.headers,
json=payload
)
return response.json()
def check_status(self, message_id):
response = requests.get(
f"{self.BASE_URL}/sms/status/{message_id}",
headers=self.headers
)
return response.json()
# Usage
client = TechToSMS(api_key="YOUR_API_KEY")
result = client.send_sms(
to="919876543210",
message="Your order #4821 has been dispatched. - TECHTO",
sender_id="TECHTO",
template_id="1107XXXXXXXXXXXXXXX",
entity_id="1100XXXXXXXXXXXXXXX"
)
print(result["message_id"]) # TN-MSG-20260601-948271
print(result["status"]) # success
Node.js
const axios = require('axios');
const techto = {
baseURL: 'https://api.techtonetworks.com/v1',
apiKey: process.env.TECHTO_API_KEY,
async sendSMS({ to, message, senderId, templateId, entityId, messageType = 'transactional' }) {
const response = await axios.post(`${this.baseURL}/sms/send`, {
to,
sender_id: senderId,
message,
message_type: messageType,
dlt_entity_id: entityId,
template_id: templateId,
}, {
headers: {
'Content-Type': 'application/json',
'X-API-Key': this.apiKey,
}
});
return response.data;
},
async checkStatus(messageId) {
const response = await axios.get(`${this.baseURL}/sms/status/${messageId}`, {
headers: { 'X-API-Key': this.apiKey }
});
return response.data;
}
};
// Usage
(async () => {
try {
const result = await techto.sendSMS({
to: '919876543210',
message: 'Your order #4821 has been dispatched. - TECHTO',
senderId: 'TECHTO',
templateId: '1107XXXXXXXXXXXXXXX',
entityId: '1100XXXXXXXXXXXXXXX',
});
console.log(result.message_id); // TN-MSG-20260601-948271
} catch (err) {
console.error('SMS failed:', err.response?.data);
}
})();
PHP
<?php
class TechToSMS {
private $baseURL = 'https://api.techtonetworks.com/v1';
private $apiKey;
public function __construct(string $apiKey) {
$this->apiKey = $apiKey;
}
public function sendSMS(
string $to,
string $message,
string $senderId,
string $templateId,
string $entityId,
string $messageType = 'transactional'
): array {
$payload = json_encode([
'to' => $to,
'sender_id' => $senderId,
'message' => $message,
'message_type' => $messageType,
'dlt_entity_id' => $entityId,
'template_id' => $templateId,
]);
$ch = curl_init("{$this->baseURL}/sms/send");
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => $payload,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [
'Content-Type: application/json',
"X-API-Key: {$this->apiKey}",
],
]);
$response = curl_exec($ch);
curl_close($ch);
return json_decode($response, true);
}
}
// Usage
$client = new TechToSMS($_ENV['TECHTO_API_KEY']);
$result = $client->sendSMS(
to: '919876543210',
message: 'Your order #4821 has been dispatched. - TECHTO',
senderId: 'TECHTO',
templateId: '1107XXXXXXXXXXXXXXX',
entityId: '1100XXXXXXXXXXXXXXX'
);
echo $result['message_id']; // TN-MSG-20260601-948271
Java
import java.net.http.*;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
public class TechToSMS {
private static final String BASE_URL = "https://api.techtonetworks.com/v1";
private final String apiKey;
private final HttpClient httpClient;
private final ObjectMapper objectMapper;
public TechToSMS(String apiKey) {
this.apiKey = apiKey;
this.httpClient = HttpClient.newHttpClient();
this.objectMapper = new ObjectMapper();
}
public Map<String, Object> sendSMS(String to, String message, String senderId,
String templateId, String entityId, String messageType) throws Exception {
Map<String, String> payload = Map.of(
"to", to,
"sender_id", senderId,
"message", message,
"message_type", messageType,
"dlt_entity_id", entityId,
"template_id", templateId
);
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(BASE_URL + "/sms/send"))
.header("Content-Type", "application/json")
.header("X-API-Key", apiKey)
.POST(HttpRequest.BodyPublishers.ofString(
objectMapper.writeValueAsString(payload),
StandardCharsets.UTF_8
))
.build();
HttpResponse<String> response = httpClient.send(
request, HttpResponse.BodyHandlers.ofString()
);
return objectMapper.readValue(response.body(), Map.class);
}
// Usage
public static void main(String[] args) throws Exception {
TechToSMS client = new TechToSMS(System.getenv("TECHTO_API_KEY"));
Map<String, Object> result = client.sendSMS(
"919876543210",
"Your order #4821 has been dispatched. - TECHTO",
"TECHTO",
"1107XXXXXXXXXXXXXXX",
"1100XXXXXXXXXXXXXXX",
"transactional"
);
System.out.println(result.get("message_id")); // TN-MSG-20260601-948271
}
}
Webhooks: Receiving Delivery Reports in Real Time
Polling the status endpoint for every message is inefficient and adds unnecessary API load. The correct approach is to configure a webhook — a URL on your server that TechTo Networks calls automatically when a message status changes.
Configuring Your Webhook
Pass callback_url in your send request:
{
"to": "919876543210",
"message": "Your OTP is {otp}. Valid for 5 minutes. - TECHTO",
"callback_url": "https://yourapp.com/webhooks/sms-delivery",
...
}
Or set a global webhook URL for all messages in your TechTo dashboard under Settings → Webhooks.
Webhook Payload (Delivery Receipt)
TechTo calls your endpoint via HTTP POST with the following JSON body:
{
"event": "delivery_receipt",
"message_id": "TN-MSG-20260601-948271",
"to": "919876543210",
"status": "delivered",
"operator": "Jio",
"error_code": null,
"error_description": null,
"submitted_at": "2026-06-01T14:22:31+05:30",
"delivered_at": "2026-06-01T14:22:34+05:30",
"delivery_time_ms": 3240
}
Webhook Status Values
Status | Meaning | Action Required |
delivered | Confirmed delivery to handset | None — success |
submitted | Accepted by operator, delivery pending | Wait for update |
failed | Delivery failed — check error_code | Retry or alert |
rejected | Blocked by DLT validation | Fix entity/template/header |
undelivered | Operator could not deliver (handset off, number invalid) | Check number validity |
expired | Message validity window elapsed without delivery | Retry if still relevant |
Webhook Handler Example (Node.js / Express)
const express = require('express');
const app = express();
app.use(express.json());
app.post('/webhooks/sms-delivery', (req, res) => {
const { event, message_id, to, status, error_code, delivery_time_ms } = req.body;
if (event === 'delivery_receipt') {
if (status === 'delivered') {
console.log(`✅ Delivered to ${to} in ${delivery_time_ms}ms`);
// Update your database record
} else if (status === 'rejected') {
console.error(`❌ DLT rejection for ${message_id}: ${error_code}`);
// Alert your ops team — likely a template mismatch
} else if (status === 'failed') {
console.warn(`⚠️ Failed for ${to}: ${error_code}`);
// Trigger retry logic or fallback channel
}
}
res.status(200).json({ received: true });
});
Error Codes Reference: Indian SMS Gateway API
Understanding error codes from Indian telecom operators saves hours of debugging. Here is a complete reference for codes returned by TechTo Networks' API.
Error Code | Category | Description | Resolution |
E100 | Success | Message delivered | — |
E101 | DLT | Entity ID not found | Verify 19-digit entity ID on DLT portal |
E102 | DLT | Template ID not found | Check template is approved, not pending |
E103 | DLT | Template content mismatch | Static text must exactly match registered template |
E104 | DLT | Header (sender ID) not registered | Register header under same entity on DLT portal |
E105 | DLT | Header suspended | Reactivate sender ID on DLT portal |
E201 | Number | Invalid mobile number format | Use 91XXXXXXXXXX format; 10-digit after 91 |
E202 | Number | Number is DND-registered (promotional) | Switch to transactional route |
E203 | Number | Number deactivated / ported | Remove from your database |
E301 | Content | Message exceeds character limit | Keep under 160 chars per segment; Unicode reduces to 70 |
E302 | Content | Special characters in non-unicode mode | Set unicode: true for Hindi/regional content |
E401 | Auth | Invalid API key | Check key in TechTo dashboard |
E402 | Auth | IP not whitelisted | Add your server IP to allowed list in dashboard |
E403 | Auth | Account suspended | Contact TechTo support |
E501 | Rate | Rate limit exceeded | Implement exponential backoff; upgrade plan |
E502 | Credits | Insufficient credits | Top up account |
E601 | Routing | No route available for this number | Contact support — rare operator routing gap |
E602 | Routing | Operator SMSC congestion | Retry after 30–60 seconds |
E701 | Schedule | Schedule time is in the past | Use future IST timestamp |
E702 | Schedule | Schedule time outside TRAI window (promotional) | Schedule between 10:00 AM and 8:00 PM IST |
API Security Best Practices for Indian Businesses
1. Store API Keys in Environment Variables
Never hardcode your API key in source code or commit it to a repository.
# .env file (never commit this)
TECHTO_API_KEY=your_actual_key_here
# Access in Python
import os
api_key = os.environ.get("TECHTO_API_KEY")
# Access in Node.js
const apiKey = process.env.TECHTO_API_KEY;
2. Enable IP Whitelisting
In TechTo dashboard → Settings → API Security, add your server's static IP addresses. Any request from an unlisted IP is rejected with E402, even with a valid API key. This prevents credential theft from being exploited.
3. Validate Webhook Signatures
TechTo signs every webhook delivery with an HMAC-SHA256 signature using your webhook secret. Validate this on your server before processing:
import hmac
import hashlib
def validate_webhook(payload_body: bytes, signature: str, secret: str) -> bool:
expected = hmac.new(
secret.encode('utf-8'),
payload_body,
hashlib.sha256
).hexdigest()
return hmac.compare_digest(expected, signature)
# In your webhook handler
signature = request.headers.get('X-TechTo-Signature')
is_valid = validate_webhook(request.body, signature, WEBHOOK_SECRET)
if not is_valid:
return Response(status=401)
4. Implement Rate Limiting on Your Side
Before hitting TechTo's rate limits, implement your own application-level throttle. For OTP use cases, a single mobile number should never receive more than 3 OTPs in 10 minutes.
5. Never Log Message Content
SMS message content — especially OTPs and financial alerts — should never be written to application logs. Log the message_id for tracking, not the message body.
Real-World Integration Patterns
Pattern 1: E-Commerce Order Notification (Node.js + Webhooks)
// Triggered after order status update in your e-commerce backend
async function sendOrderUpdate(order) {
const message = `Hi ${order.customerName}, your order #${order.id} is ${order.status}. Track: ${order.trackingUrl} - TECHTO`;
const result = await techto.sendSMS({
to: `91${order.customerPhone}`,
message,
senderId: 'TECHTO',
templateId: process.env.ORDER_TEMPLATE_ID,
entityId: process.env.DLT_ENTITY_ID,
messageType: 'transactional',
callbackUrl: 'https://yourapp.com/webhooks/sms-delivery'
});
// Store message_id against the order for tracking
await db.orders.update(order.id, { smsMessageId: result.message_id });
}
Pattern 2: Scheduled Promotional Campaign (Python + Pandas)
import pandas as pd
import requests
from datetime import datetime
# Load opted-in customer list
customers = pd.read_csv('opted_in_customers.csv')
# Build bulk payload
messages = [
{
"to": f"91{row['mobile']}",
"message": f"Hi {row['name']}, TechTo Sale: 30% off today. techtonetworks.com - TECHTO",
"template_id": PROMO_TEMPLATE_ID
}
for _, row in customers.iterrows()
]
# Schedule for 11 AM IST (within TRAI promotional window)
response = requests.post(
"https://api.techtonetworks.com/v1/sms/schedule",
headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
json={
"messages": messages,
"sender_id": "TECHTO",
"message_type": "promotional",
"dlt_entity_id": ENTITY_ID,
"schedule_time": "2026-06-10T11:00:00+05:30"
}
)
print(f"Scheduled {len(messages)} messages. Batch: {response.json()['batch_id']}")
Pattern 3: WordPress / WooCommerce Integration (PHP)
// Add to functions.php or custom plugin
add_action('woocommerce_order_status_changed', 'send_order_sms', 10, 3);
function send_order_sms($order_id, $old_status, $new_status) {
$order = wc_get_order($order_id);
$phone = $order->get_billing_phone();
$name = $order->get_billing_first_name();
$client = new TechToSMS(get_option('techto_api_key'));
$message = "Hi {$name}, your order #{$order_id} is now {$new_status}. - TECHTO";
$client->sendSMS(
to: "91{$phone}",
message: $message,
senderId: 'TECHTO',
templateId: get_option('techto_order_template_id'),
entityId: get_option('techto_dlt_entity_id')
);
}
Performance Benchmarks: What to Expect from TechTo Networks API
Metric | TechTo Networks | Industry Average |
API response time (P50) | 180ms | 300–500ms |
API response time (P95) | 420ms | 800–1,200ms |
SMS delivery P50 (Jio) | 1.8 sec | 3–5 sec |
SMS delivery P50 (Airtel) | 2.1 sec | 3–5 sec |
SMS delivery P95 (all operators) | 6.8 sec | 12–20 sec |
Platform uptime SLA | 99.99% | 99.9% |
Max throughput (REST) | 300 TPS | 100–150 TPS |
Max throughput (SMPP) | 3,000 TPS | 1,000–2,000 TPS |
Delivery rate (transactional) | 99.2% | 95–98% |
DLT validation time | <50ms | 100–300ms |
SMS Gateway API Pricing
TechTo Networks uses transparent per-message pricing with no monthly platform fees on standard plans.
Message Type | Rate | Min Purchase | Validity |
Transactional SMS (Tier-1) | ₹0.18/SMS | 1,000 SMS | 1 year |
Promotional SMS | ₹0.13/SMS | 5,000 SMS | 1 year |
OTP SMS | ₹0.18/SMS | 1,000 SMS | 1 year |
Unicode (Regional Language) SMS | ₹0.25/SMS | 1,000 SMS | 1 year |
International SMS | From ₹2.50/SMS | 500 SMS | 1 year |
SMPP Access | ₹0.15/SMS | 1,00,000 SMS/mo | Monthly |
API Access | Free | All plans | — |
Volume pricing available from 1,00,000 SMS/month. All rates exclude 18% GST. DLT routing charges included.
Frequently Asked Questions
What is an SMS Gateway API? An SMS Gateway API is a programmatic interface — typically REST or HTTP — that lets your application send and receive SMS messages by connecting to a telecom gateway that routes messages to mobile operators. In India, every SMS Gateway API must support DLT compliance parameters: entity ID, sender ID, and template ID, which are validated in real time before message delivery.
What is the difference between REST API and SMPP for SMS? REST API communicates over standard HTTPS with JSON bodies — it is stateless, easy to implement, and suitable for up to 300 messages per second. SMPP (Short Message Peer-to-Peer) creates a persistent binary TCP connection directly to the operator SMSC and supports 500–3,000+ messages per second with lower latency. Use REST for most applications; use SMPP only for platforms sending more than 500 OTPs per second at peak.
Is DLT registration required for using an SMS Gateway API in India? Yes. TRAI mandates DLT registration for every business sending commercial SMS in India — including transactional, OTP, and promotional messages. Without a registered entity ID, sender ID, and approved template ID, your API calls will be accepted but messages will be silently blocked at the operator level. TechTo Networks assists with DLT registration as part of onboarding.
How fast does the TechTo Networks SMS API deliver messages in India? TechTo delivers transactional SMS in a median of 1.8–2.1 seconds across Jio and Airtel. P95 delivery — the speed at which 95% of messages arrive — is under 7 seconds across all four Indian operators during peak hours. API response time (the time between your POST request and the API acknowledgement) is under 200ms at P50.
How do I handle delivery failures in the SMS API? Configure a callback_url webhook in your API request. TechTo sends a POST to your webhook with the delivery status when it changes. For failed messages, check the error_code field — E103 (template mismatch) and E202 (DND number) are the most common in India. Implement exponential backoff for retries on E602 (operator congestion) errors. For E101–E105 (DLT errors), fix the root cause on the DLT portal rather than retrying.
Can I send SMS in Hindi or regional Indian languages via the API? Yes. Set "unicode": true in your API request. Unicode SMS supports all Indian languages including Hindi, Tamil, Telugu, Malayalam, Kannada, Bengali, Marathi, and Gujarati. Note that Unicode messages have a 70-character segment limit instead of 160, so longer messages consume more credits. Your DLT template must be registered with the regional language text.
What is the rate limit for the TechTo Networks SMS API? The default rate limit on REST API is 300 requests per second per API key. For higher throughput, SMPP binds support 3,000+ messages per second. If you need to send above the default limit, contact our team for a rate limit increase or SMPP setup. Hitting the rate limit returns an E501 error — implement exponential backoff with jitter in your retry logic.
How do I integrate TechTo SMS API with CRM platforms? TechTo provides native integrations with Zoho CRM, HubSpot, Salesforce, Freshsales, and LeadSquared. For custom CRM integration, use the REST API with your CRM's webhook or automation workflow — the API call is a standard POST request and can be triggered from any platform that supports HTTP actions. Contact our integrations team for CRM-specific documentation.
Why TechTo Networks for SMS Gateway API in India
Direct Tier-1 operator routes. TechTo connects directly to Jio, Airtel, Vi, and BSNL SMSC — no aggregator hops. This delivers measurably faster P95 delivery than providers routing through intermediaries.
Full DLT automation. Entity registration, header approval, template validation, and NCPR scrubbing handled at the platform level. Incorrect template parameters are caught before transmission, not after silent failures.
Comprehensive API documentation. REST, SMPP, and HTTP API documentation with code samples in Python, Node.js, PHP, Java, and .NET. Postman collection available for immediate testing.
Sandbox environment. Test your full integration — including webhook delivery and error code handling — without consuming live credits. Sandbox mirrors production behaviour exactly.
99.99% platform uptime SLA. Backed by a contractual SLA, not a marketing claim. Monthly uptime reports available to enterprise customers.
24/7 developer support. Dedicated technical account manager for API integration queries. Average P1 incident response: under 15 minutes.
Start integrating in minutes.
TechTo Networks Pvt. Ltd. | TRAI DLT Registered | Tier-1 Direct Routes | Kerala, India
Really well explained! Simple, practical, and easy to understand — especially the real-world use cases 👍