Paso 1: Registrarse e iniciar sesión
- Ir al registro de Message Central
- Crea tu cuenta gratuita
- Usa tus créditos gratuitos para probar y jugar con las OTP
Paso 2: Integración de API (¡desarrolladores, ensamblados!)
Hemos mantenido las cosas muy sencillas. Copia algunos fragmentos de código y lo probarás en poco tiempo.
¿Prefieres ver antes que programar? ¿Nuestro guía rápida de vídeo lo tiene todo cubierto.
Parámetro de API para Verify Now
Los siguientes parámetros deben enviarse al usar las API VerifyNow.
RCS/SAUTH
URL base de API Rest
Todos los puntos finales de la API de la plataforma que aparecen a continuación deben tener como prefijo la siguiente URL:
https://cpaas.messagecentral.comGenerar token
Al usar la API de verificación por SMS de Verify Now para enviar códigos de verificación por SMS, la llamada inicial debe ser a la API de generación de tokens.
Esta API devuelve un token que debe incluirse en todas las llamadas posteriores. Se necesita un token de autenticación para validar al usuario y debe incluirse en la sección de encabezado de cada solicitud.
Ruta URL de solicitud:
/auth/v1/authentication/tokencURL
1curl --location 'https://cpaas.messagecentral.com/auth/v1/authentication/token?
2customerId=%3CCustomerId%3E&key=%3CBase64%20Encrypted%20password%3E&scope=NEW&country=91
3&email=test%40messagecentral.com' \
4--header 'accept: */*'
NOTA: Para convertir un comando cURL en código con Postman, abre Postman, importa el comando cURL mediante el botón «Importar» y, a continuación, genera el código en tu idioma preferido haciendo clic en el botón «Código» situado a la derecha de la solicitud.
Respuesta JSON
1{
2 "status": Integer,
3 "token": "String"
4}Ejemplo de código
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://cpaas.messagecentral.com/auth/v1/authentication/token?customerId=<CustomerId>&key=<Base64 Encrypted password>&scope=NEW&country=91&email=test@messagecentral.com")
.method("GET", body)
.addHeader("accept", "*/*")
.build();
Response response = client.newCall(request).execute();var request = require('request');
var options = {
'method': 'GET',
'url': 'https://cpaas.messagecentral.com/auth/v1/authentication/token?customerId=<CustomerId>&key=<Base64 Encrypted password>&scope=NEW&country=91&email=test@messagecentral.com',
'headers': {
'accept': '*/*'
}
};
request(options, function (error, response) {
if (error) throw new Error(error);
console.log(response.body);
});<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://cpaas.messagecentral.com/auth/v1/authentication/token?customerId=<CustomerId>&key=<Base64 Encrypted password>&scope=NEW&country=91&email=test@messagecentral.com');
$request->setMethod(HTTP_Request2::METHOD_GET);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'accept' => '*/*'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}import requests
url = "https://cpaas.messagecentral.com/auth/v1/authentication/token?customerId=<CustomerId>&key=<Base64 Encrypted password>&scope=NEW&country=91&email=test@messagecentral.com"
payload = {}
headers = {
'accept': '*/*'
}
response = requests.request("GET", url, headers=headers, data=payload)
print(response.text)
require "uri"
require "net/http"
url = URI("https://cpaas.messagecentral.com/auth/v1/authentication/token?customerId=<CustomerId>&key=<Base64 Encrypted password>&scope=NEW&country=91&email=test@messagecentral.com")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["accept"] = "*/*"
response = https.request(request)
puts response.read_body
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://cpaas.messagecentral.com/auth/v1/authentication/token?customerId=<CustomerId>&key=<Base64 Encrypted password>&scope=NEW&country=91&email=test@messagecentral.com");
request.Headers.Add("accept", "*/*");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());Enviar OTP
Para enviar OTP a un número de teléfono móvil, a continuación se muestran los parámetros de solicitud. El token de autenticación es necesario para enviar la OTP, que es generada por la API de tokens generada (que puedes encontrar más arriba en la sección Introducción).
Ruta URL de solicitud:
Una respuesta correcta devolverá un código de estado 200.
/verification/v3/sendParámetros de URL de solicitud:
cURL
1curl --location --request POST 'https://cpaas.messagecentral.com/verification/v3/send?
2countryCode=91&flowType=SMS&mobileNumber=9999999999' \
3--header 'authToken:
4eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJDLTMzNDMyQTVGNDIGNzQwNCI6ImIhdCI6MTcxMjExOTA0MCwiZXhwIjo'
NOTA: Para convertir un comando cURL en código con Postman, abre Postman, importa el comando cURL mediante el botón «Importar» y, a continuación, genera el código en tu idioma preferido haciendo clic en el botón «Código» situado a la derecha de la solicitud. Puedes cambiar el FlowType según el canal que elijas.
Respuesta JSON
1{
2 "responseCode": 200,
3 "message": "SUCCESS",
4 "data": {
5 "verificationId": "xxxx",
6 "mobileNumber": "xxxx",
7 "responseCode": "200",
8 "errorMessage": null,
9 "timeout": "60",
10 "smCLI": null,
11 "transactionId": "xxxx"
12 }
13}Ejemplo de código
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://cpaas.messagecentral.com/verification/v3/send?countryCode=91&flowType=SMS&mobileNumber=9999999999")
.method("POST", body)
.addHeader("authToken", "eyJhbGciOiJIUzUxMiJ9.eyJzdWOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOTA0MCwiZXhw")
.build();
Response response = client.newCall(request).execute();
var request = require('request');
var options = {
'method': 'POST',
'url': 'https://cpaas.messagecentral.com/verification/v3/send?countryCode=91&flowType=SMS&mobileNumber=9999999999',
'headers': {
'authToken': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOTA0MCwiZXhw'
}
};
request(options, function (error, response) {
if (error) throw new Error(error);
console.log(response.body);
});<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://cpaas.messagecentral.com/verification/v3/send?countryCode=91&flowType=SMS&mobileNumber=9999999999');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'authToken' => 'eyJhbGciOiJIUzUxMiJ9.eyJzdWOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOTA0MCwiZXhw'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}import requests
url = "https://cpaas.messagecentral.com/verification/v3/send?countryCode=91&flowType=SMS&mobileNumber=9999999999"
payload = {}
headers = {
'authToken': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOTA0MCwiZXhw'
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)require "uri"
require "net/http"
url = URI("https://cpaas.messagecentral.com/verification/v3/send?countryCode=91&flowType=SMS&mobileNumber=9999999999")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authToken"] = "eyJhbGciOiJIUzUxMiJ9.eyJzdWOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOTA0MCwiZXhw"
response = https.request(request)
puts response.read_bodyvar client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://cpaas.messagecentral.com/verification/v3/send?countryCode=91&flowType=SMS&mobileNumber=9999999999");
request.Headers.Add("authToken", "eyJhbGciOiJIUzUxMiJ9.eyJzdWOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOTA0MCwiZXhw");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());Validar OTP
El método validateOTP es un punto final de la API REST para validar una contraseña de un solo uso (OTP) para los clientes.
Ruta URL de solicitud:
Una respuesta correcta devolverá un código de estado 200.
/verification/v3/validateOtp/- Para soporte en varios idiomas
- por defecto es inglés
- Por ahora, solo admitimos inglés
cURL
1curl --location 'https://cpaas.messagecentral.com/verification/v3/validateOtp?
2&verificationId=2949&code=1476' \
3--header 'authToken:
4eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJDLTMzNDMyQTVGNDIGNzQwNCI6ImIhdCI6MTcxMjExOTA0MC'
NOTA: Para convertir un comando cURL en código con Postman, abre Postman, importa el comando cURL mediante el botón «Importar» y, a continuación, genera el código en tu idioma preferido haciendo clic en el botón «Código» situado a la derecha de la solicitud.
Respuesta JSON
Una respuesta correcta devolverá un código de estado 200.
1{
2 "responseCode": 200,
3 "message": "SUCCESS",
4 "data": {
5 "verficationId": "xxxx",
6 "mobileNumber": "xxxx",
7 "responseCode": "200",
8 "errorMessage": null,
9 "verificationStatus": "VERIFICATION_COMPLETED",
10 "authToken": null,
11 "transactionId": "xxxx"
12 }
13}Ejemplo de código
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://cpaas.messagecentral.com/verification/v3/validateOtp?&verificationId=2949&code=1476")
.method("GET", body)
.addHeader("authToken", "eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOT")
.build();
Response response = client.newCall(request).execute();var request = require('request');
var options = {
'method': 'GET',
'url': 'https://cpaas.messagecentral.com/verification/v3/validateOtp?&verificationId=2949&code=1476',
'headers': {
'authToken': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOT'
}
};
request(options, function (error, response) {
if (error) throw new Error(error);
console.log(response.body);
});<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://cpaas.messagecentral.com/verification/v3/validateOtp?&verificationId=2949&code=1476');
$request->setMethod(HTTP_Request2::METHOD_GET);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'authToken' => 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOT'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://cpaas.messagecentral.com/verification/v3/validateOtp?&verificationId=2949&code=1476");
request.Headers.Add("authToken", "eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOT");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
require "uri"
require "net/http"
url = URI("https://cpaas.messagecentral.com/verification/v3/send?countryCode=91&flowType=SMS&mobileNumber=9999999999")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authToken"] = "eyJhbGciOiJIUzUxMiJ9.eyJzdWOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOTA0MCwiZXhw"
response = https.request(request)
puts response.read_bodyvar client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://cpaas.messagecentral.com/verification/v3/send?countryCode=91&flowType=SMS&mobileNumber=9999999999");
request.Headers.Add("authToken", "eyJhbGciOiJIUzUxMiJ9.eyJzdWOiJDLTMzNDMyQTVGNDlGNzQwNCIsImlhdCI6MTcxMjExOTA0MCwiZXhw");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());Códigos de respuesta
¿Necesitas ayuda?
¿Necesitas una mano? Nuestros expertos están disponibles las 24 horas del día, los 7 días de la semana para guiarlo en cualquier momento y en cualquier momento.
Correo electrónico de soporte: support@messagecentral.com
Preguntas frecuentes
¿Cuál es la mejor API de OTP por SMS para India en fiabilidad de entrega y latencia?
Busca un proveedor de API de OTP por SMS que ofrezca rutas directas de operador, peering regional con operadores, reintentos/fallback automáticos y SLA de entrega medibles. Los mejores proveedores también admiten cumplimiento DLT, informes de entrega (DLR), enrutamiento de baja latencia y fallback de SMS + WhatsApp. Evalúalos midiendo las tasas de entrega reales, la latencia media (ms) y el desglose de errores en los principales operadores indios (Jio, Airtel, Vi).
¿Qué velocidad de entrega de OTP se necesita en apps indias y qué afecta a la latencia?
Apunta a una entrega en menos de 2 segundos para la mejor experiencia (menos de 5 s es aceptable). La latencia depende del enrutamiento del operador, las colas en horas punta, la congestión de la red, los saltos entre agregadores de SMS y los retrasos de DLT/plantillas. Usa rutas directas, enrutamiento en paralelo y fallback integrado de SMS + WhatsApp para reducir al mínimo la latencia de extremo a extremo y aumentar la tasa de verificación completada.
¿Cómo integro una API de OTP por SMS en mi app en India (Node.js, Python, PHP, Java)?
Flujo básico: genera un OTP seguro → llama a la API de envío de OTP del proveedor → guarda el hash del OTP + su caducidad → verifica la entrada del usuario contra el hash guardado mediante la API/webhook de verificación. La mayoría de proveedores ofrecen endpoints REST y SDK de verificación por OTP. Ejemplo (pseudocódigo):
Node.js (fetch):
await fetch('https://api.provider/send', {
method:'POST',
headers:{'Authorization':'Bearer KEY','Content-Type':'application/json'},
body: JSON.stringify({to:'+91XXXXXXXXXX', template:'OTP {{code}}',
variables:{code:123456}}) });
Usa HTTPS, HMAC/firmas, reintentos y webhooks para los informes de entrega (DLR).
¿Cómo evito el abuso de reenvíos de OTP o los ataques de fuerza bruta en mi flujo de autenticación?
Aplica protecciones en el servidor:
- Limita los reenvíos por teléfono y por periodo de tiempo (p. ej., 3 envíos / 10 minutos).
- Limita los intentos de verificación y añade esperas progresivas o bloqueos temporales tras los fallos.
- Usa huella digital de dispositivo + IP y CAPTCHA en los flujos sospechosos.
- Bloquea la cuenta o exige una verificación adicional tras N intentos fallidos. Registra los intentos y avisa al equipo de seguridad.
¿Qué causa los fallos de entrega de OTP en India y cómo los solucionan los desarrolladores?
Causas habituales: rechazo de DLT/plantillas, filtrado del operador (DND), enrutamiento deficiente, sender ID incorrecto, formato de número erróneo o caídas temporales del operador. Soluciones: asegura las aprobaciones de DLT y plantillas, usa el formato E.164 correcto (+91), reintenta por rutas alternativas, activa el fallback por SMS, supervisa los DLR y elige un proveedor con relación directa con los operadores.
¿Cómo pruebo las APIs de OTP en modo sandbox sin enviar SMS reales?
Usa el sandbox o las claves de prueba del proveedor para simular envíos y confirmaciones. El sandbox suele devolver DLR y respuestas de verificación simuladas. En local, simula las respuestas de la API en las pruebas unitarias y usa credenciales de staging para el QA de extremo a extremo. Valida siempre los webhooks en staging (con herramientas como ngrok) y registra todos los eventos para reproducirlos en las pruebas.
¿Cómo implemento la limitación de frecuencia y la lógica de reintentos para el envío de OTP?
Limitación de frecuencia: aplica límites por teléfono y por IP en el API gateway (p. ej., 3 envíos cada 10 min). Lógica de reintentos: usa backoff exponencial para errores transitorios y reintento inmediato por una ruta alternativa para fallos leves. Pon siempre un tope a los reintentos (p. ej., 3 intentos) y registra sus resultados para evitar spam o bloqueos del operador.
¿Puedo usar un Sender ID alfanumérico para OTP en India?
No: India exige Sender IDs numéricos a través de rutas aprobadas por DLT para la mayoría de flujos transaccionales; los alfanuméricos no suelen permitirse para OTP. Los OTP deben cumplir las normas de telecomunicaciones/DLT. Usa un proveedor que gestione por ti el registro DLT y la configuración del Sender ID numérico.
¿Qué caducidad de OTP y ciclo de reintentos se recomiendan para usuarios en India?
Caducidad: 3–5 minutos es lo habitual para OTP transaccionales (2FA). Ciclo de reintentos: permite 1–2 reenvíos inmediatos con límites antiabuso (p. ej., máximo 3 envíos cada 10–15 minutos). Las caducidades cortas reducen el fraude; unos límites de reenvío razonables reducen la carga de soporte y el filtrado de los operadores.
¿Qué diferencia hay entre las rutas de OTP Transaccionales y Service Implicit?
Las rutas Transaccionales son para mensajes críticos y esperados (OTP, actualizaciones de pedidos), siguen normas de cumplimiento más estrictas y suelen tener mayor prioridad de entrega. Las rutas Service Implicit (u otras rutas de servicio) pueden variar según el operador y suelen aplicar otras reglas de plantillas/consentimiento. Consulta la documentación de enrutamiento de tu proveedor y elige rutas transaccionales para los OTP para maximizar la entregabilidad y el cumplimiento.
¿Cómo migro de otro proveedor de SMS a una nueva API de OTP sin tiempo de inactividad?
Planifica una transición por fases:
- Configura el nuevo proveedor y prepara DLT/plantillas en paralelo.
- Replica el tráfico (envía lotes de prueba) y verifica las métricas de entrega.
- Aplica envío doble a un pequeño porcentaje del tráfico real (A/B) y supervisa los resultados.
- Traslada el tráfico poco a poco manteniendo el proveedor anterior como respaldo.
- Actualiza los endpoints de DNS/webhooks y revoca las claves antiguas cuando todo esté estable. Supervisa de cerca los registros y las tasas de entrega.