Enviar SMS

Para enviar SMS a través de nuestra API primero debes obtener tu clave API para acceder a los recursos. Si no la tienes aún puedes generarla en la sección de integraciones dentro del panel.

Importante

Debes leer el siguiente documento antes de realizar envíos a través de nuestra API. Al hacer uso de la misma, estarás aceptando estar enterado de los puntos contenidos en el documento. https://sms.gy/NW9ju
Encabezados
Atributo Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
message   Obligatorio   Mensaje que desea enviar. Si el mensaje contiene algún error o sobrepasa el número de caracteres permitidos se le indicará en la respuesta de la API.

  Nota 1:   El envío de mensajes a través de nuestra API v2 no acepta acentos, si envía acentos en su mensaje estos serán sustituidos automáticamente al procesarlos.
  Text  
numbers   Obligatorio   Lista de números a los que desea enviar el mensaje. Los números deben ir separados por una coma (,). Ejemplo:   4771234567,4770987654,4779182736     Text  
country_code   Obligatorio   Código de país al que desea enviar el mensaje. Consulta nuestra lista de países en las que tenemos disponible nuestro servicio de envío de SMS.   Number  
find_country_code   Opcional   Si el número contiene el código de país y no los puedes separar para mandar  numbers  y  country_code  puedes enviar  numbers  incluyendo el código del país y habilitar este atributo. Por defecto   0  .
  1   Extraer código de país del número.
  0   Usar código de país del atributo  country_code .

  Number  
name   Opcional   Nombre para identificar los envíos realizados en Reportes. Por defecto:   Campaign Y-m-d H:M:S     Text  
sender   Opcional   Indica el remitente con el que quieres que lleguen los mensajes a tus clientes.

  Nota 1:   Sólo puedes indicar remitentes que tengas configurados en tu cuenta.
  Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
sandbox   Opcional   Para enviar SMS en modo de pruebas indica este atributo con   1  . En caso contrario el mensaje será enviado y descontado de tu crédito. Por defecto   0  .
  1   Modo de pruebas.
  0   Modo producción.

Los mensajes enviados en modo de pruebas enviarán la misma respuesta a tu integración como si los enviaras en modo producción para facilitarte la integración sin consumir mensajes.

  Nota 1:   Solo puedes enviar 1000 mensajes en modo de prueba por día. Los mensajes enviados en este modo son solo una simulación, no se mandan y no descuentan créditos.
  Nota 2:   El reporte de los mensajes enviados en modo de pruebas solo estarán disponibles el mismo día que se enviaron dentro de la sección 'Integraciones -> Rest API -> Logs Sandbox'.
  Number  
date   Opcional   Fecha a enviar la campaña
  Nota 1:   El formato de la fecha debe de estar en formato DateTime   YYYY-MM-DD HH-mm-ss  
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
sms_01 Mensaje indefinido
sms_02 Mensaje muy largo
sms_03 Número indefinido
sms_04 Número con formato incorrecto
sms_05 Código de país indefinido
sms_06 Nombre muy largo
sms_07 Créditos insuficientes
sms_12, sms_13 Error al enviar los mensajes
sms_15 Máximo 500 mensajes por envío
sms_16 Número repetido
sms_17 Máximo 1,000 envíos por día en modo de pruebas
sms_18 Código de país no soportado
sms_19 Número fijo
sms_20 La fecha de envío a futuro es menor a la actual

Enviar SMS

Para enviar SMS debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/sms/send 
Ejemplo de envio SMS:
                                      
curl -X POST "https://api.smsmasivos.com.mx/sms/send" -H "apikey: your_apikey" -d "message=your_message_to_send&numbers=your_list_of_numbers&country_code=your_country_code"
                                      
                                    
                                        
$params = array(
  "message" => your_message_to_send,
  "numbers" => your_list_of_numbers,
  "country_code" => your_country_code
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/sms/send",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/sms/send")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "message" => your_message_to_send,
  "numbers" => your_list_of_numbers,
  "country_code" => your_country_code
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/sms/send");
var postData = "message=your_message_to_send&";
postData += "numbers=your_list_of_numbers&";
postData += "country_code=your_country_code";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/sms/send'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "message": your_message_to_send,
      "numbers": your_list_of_numbers,
      "country_code": your_country_code
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/sms/send"
headers = {
  'apikey':your_apikey
}
data = {
  'message':your_message_to_send,
  'numbers':your_list_of_numbers,
  'country_code':your_country_code
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.sendSMS("your_apikey","your_message","4771234567,4777654321,4771231234","your_country_code","your_campaign_name","language_selected","sandbox_mode", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getReferences().toString());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

sms.sendSMS(message: "your_message_to_send", numbers: "your_list_of_numbers", country_code: your_country_code, name: "your_campaign_name", lang: "es", sandbox: true) { data, err in
  print(data!.value(forKey: "references")!)
}

                                        
                                      
Respuesta:
{
  "success": true,
  "message": "Mensajes enviados",
  "status": 200,
  "code": "sms_11",
  "total_messages": amount_of_messages_sent [1],
  "references": [
    {
      "reference": each_reference [210511213b247bjim132sEuEBDzvajpa],
      "number": each_number [524770000000]
    },
    {
      "reference": each_reference [210511213b247bjim132sEuEBDzvajpb],
      "number": each_number [524770000001]
    }
  ],
  "credit": credits_left [0.00]
}
                                  

Enviar SMS vía Email (SMTP Gateway)

Nos mandas un correo electrónico y nosotros lo convertimos en un SMS, de esta forma puedes conectar sistemas que ya mandan correos sin necesidad de hacer una integración que requiera programación.

Tenemos diferentes formas de recibir el correo dependiendo de lo que puede enviar tu sistema.

Es importante que verifiques que tienes créditos suficientes en tu cuenta, te sugerimos activar compras automáticas.

Opción 1

Nos mandas un correo a: clave de país + lada + número de teléfono @api.smsmasivos.com.mx

En tu asunto pones la APIKey que consigues en tu panel de SMS Masivos

En el cuerpo de tu correo incluyes el mensaje con menos de 160 caracteres que recibirán tus clientes como un SMS

Option 1
Opción 2

Nos mandas un correo a: [email protected]

En el asunto de tu correo escribes: clave de país + lada + número de teléfono;APIkey

En el cuerpo de tu correo incluyes el mensaje con menos de 160 caracteres que recibirán tus clientes como un SMS

Option 2
Opción 3

Nos mandas un correo a: [email protected]

En el asunto de tu correo incluyes el mensaje con menos de 160 caracteres que recibirán tus clientes como un SMS

En el cuerpo de tu correo escribes: clave de país + lada + número de teléfono;APIkey

Option 3
Opción 4

Nos mandas un correo a: clave de país + lada + número de telé[email protected]

En el asunto de tu correo escribes: SMS Masivos

En el cuerpo de tu correo incluyes el mensaje con menos de 160 caracteres que recibirán tus clientes como un SMS

Option 4
Opción 5

Nos mandas un correo a: clave de país + lada + número de telé[email protected]

En el asunto de tu correo incluyes el mensaje con menos de 160 caracteres que recibirán tus clientes como un SMS

En el cuerpo de tu correo escribes: api:APIKey

Option 5

  Nota:   No indiques más de un destinatario, ya que no es soportada esta forma.


  Nota:   Recuerde no sobrepasar el límite de caracteres (incluyendo espacios).


  Nota:   Si tu mensaje agrega automaticamente una firma puedes delimitar el final del mensaje con el conjunto de caracteres %&%


Consulta de créditos

Puedes obtener la cantidad de créditos que tienes disponibles por medio de nuestra API.

Encabezados
Atributo Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Estatus

Es el número que corresponde al estatus que fue devuelto por el envío de tu mensaje. Los estatus pueden ser:

  0   Entregado
  1   No entregado
  2   Error
  3   Expirado
  4   Rechazado
  5   Desconocido
  6   No existe
  7   Formato incorrecto
  8   Pendiente
  9   Phishing
  10   Blacklist
  11   Número fijo
  12   País no contratado

Tipo

Es el tipo de campaña que se envió. Los tipos pueden ser

  SMS   Envíos de SMS
  Push   Envíos de Push
  Email   Envíos de E-mail
  Landing   Envíos de Landing
  Formulario   Envíos de Formulario
  SMPP   Envíos de SMPP
  Solicitud de pago   Envíos de Solicitud de pagos
  Voz   Envíos de voz

Errores
Código Mensaje
auth_01 Usuario no autorizado
report_01 Fecha de inicio indefinida
report_02 Fecha de fin indefinida
report_03 Fecha de inicio es mayor a fecha fin
report_05 Solo puedes realizar 10 peticiones de reportes a la API por día.

Consulta de créditos

Para consultar tu crédito disponible debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/credits/consult 
Ejemplo de consulta créditos:
                                      
curl -X POST "https://api.smsmasivos.com.mx/credits/consult" -H "apikey: your_apikey"
                                      
                                    
                                        
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/credits/consult",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query(array()),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/credits/consult")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/credits/consult");
var postData = "";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/credits/consult'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/credits/consult"
headers = {
  'apikey': your_apikey
}
r = requests.post(url = targetURL, data = {}, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.getCredits("your_apikey","language_selected", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getCredit());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

sms.getCredits(lang: "es") { data, err in
  print(data!.value(forKey: "credit")!)
}

                                        
                                      
Respuesta:
{
  "success": true,
  "message": "Créditos disponibles",
  "status": 200,
  "code": "report_04",
  "report": [
    {
      "name": each_shipment_name,
      "created_date": each_created_date,
      "reference": each_reference,
      "number": each_number,
      "message": each_message,
      "sent_date": each_sent_date,
      "status": each_status,
      "operator": each_operator,
	  "type": each_type
    }
  ]
}
                                  

Estatus de SMS

Para recibir la confirmación de los mensajes SMS que enviaste a tus destinatarios es necesario nos proporciones una URL que puedes configurar en tu panel en 'Confirmación de entrega' o en la sección de 'API'. A esta URL pasaremos por método GET la confirmación de tus destinatarios.

Es necesario que su sistema reciba los parámetros que se enviarán y nos dé como respuesta un código HTTP 200 después de haber procesado correctamente los parámetros enviados. En caso de que se nos proporcione una respuesta diferente se realizará un reintento, hasta 25 reintentos diferentes se realizarán para cada solicitud.

Parámetros a enviar
Atributo Descripción Tipo de Dato
type Tipo de acción a procesar en tu URL.
  confirmation   Estatus de SMS
  response   Respuestas de SMS
  Text  
reference Identificador del mensaje.   Text  
status Es el número que corresponde al estatus que fue devuelto por el envío de tu mensaje. Los estatus pueden ser:
  0   Entrega confirmada
  1   No entregado
  2   Desconexión temporal
  3   Expirado
  4   Rechazado
  5   Desconocido
  6   Número desconocido
  7   Formato incorrecto
  8   Error
  9   Phishing
  10   Blacklist
  11   Número fijo
  12   País no contratado
  Number  
number Número del destinatario a quien se envió el mensaje.   Number  
date Fecha y hora de confirmación de entrega en formato año, día, mes, hora, minuto, segundo.   AAAAMMDDHHMMSS     Text  

La URL proporcionada en Confirmación de entrega y Respuestas de destinatarios es compartida, por lo cuál deberá validar el tipo de acción que procesará.

Estatus de SMS

Forma correcta de definir la URL para confirmación de entrega:

 GET  https://dominio.com/path/to/url 
Llamada a URL
https://dominio.com/path/to/url?type=confirmation&reference=reference_value&status=status_value&number=number_value&date=date_value 

Respuestas de SMS

Cuando tu cliente responde a uno de tus SMS podemos reenviarte esa respuesta, para esto requerimos de un Webhook que darás de alta en tu panel en la sección de 'Integraciones' . Pasaremos por método GET a este webhook las respuestas.

Es necesario que su sistema reciba los parámetros que se enviarán y nos dé como respuesta un código HTTP 200 una vez que las recibas.

En caso de que se nos proporciones una respuesta diferente, se realizará un reintento. Hasta 25 reintentos diferentes se realizarán para cada solicitud.

Parámetros a enviar
Atributo Descripción Tipo de Dato
type Tipo de acción a procesar en tu URL.
  confirmation   Estatus de SMS
  response   Respuestas de SMS
  Text  
reference Identificador del mensaje.   Text  
number Número del destinatario a quien se envió el mensaje.   Number  
message Mensaje que se envió al destinatario.   Text  
response Mensaje de respuesta por parte del destinatario.   Text  
send_date Fecha y hora en que se envió el mensaje en formato año, día, mes, hora, minuto, segundo.   AAAAMMDDHHMMSS     Text  
response_date Fecha y hora en que se recibio respuesta del destinatario en formato año, día, mes, hora, minuto, segundo.   AAAAMMDDHHMMSS     Text  

La URL proporcionada en Confirmación de entrega y Respuestas de destinatarios es compartida, por lo cuál deberá validar el tipo de acción que procesará.

Respuestas de SMS

Forma correcta de definir la URL para respuestas de destinatarios:

 GET  https://dominio.com/path/to/url 
Llamada a URL
https://dominio.com/path/to/url?type=response&reference=reference_value&number=number_value&message=message_value&response=response_value&send_date=send_date_value&response_date=response_date_value 

Reporte de entregas

Con nuestra API puedes obtener un reporte detallado de tus envíos para ver el estatus de tus mensajes enviados indicando un rango de fechas.

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
start_date   Obligatorio   Fecha de inicio para filtrar el reporte de los mensajes enviados entre el rango de fechas definida.   Text  
end_date   Obligatorio   Fecha de fin para filtrar el reporte de los mensajes enviados entre el rango de fechas definida.   Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
sandbox   Opcional   Para enviar SMS en modo de pruebas indica este atributo con   1  . En caso contrario el mensaje será enviado y descontado de tu crédito. Por defecto   0  .
  1   Modo de pruebas.
  0   Modo producción.

Los mensajes enviados en modo de pruebas enviarán la misma respuesta a tu integración como si los enviaras en modo producción para facilitarte la integración sin consumir mensajes.

  Nota 1:   Solo puedes enviar 1000 mensajes en modo de prueba por día. Los mensajes enviados en este modo son solo una simulación, no se mandan y no descuentan créditos.
  Nota 2:   El reporte de los mensajes enviados en modo de pruebas solo estarán disponibles el mismo día que se enviaron dentro de la sección 'Integraciones -> Rest API -> Logs Sandbox'.
  Number  
Estatus

Es el número que corresponde al estatus que fue devuelto por el envío de tu mensaje. Los estatus pueden ser:

  0   Entregado
  1   No entregado
  2   Error
  3   Expirado
  4   Rechazado
  5   Desconocido
  6   No existe
  7   Formato incorrecto
  8   Pendiente

Errores
Código Mensaje
auth_01 Usuario no autorizado
report_01 Fecha de inicio indefinida
report_02 Fecha de fin indefinida
report_03 Fecha de inicio es mayor a fecha fin

Reporte de entregas

Para generar el reporte debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/reports/generate 
Ejemplo de generar reporte:
                                      
curl -X POST "https://api.smsmasivos.com.mx/reports/generate" -H "apikey: your_apikey" -d "start_date=your_start_date&end_date=your_end_date"
                                      
                                    
                                        
$params = array(
  "start_date" => your_start_date,
  "end_date" => your_end_date
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/reports/generate",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/reports/generate")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "start_date" => your_start_date,
  "end_date" => your_end_date
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/reports/generate");
var postData = "start_date=your_start_date&";
postData += "end_date=your_end_date";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/reports/generate'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "start_date": your_start_date,
      "end_date": your_end_date
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/reports/generate"
headers = {
  'apikey':your_apikey
}
data = {
  'start_date':your_start_date,
  'end_date':your_end_date
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.getReports("your_apikey","2021-01-01 00:00:00","2021-01-31 23:59:59","language_selected","sandbox_mode", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getReport().toString());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

let start = Date()
let end = Date.init(timeIntervalSinceNow: 86400)

sms.getReports(start_date: start!, end_date: end!, lang: "es", sandbox: true) { data, err in
  print(data!.value(forKey: "report")!)
}

                                        
                                      
Respuesta:
{
  "success": true,
  "message": "Reporte generado",
  "status": 200,
  "code": "report_04",
  "report": [
    {
      "name": each_shipment_name,
      "created_date": each_created_date,
      "reference": each_reference,
      "number": each_number,
      "message": each_message,
      "sent_date": each_sent_date,
      "status": each_status,
      "operator": each_operator
    }
  ]
}
                                  

Envía de mensajes de voz a través de nuestra API

Elige una de nuestras plantillas predefinidas y envía los parámetros a la ruta para enviar un mensaje de voz a tus contactos

Encabezados
Atributo Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
numbers   Obligatorio   Número de telefono a verificar, formato: XXXXXXXXXX.   Text  
country_code   Obligatorio   Código de país al que desea enviar el mensaje. Consulta nuestra lista de países en las que tenemos disponible nuestro servicio de envío de SMS.   Number  
template   Obligatorio   Personaliza el texto de sus mensajes seleccionando entre las diferentes plantillas disponibles.

  a   {{company}} El codigo de verificacion es: {{code}}
  b   Ingresa el siguiente codigo para validar tu cuenta: {{code}}
  c   Ingresa el codigo {{code}} para activar tu cuenta {{company}}
  d   Tu codigo de activacion es {{code}}
  e   Captura el codigo {{code}} para activar tu cuenta {{company}}
  f   Tu codigo es: {{code}}
  g   Tu codigo de confirmacion {{company}} es: {{code}}
  h   {{code}} es tu codigo de verificacion de {{company}}
  i   {{code}} es tu codigo para iniciar sesion en {{company}}
  j   Tu codigo de activacion para {{company}} es el {{code}}
  Text  
company   Obligatorio   Nombre de la compañía mostrada al usuario en el mensaje de verificación.

  Text  
code   Obligatorio   Código de verificación, Longitud de 4 a 6 caracteres

  Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
error_02 Error en la información de la petición
error_03 Error de procesamiento

Envío por voz

Para realizar un envío por voz debes hacer una petición a la siguiente dirección.

 POST  https://api.smsmasivos.com.mx/voice/send 
Ejemplo de envío de voz.
                                      
curl -X POST "https://api.smsmasivos.com.mx/voice/send " -H "apikey: your_apikey" -d "phone_number=your_phone_number&template=your_template_option&country_code=your_country_code&code=your_verification_code&company=your_company"
                                      
                                    
                                        
$params = array(
  "phone_number" => your_phone_number,
  "country_code" => your_country_code,
  "template" => template_option,
  "code" => your_code, 
  "company" => your_company
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/voice/send",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/voice/send")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "phone_number" => your_phone_number,
  "country_code" => country_code,
  "template" => template_option,
  "code" => your_code, 
  "company" => your_company
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/voice/send");
var postData = "phone_number=your_phone_number&";
postData += "country_code=your_country_code";
postData += "template=template_option";
postData += "code=your_code";
postData += "company=your_company";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/voice/send'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "phone_number": your_phone_number,
      "country_code": your_country_code,
      "template" :template_option,
      "code" : your_code, 
      "company" : your_company
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/voice/send"
headers = {
  'apikey':your_apikey
}
data = {
  'phone_number':your_phone_number,
  'country_code':your_country_code,
  'template' :template_option,
  'code' : your_code, 
  'company' : your_company
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.registryDoubleFactor("your_apikey","your_phone_number","your_country_code","your_code","your_company_name","language_selected,"template_selected", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getMessage());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

let expiration_date = Date.init(timeIntervalSinceNow: 86400)

sms.registryDoubleFactor(phone_number: "your_phone_number", country_code: "your_country_code", code: "your_code", template: "template_option", company:"your_company_name", lang: "es") { data, err in
  print(data!.value(forKey: "message")!)
}

                                        
                                      
JSON Respuesta:
{
    "success": true,
    "message": "Mensajes enviados",
    "status": 200,
    "code": "sms_11",
    "total_messages": amount_of_messages_sent [1],
    "references": [
        {
            "reference": each_reference [210511213b247bjim132sEuEBDzvajpa],
            "number": each_number [524770000000]
        }
    ],
    "credit": credits_left [0.00]
}
                                  

Enviar mensaje vía WhatsApp

Conecta tu propia línea de WhatsApp escaneando el código QR con tu celular similar a como lo haces con WhatsApp Web para vincularlo con nuestra plataforma y poder utilizarlo para enviar mensajes transaccionales a través de nuestra API. NOTA: El envío de mensajes masivos por este medio generará que tu número sea banneado y no lo puedas utilizar nunca más, no nos hacemos responsables por números bloqueados.

Encabezados
Atributo Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
instance_id   Obligatorio   Identificador de la instancia de WhatsApp creada. Para el envío de mensajes es necesario tener vinculada su cuenta de WhatsApp a nuestro sistema mediante el escaneo del QR.   Text  
type   Obligatorio   Tipo de mensaje a enviar.
  text  : Envío de mensaje de texto.
  file  : Envío de archivos.
  Text  
number   Obligatorio   Número del contacto al que desea enviar el mensaje.   Text  
country_code   Obligatorio   Código de país del contacto al que desea enviar el mensaje.   Text  
message   Obligatorio   Mensaje que desea enviar. Si el mensaje contiene algún error o sobrepasa el número de caracteres permitidos se le indicará en la respuesta de la API.
Si el mensaje es tipo   text   el mensaje se enviara exactamente como lo escriba.
Si el mensaje es tipo   file   deberá escribir en el mensaje la URL de su archivo a enviar. Asegúrese que la URL que ingrese sea un recurso disponible y la conexión sea SSL.

  Nota:   El envío de mensaje vía WhatsApp no es masivo, si tiene dudas lea el siguiente artículo antes de enviar.
  Text  
find_country_code   Opcional   Si el número contiene el código de país y no los puedes separar para mandar  numbers  y  country_code  puedes enviar  numbers  incluyendo el código del país y habilitar este atributo. Por defecto   0  .
  1   Extraer código de país del número.
  0   Usar código de país del atributo  country_code .

  Number  
date   Opcional   Fecha a enviar el mensaje
  Nota 1:   El formato de la fecha debe de estar en formato DateTime   YYYY-MM-DD HH-mm-ss  
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
whatsapp_04 Instancia de WhatsApp indefinida
whatsapp_05 Tipo de mensaje indefinido
whatsapp_06 Mensaje indefinido
whatsapp_07 Número indefinido
whatsapp_08 Instancia no existe
whatsapp_19 Error al enviar el mensaje a WhatsApp revisa que tu instancia este conectada a tu celular.
whatsapp_20 Error interno al enviar el mensaje vía WhatsApp
whatsapp_22 Código de país indefinido
whatsapp_23 Número con formato incorrecto
whatsapp_24 La fecha para enviar su mensaje es menor que la actual

Enviar mensaje vía WhatsApp

Para enviar mensajes de texto vía WhatsApp debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/whatsapp/send 
Ejemplo de envío de mensaje de texto vía WhatsApp
                                      
curl -X POST "https://api.smsmasivos.com.mx/whatsapp/send " -H "apikey: your_apikey" -d "instance_id=your_whatsapp_instance_id&type=type_to_send&number=number_to_send&country_code=country_code_to_send&message=message_to_send"
                                      
                                    
                                        
$params = array(
  "instance_id" => your_whatsapp_instance_id,
  "type" => type_to_send,
  "number" => number_to_send,
  "country_code" => country_code_to_send,
  "message" => message_to_send
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/whatsapp/send",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/whatsapp/send")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "instance_id" => your_whatsapp_instance_id,
  "type" => type_to_send,
  "number" => number_to_send,
  "country_code" => country_code_to_send,
  "message" => message_to_send
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/whatsapp/send");
var postData = "instance_id=your_whatsapp_instance_id&";
postData += "type=type_to_send&";
postData += "number=number_to_send&";
postData += "country_code=country_code_to_send&";
postData += "message=message_to_send";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/whatsapp/send'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "instance_id": your_whatsapp_instance_id,
      "type": type_to_send,
      "number": number_to_send,
      "country_code": country_code_to_send,
      "message": message_to_send
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/whatsapp/send"
headers = {
  'apikey': your_apikey
}
data = {
  'instance_id': your_whatsapp_instance_id,
  'type': type_to_send,
  'number': number_to_send,
  'country_code': country_code_to_send,
  'message': message_to_send
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

No available

                                        
                                      
                                        

No available

                                        
                                      
JSON Respuesta:
{
    "success": true,
    "message": "message sent",
    "status": 200,
    "code": "whatsapp_21",
    "credit": credits_left [0.00]
}
                                  

(Autenticación de Doble Factor) Registro

Envía una clave única a tus usuarios para validar que el número ingresado realmente existe y lo tienen con ellos. Es ideal para registro de usuarios y envío de contraseñas de un solo uso. El método de “Registro” envía al usuario el código inicial a su celular, este código puede ser enviado a través de un SMS o una llamada.

Encabezados
Atributo Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Formato de URL
Nombre Descripción Tipo de Dato
format   Obligatorio   El formato en el que espera la respuesta de la llamada a la API.
  json   Respuesta en formato JSON.
  xml   Respuesta en formato XML.
  Text  
Atributos
Atributo Descripción Tipo de Dato
phone_number   Obligatorio   Número de telefono a verificar, formato: XXXXXXXXXX.   Text  
country_code   Obligatorio   Código de país al que desea enviar el mensaje. Consulta nuestra lista de países en las que tenemos disponible nuestro servicio de envío de SMS.   Number  
voice   Opcional   Canal de voz para enviar tu mensaje, el usuario recibie una llamada con el código de verificación
  true  Realiza una llamada por teléfono con voz robótica en vez de enviar un SMS
  false   Envía el código a través de un SMS
  Boolean  
code_length   Opcional   Longitud del código de verificación. Por defecto   4  .
  Number  
expiration_date   Opcional   Fecha de expiración para el código de verificación. Por defecto 24 hrs. Formato de ejemplo   2000-01-31 14:18:00  .
  Text  
locale   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
company   Opcional   Nombre de la compañía mostrada al usuario en el mensaje de verificación.

  Text  
showcode   Opcional   Para recibir dentro de la respuesta a tu petición el código autogenerado y enviado a tu cliente indica este atributo con   1  . Por defecto   0  .
  Boolean  
Estatus del proceso
Código Mensaje
verification_01 Código generado exitosamente
verification_02 El código generado ha expirado su periodo de activación
verification_03 Código ya enviado. Esperando por validación
verification_04 Usuario ya verificado
verification_05 Error enviando el mensaje de verificación
verification_07 Número incorrecto
verification_08 Código de país incorrecto
verification_09 Longitud del código de verificación no permitida
verification_10 Error general creando registro
verification_11 Nombre de compañía muy largo
verification_12 Parámetro de voz incorrecto
verification_13 Fecha de expiración inválida
verification_14 Parámetro reset_code incorrecto
verification_15 Parámetro code_number incorrecto

(Autenticación de Doble Factor) Registro

 POST  https://api.smsmasivos.com.mx/protected/{format}/phones/verification/start 
Ejemplo de solicitud del código de verificación:
                                      
curl -X POST "https://api.smsmasivos.com.mx/protected/json/phones/verification/start" -H "apikey: your_apikey" -d "phone_number=your_phone_number&country_code=your_country_code"
                                      
                                    
                                        
$params = array(
  "phone_number" => your_phone_number,
  "country_code" => your_country_code
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/protected/json/phones/verification/start",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/protected/json/phones/verification/start")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "phone_number" => your_phone_number,
  "country_code" => country_code
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/protected/json/phones/verification/start");
var postData = "phone_number=your_phone_number&";
postData += "country_code=your_country_code";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/protected/json/phones/verification/start'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "phone_number": your_phone_number,
      "country_code": your_country_code
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/protected/json/phones/verification/start"
headers = {
  'apikey':your_apikey
}
data = {
  'phone_number':your_phone_number,
  'country_code':your_country_code
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.registryDoubleFactor("your_apikey","your_phone_number","your_country_code","your_code_length","your_company_name","language_selected", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getMessage());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

let expiration_date = Date.init(timeIntervalSinceNow: 86400)

sms.registryDoubleFactor(phone_number: "your_phone_number", country_code: your_country_code, code_length: your_country_code, expiration_date: expiration_date, company:"your_company_name", lang: "es") { data, err in
  print(data!.value(forKey: "message")!)
}

                                        
                                      
JSON Respuesta:
{
    "success": true,
    "message": "Code successfully generated",
    "status": 200,
    "code": "verification_01",
    "verification_code": "XXXX" [Opcional]
}
                                  
XML Respuesta:
<hash>
   <success>true</success>
   <message>Code successfully generated</message>
   <status>200</status>
   <code>verification_01</code>
   <verification_code>XXXX</verification_code> [Opcional]
</hash>

(Autenticación de Doble Factor) Validación

Una vez que tu usuario recibe el código en su celular, lo deberá capturar en un input en tu sitio web o aplicación móvil y usarás el método “Validación” para que confirmemos si el código proporcionado es correcto.

Encabezados
Atributo Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Formato de URL
Nombre Descripción Tipo de Dato
format   Obligatorio   El formato en el que espera la respuesta de la llamada a la API.
  json   Respuesta en formato JSON.
  xml   Respuesta en formato XML.
  Text  
Atributos
Atributo Descripción Tipo de Dato
phone_number   Obligatorio   Número de telefono a verificar, formato: XXXXXXXXXX.   Text  
verification_code   Obligatorio   El código que se ha generado en la ruta 'phones/verification/start'
  Nota:   El código únicamente llega al número especificado en el proceso.
  Text  
locale   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Estatus del proceso
Código Mensaje
validation_01 Usuario verificado exitosamente
validation_02 El código generado ha expirado su periodo de activación
validation_03 No existe registro del usuario que intentas verificar
validation_04 Número máximo de intentos por hora excedidos
validation_05 Código proporcionado es incorrecto
validation_06 El usuario ya se encuentra verificado
validation_07 Número incorrecto
validation_08 El código es incorrecto o no fue enviado
validation_10 Error general creando registro

(Autenticación de Doble Factor) Validación

 POST  https://api.smsmasivos.com.mx/protected/{format}/phones/verification/check
Ejemplo de solicitud de validación del código:
                                      
curl -X POST "https://api.smsmasivos.com.mx/protected/xml/phones/verification/check" -H "apikey: your_apikey" -d "phone_number=your_phone_number&verification_code=client_verification_code"
                                      
                                    
                                        
$params = array(
  "phone_number" => your_phone_number,
  "verification_code" => client_verification_code
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/protected/xml/phones/verification/check",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/protected/json/phones/verification/check")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "phone_number" => your_phone_number,
  "verification_code" => client_verification_code
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/protected/json/phones/verification/check");
var postData = "phone_number=your_phone_number&";
postData += "verification_code=client_verification_code";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'hhttps://api.smsmasivos.com.mx/protected/json/phones/verification/check'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "phone_number": your_phone_number,
      "verification_code": client_verification_code
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/protected/json/phones/verification/check"
headers = {
  'apikey':your_apikey
}
data = {
  'phone_number':your_phone_number,
  'verification_code':client_verification_code
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.validationDoubleFactor("your_apikey","your_phone_number","client_verification_code","language_selected", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getMessage());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

sms.validationDoubleFactor(phone_number: "your_phone_number", verification_code: "client_verification_code", lang: "es") { data, err in
  print(data!.value(forKey: "message")!)
}

                                        
                                      
JSON Respuesta:
{
    "success": true,
    "message": "Success, User verified",
    "status": 200,
    "code": "validation_01"
}
                                  
XML Respuesta:
                                    
<hash>
   <success>true</success>
   <message>Success, User Verified</message>
   <status>200</status>
   <code>validation_01</code>
</hash>

(Autenticación de Doble Factor) Reenvío

Si tu usuario no recibe el código inicial, puedes usar el método “Reenvío” para hacer reintentos. Te sugerimos poner un timer de por lo menos 40 segundos entre reintentos. Si tu usuario no está recibiendo el mensaje de texto puedes usar el parámetro “voice” para hacerle una llamada en lugar de enviar un SMS.

Encabezados
Atributo Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Formato de URL
Nombre Descripción Tipo de Dato
format   Obligatorio   El formato en el que espera la respuesta de la llamada a la API.
  json   Respuesta en formato JSON.
  xml   Respuesta en formato XML.
  Text  
Atributos
Atributo Descripción Tipo de Dato
phone_number   Obligatorio   Número de telefono a verificar, formato: XXXXXXXXXX.   Text  
country_code   Obligatorio   Código de país al que desea enviar el mensaje. Consulta nuestra lista de países en las que tenemos disponible nuestro servicio de envío de SMS.   Number  
code_length   Opcional   Longitud del código de verificación. Por defecto   4  .
  Number  
expiration_date   Opcional   Fecha de expiración para el código de verificación. Por defecto 24 hrs. Formato de ejemplo   2000-01-31 14:18:00  .
  Text  
locale   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
company   Opcional   Nombre de la compañía mostrada al usuario en el mensaje de verificación.

  Text  
reset_code   Opcional   Reinicia el código de verificación, por defecto false
  true  Genera un nuevo código aleatorio
  false   Conserve el mismo código de verificación que generó la última vez
  Boolean  
voice   Opcional   Canal de voz para enviar tu mensaje, el usuario recibie una llamada con el código de verificación
  true   Realiza una llamada por teléfono con voz robótica en vez de enviar un SMS
  false   Envía el código a través de un SMS
  Boolean  
showcode   Opcional   Para recibir dentro de la respuesta a tu petición el código autogenerado y enviado a tu cliente indica este atributo con   1  . Por defecto   0  .
  Boolean  
Estatus del proceso
Código Mensaje
verification_01 Código generado exitosamente
verification_03 verification_03_resend - translation error
verification_05 Error enviando el mensaje de verificación
verification_07 Número incorrecto
verification_08 Código de país incorrecto
verification_09 Longitud del código de verificación no permitida
verification_10 Error general creando registro
verification_11 Nombre de compañía muy largo
verification_12 Parámetro de voz incorrecto
verification_13 Fecha de expiración inválida
verification_14 Parámetro reset_code incorrecto
verification_15 Parámetro code_number incorrecto

(Autenticación de Doble Factor) Reenvío

 POST  https://api.smsmasivos.com.mx/protected/{format}/phones/verification/resend 
Ejemplo de solicitud del código de verificación:
                                      
curl -X POST "https://api.smsmasivos.com.mx/protected/json/phones/verification/resend" -H "apikey: your_apikey" -d "phone_number=your_phone_number&country_code=your_country_code"
                                      
                                    
                                        
$params = array(
  "phone_number" => your_phone_number,
  "country_code" => your_country_code
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/protected/json/phones/verification/resend",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/protected/json/phones/verification/resend")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "phone_number" => your_phone_number,
  "country_code" => country_code
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/protected/json/phones/verification/resend");
var postData = "phone_number=your_phone_number&";
postData += "country_code=your_country_code";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/protected/json/phones/verification/resend'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "phone_number": your_phone_number,
      "country_code": your_country_code
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/protected/json/phones/verification/resend"
headers = {
  'apikey':your_apikey
}
data = {
  'phone_number':your_phone_number,
  'country_code':your_country_code
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.forwardingDoubleFactor("your_apikey","your_phone_number","your_country_code","your_code_length","your_expiration_date","your_company_name","language_selected", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getMessage());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

let expiration_date = Date.init(timeIntervalSinceNow: 86400)

sms.registryDoubleFactor(phone_number: "your_phone_number", country_code: "your_country_code", code_length: "code_length", expiration_date: "expiration_date", company:"your_company_name", lang: "es") { data, err in
  print(data!.value(forKey: "message")!)
}

                                        
                                      
JSON Respuesta:
{
    "success": true,
    "message": "Code successfully generated",
    "status": 200,
	"code": "verification_01",
	"verification_code": "XXXX" [Opcional]
}
                                  
XML Respuesta:
<hash>
   <success>true</success>
   <message>Code successfully generated</message>
   <status>200</status>
   <code>verification_01</code>
   <verification_code>XXXX</verification_code> [Opcional]
</hash>

(Autenticación de Doble Factor) Reinicio

Una vez que tu usuario valida su número, el sistema de manera default no lo deja volver a validarlo, notificándote que es un usuario ya confirmado. Si planeas usar el sistema de 2FA para envío de contraseñas únicas puedes usar el método “Reinicio”, lo que te permitirá correr el proceso de registro nuevamente.

Encabezados
Atributo Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Formato de URL
Nombre Descripción Tipo de Dato
format   Obligatorio   El formato en el que espera la respuesta de la llamada a la API.
  json   Respuesta en formato JSON.
  xml   Respuesta en formato XML.
  Text  
Atributos
Atributo Descripción Tipo de Dato
phone_number   Obligatorio   Número de telefono a verificar, formato: XXXXXXXXXX.   Text  
country_code   Obligatorio   Código de país al que desea enviar el mensaje. Consulta nuestra lista de países en las que tenemos disponible nuestro servicio de envío de SMS.   Number  
reset_code   Opcional   Reinicia el código de verificación, por defecto false
  true  Genera un nuevo código aleatorio
  false   Conserve el mismo código de verificación que generó la última vez
  Boolean  
showcode   Opcional   Para recibir dentro de la respuesta a tu petición el código autogenerado y enviado a tu cliente indica este atributo con   1  . Por defecto   0  .
  Boolean  
Estatus del proceso
Código Mensaje
verification_01_reset Código generado exitosamente
verification_03_reset Código ya enviado. Esperando por validación
verification_07 Número incorrecto
verification_08 Código de país incorrecto
verification_10 Error general creando registro
verification_14 Parámetro reset_code incorrecto
verification_15 Parámetro code_number incorrecto

(Autenticación de Doble Factor) Reinicio

 POST  https://api.smsmasivos.com.mx/protected/{format}/phones/verification/reset 
Ejemplo de solicitud del código de verificación:
                                      
curl -X POST "https://api.smsmasivos.com.mx/protected/json/phones/verification/reset" -H "apikey: your_apikey" -d "phone_number=your_phone_number&country_code=your_country_code&reset_code=true"
                                      
                                    
                                        
$params = array(
  "phone_number" => your_phone_number,
  "country_code" => your_country_code,
  "reset_code" => true
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/protected/json/phones/verification/reset",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/protected/json/phones/verification/reset")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "phone_number" => your_phone_number,
  "country_code" => country_code,
  "reset_code" => true
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/protected/json/phones/verification/reset");
var postData = "phone_number=your_phone_number&";
postData += "country_code=your_country_code";
postData += "reset_code=true";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/protected/json/phones/verification/reset'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "phone_number": your_phone_number,
      "country_code": your_country_code,
      "reset_code" => true
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/protected/json/phones/verification/reset"
headers = {
  'apikey':your_apikey
}
data = {
  'phone_number':your_phone_number,
  'country_code':your_country_code,
  'reset_code' : true
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.forwardingDoubleFactor("your_apikey","your_phone_number","your_country_code","reset_code", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getMessage());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

let expiration_date = Date.init(timeIntervalSinceNow: 86400)

sms.registryDoubleFactor(phone_number: "your_phone_number", country_code: "your_country_code", reset_code: "reset_code_value") { data, err in
  print(data!.value(forKey: "message")!)
}

                                        
                                      
JSON Respuesta:
{
    "success": true,
    "message": "Successfully reset user",
    "status": 200,
	"code": "verification_01",
	"verification_code": "XXXX" [Opcional]
}
                                  
XML Respuesta:
<hash>
   <success>true</success>
   <message>Successfully reset user</message>
   <status>200</status>
   <code>verification_01</code>
   <verification_code>XXXX</verification_code> [Opcional]
</hash>

Obtener agendas

Obten información de tus agendas como: Nombre, descripción, fecha de creación y list key

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado

Obtener agendas

Para consultar las agendas debes hacer una petición a la siguiente dirección

 POST  https://api.smsmasivos.com.mx/agendas/get 
Ejemplo de consultar agendas:
                                      
curl -X POST "https://api.smsmasivos.com.mx/agendas/get" -H "apikey: your_apikey" -d
                                      
                                    
                                        
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/agendas/get",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query(array()),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/agendas/get")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data()
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/agendas/get");
var postData = "";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/agendas/get'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {}
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/agendas/get"
headers = {
  'apikey':your_apikey
}
data = {}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "result": [
        {
            "agenda_name": "Agenda nombre",
            "agenda_description": "Agenda despcriocion",
            "agenda_creation_date": "2020-01-01 01:01:00",
            "list_key": "aaaaabbbbbbcccc"
        }
      ],
  "status":200,
  "code":"agendas_01"
}
                                  

Cambiar nombre de la agenda

Cambia el nombre de tu agenda, para que la mantengas actualizada

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
list_key   Obligatorio   Clave hash de la agenda/canal a la que deseas agregar o actualizar el contacto.   Text  
agenda_name   Obligatorio   Nombre de la agenda   Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
err_01 No existe la agenda
change_name_02 List key no definido
change_name_03 Nombre de agenda no definido
change_name_04 Error al modificar el nombre de la agenda

Cambiar nombre de la agenda

Para cambiar el nombre de la agenda debes hacer una petición a la siguiente dirección

 POST  https://api.smsmasivos.com.mx/agendas/change_name 
Ejemplo para cambiar el nombre de la agenda
                                      
curl -X POST "https://api.smsmasivos.com.mx/agendas/change_name" -H "apikey: your_apikey" -d "list_key=your_list_key&agenda_name=your_agenda_name"
                                      
                                    
                                        
$params = array(
  "list_key" => your_list_key,
  "agenda_name" => your_agenda_name
);

$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/agendas/change_name",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/agendas/change_name")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "list_key" => your_list_key,
  "agenda_name" => your_agenda_name
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/agendas/change_name");
var postData = "list_key=your_list_key&agenda_name=your_agenda_name";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/agendas/change_name'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "list_key": your_list_key,
      "agenda_name": your_agenda_name
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/agendas/change_name"
headers = {
  'apikey':your_apikey
}
data = {
  'list_key':your_list_key,
  'agenda_name':your_agenda_name
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "message": "Nombre de la agenda modificado correctamente",
  "status":200,
  "code":"change_name_01"
}
                                  

Eliminar agenda

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
list_key   Obligatorio   Clave hash de la agenda/canal a la que deseas agregar o actualizar el contacto.   Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
err_01 No existe la agenda
get_contacts_02 List key no definido

Eliminar agenda

Para eliminar la agenda debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/agendas/delete 
Ejemplo para eliminar una agenda
                                      
curl -X POST "https://api.smsmasivos.com.mx/agendas/delete" -H "apikey: your_apikey" -d "list_key=your_list_key"
                                      
                                    
                                        
$params = array(
  "list_key" => your_list_key
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/agendas/delete",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/agendas/delete")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "list_key" => your_list_key
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/agendas/delete");
var postData = "list_key=your_list_key";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/agendas/delete'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "list_key": your_list_key
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/agendas/delete"
headers = {
  'apikey':your_apikey
}
data = {
  'list_key':your_list_key
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "message": "Agenda eliminada correctamente",
  "status":200,
  "code":"delete_01"
}
                                  

Obtener contactos de una agenda

Obten información de los contactos de tu agenda como: Nombre, número, email y fecha de registro

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
list_key   Obligatorio   Clave hash de la agenda/canal a la que deseas agregar o actualizar el contacto.   Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
err_01 No existe la agenda
get_contacts_02 List key no definido

Obtener contactos de una agenda

Para consultar los contactos de una agenda debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/agendas/get_contacts 
Ejemplo de consultar contactos:
                                      
curl -X POST "https://api.smsmasivos.com.mx/agendas/get_contacts" -H "apikey: your_apikey" -d "list_key=your_list_key"
                                      
                                    
                                        
$params = array(
  "list_key" => your_list_key
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/agendas/get_contacts",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/agendas/get_contacts")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "list_key" => your_list_key
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/agendas/get_contacts");
var postData = "list_key=your_list_key";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/agendas/get_contacts'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "list_key": your_list_key
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/agendas/get_contacts"
headers = {
  'apikey':your_apikey
}
data = {
  'list_key':your_list_key
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "result": [
        {
            "contact_name": "",
            "contact_number": "477123456",
            "contact_email": "[email protected]",
            "contact_creation_date": "2020-01-01 01:01:01"
        }
    ],
  "status":200,
  "code":"get_contacts_01"
}
                                  

Agregar o actualizar contacto

Agrega información de tus contactos como: nombre, número y/o correo electrónico a cualquier agenda/canal que tengas configurado en el panel.

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
list_key   Obligatorio   Clave hash de la agenda/canal a la que deseas agregar o actualizar el contacto.   Text  
number   Obligatorio   Número del contacto a registrar.
  Nota 1:   El número del contacto NO debe contener el código de país.
  Nota 2:   No puedes registrar 2 o más veces un número en la misma agenda/canal.
  Text  
name   Opcional   Nombre del contacto a registrar o actualizar.   Text  
email   Opcional   Cuenta de correo electrónico del contacto a registrar o actualizar.   Text  
custom_field_1   Opcional   Campo personalizado del contacto a registrar o actualizar.   Text  
custom_field_2   Opcional   Campo personalizado del contacto a registrar o actualizar.   Text  
custom_field_3   Opcional   Campo personalizado del contacto a registrar o actualizar.   Text  
custom_field_4   Opcional   Campo personalizado del contacto a registrar o actualizar.   Text  
birthday_date   Opcional   Fecha de nacimiento del contacto a registrar o actualizar   2000-01-31  .   Text  
facebook   Opcional   Perfil de Facebook del contacto a registrar o actualizar.   Text  
twitter   Opcional   Perfil de Twitter del contacto a registrar o actualizar.   Text  
linkedin   Opcional   Perfil de Linkedin del contacto a registrar o actualizar.   Text  
instagram   Opcional   Perfil de Instagram del contacto a registrar o actualizar.   Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
contact_01 Clave hash no definida
contact_02 Número no definido
contact_03 Número con formato incorrecto
contact_04 Nombre muy largo
contact_05 Correo electrónico con formato incorrecto
contact_06 Correo electrónico es muy largo, máximo 100 caracteres
contact_07 Agenda/Canal no encontrada
contact_10 Contacto existe (número duplicado en la misma agenda/canal)
contact_11, contact_12 Error al agregar el contacto
contact_14 Error al actualizar el contacto

Agregar o actualizar contacto

Para agregar un contacto debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/contacts/add 
Ejemplo de agregar contacto:
                                      
curl -X POST "https://api.smsmasivos.com.mx/contacts/add" -H "apikey: your_apikey" -d "list_key=your_list_key&number=your_contact_number"
                                      
                                    
                                        
$params = array(
  "list_key" => your_list_key,
  "number" => your_contact_number
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/contacts/add",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/contacts/add")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "list_key" => your_list_key,
  "number" => your_contact_number
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/contacts/add");
var postData = "list_key=your_list_key&";
postData += "number=your_contact_number&";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/contacts/add'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "list_key": your_list_key,
      "number": your_contact_number
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/contacts/add"
headers = {
  'apikey':your_apikey
}
data = {
  'list_key':your_list_key,
  'number':your_contact_number
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        

import com.vzert.smsmasivos.api.*;

...

apismsmasivos sms = new apismsmasivos(this);

sms.addContact("your_apikey","your_list_key","4771234567","your_contact_name","your_contact_email","language_selected", ( new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
        if (response.isSuccessful()) {
            // TODO RESPONSE
            Log.d("SMS_RESPONSE", response.body().getMessage());
        }
    }
    @Override
    public void onFailure(Call call, Throwable t) {
        // TODO ERROR
    }
}));

                                        
                                      
                                        

import apismsmasivos

...

var sms = apismsmasivos(apikey: "your_apikey")

sms.addContact(list_key: "your_list_key", number: "your_contact_number", name: "your_contact_name", email: "your_contact_email", lang: "es") { data, err in
  print(data!.value(forKey: "message")!)
}

                                        
                                      
Respuesta:
{
  "success":true,
  "message":"Contacto agregado",
  "status":200,
  "code":"contact_13"
}
                                  

Eliminar contacto

Elimina algún contacto de tu agenda.

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
list_key   Obligatorio   Clave hash de la agenda/canal a la que deseas agregar o actualizar el contacto.   Text  
number   Opcional   Número de teléfono del contacto a eliminar   Number  
email   Opcional   Email del contacto a eliminar   Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
contact_01 List key no definido
contact_02 Número con formato incorrecto
contact_03 Correo electrónico con formato incorrecto
contact_04 Correo electrónico es muy largo, máximo 100 caracteres
contact_05 Defina el número o email del contacto para poder completar su petición
contact_06 El contacto no existe
contact_08 List key no definido

Eliminar contacto

Para eliminar un contacto de una agenda debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/contacts/delete 
Ejemplo para eliminar un contacto:
                                      
curl -X POST "https://api.smsmasivos.com.mx/contacts/delete" -H "apikey: your_apikey" -d "list_key=your_list_key&number=your_number_phone"
                                      
                                    
                                        
$params = array(
  "list_key" => your_list_key,
  "number" => your_number_phone
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/contacts/delete",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/contacts/delete")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "list_key" => your_list_key,
  "number" => your_number_phone
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/contacts/delete");
var postData = "list_key=your_list_key&number=your_number_phone";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/contacts/delete'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "list_key": your_list_key
      "number": your_number_phone
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/contacts/delete"
headers = {
  'apikey':your_apikey
}
data = {
  'list_key':your_list_key
  'number':your_number_phone
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "message": "Contacto(s) eliminado correctamente",
  "status":200,
  "code":"err_07"
}
                                  

Webhook para confirmación de entrega y respuestas de destinatarios

Modifica los valores de tu webhook para la confirmación de lectura, como los son url y su estatus

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
url   Obligatorio   Webhook valor de conversión   Text  
status   Obligatorio   Estatus del webhook
  1   Habilitado.
  0   Deshabilitado.
  Number  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
add_webhook_02 Url de webhook indefinida
add_webhook_03 Formato de url inválida
add_webhook_04 Estatus de webhook indefinido
add_webhook_05 Estatus de webhook invalido
add_webhook_06 No funciona Url del webhook
add_webhook_07 Error al agregar su url
add_webhook_08 Error al agregar su url

Eliminar contacto

Para eliminar un contacto de una agenda debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/webhook/add 
Ejemplo para eliminar un contacto:
                                      
curl -X POST "https://api.smsmasivos.com.mx/webhook/add" -H "apikey: your_apikey" -d "url=your_url&status=your_status"
                                      
                                    
                                        
$params = array(
  "url" => your_url,
  "status" => your_status
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/webhook/add",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/webhook/add")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "url" => your_url,
  "status" => your_status
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/webhook/add");
var postData = "url=your_url&status=your_status";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/webhook/add'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "url": your_url,
      "status": your_status
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/webhook/add"
headers = {
  'apikey':your_apikey
}
data = {
  'url':your_url,
  'status':your_status
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "message": "Url agregada correctamente",
  "status":200,
  "code":"add_webhook_01"
}
                                  

Consultar webhook

Obten la información de tu webhook, como lo es su url y su estatus

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
webhook_02 Error al obtener su webhook

Consultar webhook

Para consultar tu webhook debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/webhook/get 
Ejemplo para consultar tu webhook
                                      
curl -X POST "https://api.smsmasivos.com.mx/webhook/get" -H "apikey: your_apikey"
                                      
                                    
                                        
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/webhook/get",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query(array()),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/webhook/get")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data()
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/webhook/get");
var postData = "";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/webhook/get'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {}
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/webhook/get"
headers = {
  'apikey':your_apikey
}
data = {}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "result": {
    "url": "https://webhooktest.com",
    "status": 1
  },
  "status":200,
  "code":"webhook_01"
}
                                  

Modificar estatus del webhook

Modifica el estatus de tu webhook

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
status   Obligatorio   Estatus del webhook
  1   Habilitado.
  0   Deshabilitado.
  Number  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
status_webhook_02 Estatus de webhook indefinido
status_webhook_03 Estatus de webhook invalido
status_webhook_04 Error al modificar el estatus del webhook
status_webhook_05 Error al modificar el estatus del webhook

Modificar estatus del webhook

Para cambiar el estatus de tu webhook debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/webhook/status 
Ejemplo para cambiar el estatus del webhook:
                                      
curl -X POST "https://api.smsmasivos.com.mx/webhook/status" -H "apikey: your_apikey" -d "status=your_status"
                                      
                                    
                                        
$params = array(
  "status" => your_status
);
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/webhook/status",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query($params),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/webhook/status")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "status" => your_status
)
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/webhook/status");
var postData = "status=your_status";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/webhook/status'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "status": your_status
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/webhook/status"
headers = {
  'apikey':your_apikey
}
data = {
  'status':your_status
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "message": "Estatus actualizado correctamente",
  "status":200,
  "code":"status_webhook_01"
}
                                  

Eliminar webhook

Encabezados
Encabezados Descripción Tipo de Dato
apikey   Obligatorio   Clave API generada en la sección de integraciones dentro del panel.   Text  
Atributos
Atributo Descripción Tipo de Dato
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
Errores
Código Mensaje
auth_01 Usuario no autorizado
delete_webhook_02 Error al eliminar el webhook
delete_webhook_03 Error al eliminar el webhook

Eliminar webhook

Para eliminar tu webhook debes hacer una petición a la siguiente dirección:

 POST  https://api.smsmasivos.com.mx/webhook/delete 
Ejemplo para eliminar tu webhook
                                      
curl -X POST "https://api.smsmasivos.com.mx/webhook/delete" -H "apikey: your_apikey"
                                      
                                    
                                        
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "https://api.smsmasivos.com.mx/webhook/delete",
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_HTTPHEADER => $headers,
  CURLOPT_POST => 1,
  CURLOPT_POSTFIELDS => http_build_query(array()),
  CURLOPT_RETURNTRANSFER => 1
));
$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);
                                        
                                      
                                        
require 'net/http'
require 'uri'

uri = URI.parse("https://api.smsmasivos.com.mx/webhook/delete")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data()
req_options = {
  use_ssl: uri.scheme == "https",
}
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body
                                        
                                      
                                        
var request = (HttpWebRequest)WebRequest.Create("https://api.smsmasivos.com.mx/webhook/delete");
var postData = "";
var data = Encoding.ASCII.GetBytes(postData);
Console.WriteLine(postData.ToString());
request.Method = "POST";
request.Headers["apikey"] = your_apikey;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
using (var stream = request.GetRequestStream())
{
  stream.Write(data, 0, data.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);
                                        
                                      
                                        
var request = require('request');

var targetURL = 'https://api.smsmasivos.com.mx/webhook/delete'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {}
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);
                                        
                                      
                                        
import requests

targetURL = "https://api.smsmasivos.com.mx/webhook/delete"
headers = {
  'apikey':your_apikey
}
data = {}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)
                                        
                                      
                                        



                                        
                                      
                                        



                                        
                                      
Respuesta:
{
  "success":true,
  "message": "Webhook eliminado correctamente",
  "status":200,
  "code":"delete_webhook_01"
}
                                  

SMS por SMPP

Si está interesado en este tipo de envíos comunícate con nosotros   [email protected]   con gusto te asesoraremos.

Librerías de ejemplo

Lista de lenguajes disponibles

Lenguaje Recursos
PHP Link del ejemplo:   Ejemplo librería PHP  
NodeJS Link del ejemplo:   Ejemplo librería NodeJS  
C# Link del ejemplo:   Ejemplo librería C#  
VB.NET Link del ejemplo:   Ejemplo librería .NET  
Python Link del ejemplo:   Ejemplo librería Python  
JAVA Link del ejemplo:   Ejemplo librería JAVA  
Ruby Link del ejemplo:   Ejemplo librería Ruby  
Android SDK Link del ejemplo:   Ejemplo librería Android  
iOS SDK Link del ejemplo:   Ejemplo librería iOS  

Países

Lista de los países en los que está disponible nuestro servicio de envío de SMS

País
Argentina   54  
Chile   56  
Colombia   57  
México   52