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   Se solicita por cuestión de estandarización, siempre se debe enviar 52 que es el código correspondiente a México   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  
sender   Opcional   Agrega el nombre con hasta 11 caracteres alfanuméricos del remitente que contrataste. Si no lo tienes contratado, este parámetro se ignora.

  Nota 1:   El remitente personalizado es un servicio que puedes contratar y que te permite enviar mensajes con el nombre de tu empresa en vez de un número, si te interesa información de su contratación, escríbenos en el chat.
  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 como si los enviaras en modo producción y estarán disponibles en reportes.

  Nota 1:   Solo puedes enviar 1000 mensajes en modo de prueba por día.
  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  
  Nota 2:   El horario está expresado en zona horaria del centro de México. (Horario Central Standard Time (CST), UTC -6)
  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.
sms_21 Formato de fecha inválido
sms_24 Lada no soportada

Enviar SMS

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

 POST  /sms/send 
Ejemplo de envio SMS:
              
curl -X POST "/sms/send" -H "apikey: your_apikey" -d "message=your_message_to_send&numbers=your_list_of_numbers&country_code=your_country_code"

            
              
curl -X GET "/sms/send" -d "message=your_message_to_send&numbers=your_list_of_numbers&country_code=your_country_code&apikey=your_apikey" 

            
                
$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 => "/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);

              
                
$params = array(
  "message" => "your_message_to_send",
  "numbers" => "your_list_of_numbers",
  "country_code" => "your_country_code",
  "apikey" => "your_apikey"
);

$url = "/sms/send?" . http_build_query($params);

$ch = curl_init();
curl_setopt_array($ch, array(
  CURLOPT_URL => $url,
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_RETURNTRANSFER => 1
));

$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);

              
                
require 'net/http'
require 'uri'

uri = URI.parse("/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


              
                  
require 'net/http'
require 'uri'

uri = URI.parse("/sms/send")
params = {
  "message" => "your_message_to_send",
  "numbers" => "your_list_of_numbers",
  "country_code" => "your_country_code",
  "apikey" => "your_apikey"
}

uri.query = URI.encode_www_form(params)

response = Net::HTTP.get_response(uri)

puts response.body

              
                

var request = (HttpWebRequest)WebRequest.Create("/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 url = "/sms/send";
var queryParams = $"message=your_message_to_send&numbers=your_list_of_numbers&country_code=your_country_code&apikey=your_apikey";
var requestUrl = url + "?" + queryParams;

var request = (HttpWebRequest)WebRequest.Create(requestUrl);
request.Method = "GET";

var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);

              
                

var request = require('request');

var targetURL = '/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);
    }
  }
);

              
                

var request = require('request');

var targetURL = "/sms/send";
var queryParams = `message=your_message_to_send&numbers=your_list_of_numbers&country_code=your_country_code&apikey=your_apikey`;
var requestURL = `${targetURL}?${queryParams}`;

request.get(
  {
    url: requestURL
  }, (err, res, body) => {
    if (err == null) {
      console.log(body);
    }
  }
);

              
                

import requests

targetURL = "/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 requests

targetURL = "/sms/send"
params = {
  'message': 'your_message_to_send',
  'numbers': 'your_list_of_numbers',
  'country_code': 'your_country_code',
  'apikey': 'your_apikey'
}

r = requests.get(url=targetURL, params=params)

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")!)
}

              
                
No available
              
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.
              
curl -X POST "/credits/consult" -H "apikey: your_apikey"

            
                
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "/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("/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("/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 = '/credits/consult'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    }
  }, (err, res, body) => {
    if(err == null){
      console.log(body);
    }
  }
);

              
                
import requests

targetURL = "/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")!)
}

              
                
No available
              
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'. Además, la URL proporcionada debe poder recibir peticiones de tipo HEAD, así verificamos su correcto funcionamiento. A esta URL pasaremos por método GET, o POST, 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. De la misma forma, es importante que tu sistema acepte peticiones con el encabezado 'Content-Type: application/x-www-form-urlencoded', en caso de solicitar la información por el método POST.

Parámetros a recibir
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   Entregado
  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:

 https://dominio.com/path/to/url  
Llamada a URL
              
    curl -X POST " https://dominio.com/path/to/url " 
-H "Content-Type: application/x-www-form-urlencoded"
-d "type=confirmation&reference=reference_value&status=status_value&number=number_value&date=date_value"
              
    curl -X GET " https://dominio.com/path/to/url ?type=confirmation&reference=reference_value&status=status_value&number=number_value&date=date_value" 
    
            
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              

Respuestas de SMS

Cuando tu cliente responde a uno de tus SMS podemos reenviarte esa respuesta, para esto requerimos de una URL que darás de alta en tu panel en la sección de 'Integraciones'. La URL proporcionada debe poder recibir peticiones de tipo HEAD, así verificamos su correcto funcionamiento. Así, enviaremos por método GET, o POST, las respuestas 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 una vez que las recibas. De la misma forma, es importante que tu sistema acepte peticiones con el encabezado Content-Type: application/x-www-form-urlencoded', en caso de solicitar el método POST.

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 recibir
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:

 https://dominio.com/path/to/url  
Llamada a URL
              
    curl -X POST " https://dominio.com/path/to/url " 
-H "Content-Type: application/x-www-form-urlencoded"
-d "type=response&reference=reference_value&number=number_value&message=message_value&response=response_value&send_date=send_date_value&response_date=response_date_value"
              
    curl -X GET " 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" 
    
            
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              

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 de su reporte. Ejemplo:   2020-10-21 00:00:00     Text  
end_date   Obligatorio   Fecha de fin de su reporte. Ejemplo:   2020-10-21 23:59:59     Text  
lang   Opcional   Idioma de la respuesta. Por defecto   es  .
  es   Español.
  en   Inglés.
  Text  
sandbox   Opcional   Indica este parámetro solo si requieres trabajar en un ambiente de pruebas y obtener los mensajes enviados por API Envío y multienvío en modo Sandbox el mismo día de tu petición a API Reporte. El parámetro Sandbox debe tener el valor   1     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
              
curl -X POST "/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 => "/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("/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("/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 = '/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 = "/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")!)
}

              
                
No available
              
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   Se solicita por cuestión de estandarización, siempre se debe enviar 52 que es el código correspondiente a México   Number  
template   Obligatorio   Envía como valor, solo la letra de la plantilla que quieres utilizar.
Los parámetros {{company}} y {{code}} serán utilizados como variables dentro de tu plantilla..

  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}}
  k   Este template te permite enviar un mensaje de voz personalizado definido en el parámetro {{voice_message}}. Para este template no deberás usar el parámetro {{code}}
  Text  
company   Opcional   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  
voice_message   Opcional   Mensaje de texto con máximo 160 caracteres que será convertido en voz.
Únicamente son permitidos letras, números, comas y puntos. Este parámetro es obligatorio al usar el template k.

  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
              
curl -X POST "/voice/send " -H "apikey: your_apikey" -d "numbers=your_phone_number&template=your_template_option&country_code=your_country_code&code=your_verification_code&company=your_company"

            
                
$params = array(
  "numbers" => 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 => "/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("/voice/send")
headers = {
  "apikey": your_apikey
}
request = Net::HTTP::Post.new(uri, headers)
request.set_form_data(
  "numbers" => 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("/voice/send");
var postData = "numbers=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 = '/voice/send'
var response = request.post(
  {
    url: targetURL,
    headers: {
      "apikey": your_apikey
    },
    form: {
      "numbers": 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 = "/voice/send"
headers = {
  'apikey':your_apikey
}
data = {
  'numbers':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(numbers: "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")!)
}

              
                
No available
              
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

Importante

No puedes usar WhatsApp para enviar mensajes masivos, si lo haces vamos a suspender tu cuenta

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.

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. Por defecto
  text   Envío de mensaje de texto.
  image   Envío de imagen.
  video   Envío de video.
  audio   Envío de audio.
  document   Envío de documento.
  Text  
number   Obligatorio   Número del contacto a 10 dígitos (si el número tiene 12 dígitos se deberá usar el parámetro find_country_code)   Text  
country_code   Obligatorio   Se solicita por estandarización y siempre se deberá ser 52   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   image  ,   video  ,   audio   o   document   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  
  Nota 2:   El horario está expresado en zona horaria del centro de México. (Horario Central Standard Time (CST), UTC -6)
  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_09, whatsapp_10, whatsapp_33 Error al enviar el mensaje, instancia desconectada
whatsapp_19 Error al enviar el mensaje a WhatsApp
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
whatsapp_28 Máximo 1,000 caracteres por mensaje de texto vía WhatsApp.
whatsapp_29 Formato de fecha inválido
whatsapp_30 Error al generar la confirmación de lectura
whatsapp_31 Error en conexión con el servidor
whatsapp_32 Número sin WhatsApp

Enviar mensaje vía WhatsApp

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

 POST  /whatsapp/send 
Ejemplo de envío de mensaje de texto vía WhatsApp
              
curl -X POST "/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"

            
              
curl -X GET "/whatsapp/send" -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&apikey=your_apikey" 

            
                
$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 => "/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);

              
                
$params = array(
  "instance_id" => your_message_to_send,
  "type" => your_list_of_numbers,
  "number" => your_country_code,
  "country_code" => 52,
  "message" => your_message,
  "apikey" => your_apikey
);

$url = "/whatsapp/send?" . http_build_query($params);

$ch = curl_init();
curl_setopt_array($ch, array(
  CURLOPT_URL => $url,
  CURLOPT_SSL_VERIFYPEER => 0,
  CURLOPT_HEADER => 0,
  CURLOPT_RETURNTRANSFER => 1
));

$response = curl_exec($ch);
curl_close($ch);

echo json_encode($response);

              
                
require 'net/http'
require 'uri'

uri = URI.parse("/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

              
                  
require 'net/http'
require 'uri'

uri = URI.parse("/whatsapp/send")
params = {
  "instance_id" => your_message_to_send,
  "type" => your_list_of_numbers,
  "number" => your_country_code,
  "country_code" => 52,
  "message" => your_message,
  "apikey" => your_apikey
}

uri.query = URI.encode_www_form(params)

response = Net::HTTP.get_response(uri)

puts response.body

              
                
var request = (HttpWebRequest)WebRequest.Create("/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 url = "/whatsapp/send";
var queryParams = $"instance_id=your_whatsapp_instance_id&type=type_to_send&number=number_to_send&country_code=country_code_to_send&message=message_to_send&apikey=your_apikey";
var requestUrl = url + "?" + queryParams;

var request = (HttpWebRequest)WebRequest.Create(requestUrl);
request.Method = "GET";

var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

Console.WriteLine(responseString);

              
                
var request = require('request');

var targetURL = '/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);
    }
  }
);

              
                

var request = require('request');

var targetURL = "/whatsapp/send";
var queryParams = `instance_id=your_whatsapp_instance_id&type=type_to_send&number=number_to_send&country_code=country_code_to_send&message=message_to_send&apikey=your_apikey`;
var requestURL = `${targetURL}?${queryParams}`;

request.get(
  {
    url: requestURL
  }, (err, res, body) => {
    if (err == null) {
      console.log(body);
    }
  }
);

              
                
import requests

targetURL = "/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)

              
                

import requests

targetURL = "/whatsapp/send"
params = {
  'instance_id': 'your_whatsapp_instance_id',
  'type': 'type_to_send',
  'number': 'number_to_send',
  'country_code': 'your_country_code',
  'message': 'message_to_send',
  'apikey': 'your_apikey'
}

r = requests.get(url=targetURL, params=params)

print(r.text)

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

Respuestas de WhatsApp

Cuando tu cliente responde a uno de tus WhatsApp podemos reenviarte esa respuesta, para esto requerimos de un Webhook que darás de alta al momento de crear tu instancia de WhatsApp, esta posteriormente podrás editarla en el apartado de opciones de la misma. Pasaremos por método GET o POST 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. De la misma forma, es importante que tu sistema acepte peticiones con el encabezado Content-Type: application/x-www-form-urlencoded', en caso de solicitar el método POST.

En caso de que se nos proporciones una respuesta diferente, se desactivará el webhook, así mismo también deberás de aceptar peticiones de tipo HEAD, ya que con ellas validamos que tu Webhook se encuentre funcionando correctamente.

Parámetros a recibir
Atributo DescripcióN Tipo de Dato
type   text   Texto   Text  
message Mensaje que se envió al destinatario.   Text  
from Número del destinatario que respondió el mensaje.   Text  
timestamp Timestamp del mensaje cuando fue respondido   Text  

Respuestas de WhatsApp

Forma correcta de definir la URL para respuestas de destinatarios:

 https://dominio.com/path/to/url  
Llamada a URL
              
  curl -X POST " https://dominio.com/path/to/url " 
-H "Content-Type: application/x-www-form-urlencoded"
-d "type=text&message=Test_message&from=5214771234567×tamp=00000000"
              
  curl -X GET " https://dominio.com/path/to/url ?type=text&message=Test_message&from=5214771234567×tamp=00000000" 
  
            
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              
                
No available
              

(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   Se solicita por cuestión de estandarización, siempre se debe enviar 52 que es el código correspondiente a México   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. Longitud de 4 a 10 caracteres. Por defecto   4  .
  Number  
expiration_date   Opcional   Fecha de expiración para el código de verificación. Por defecto 24 hrs. Máximo 3 días. Formato de ejemplo   YYYY-MM-DD HH:mm:ss  .
  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   Devuelve el código de verificación generado   1  . Por defecto   0  .
  Boolean  
code_type   Opcional   Tipo de código generado, por defecto alfanumérico Por defecto   alphanumeric  
  alphanumeric   letras y números.
  numeric   números.
  letters   letras.
  Text  
template   Opcional   Envía como valor, solo la letra de la plantilla que quieres utilizar.
Los parámetros {{company}} y {{code}} serán utilizados como variables dentro de tu plantilla. Por defecto   a  
  a   {{company}} El codigo de verificacion es: {{code}}
  b   Ingresa el siguiente codigo en tu app de {{company}} para validar tu cuenta: {{code}}
  c   Ingresa el codigo {{code}} para activar tu cuenta de {{company}}
  d   El codigo de autenticacion para {{company}} 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}}
  k   {{company}}: {{code}} es tu codigo de seguridad
  l   Tu codigo de verificacion {{company}} es: {{code}} No compartas este codigo con nadie.
  m   Tu codigo {{company}} es: {{code}}
  n   Usa la clave {{code}} para ingresar a {{company}}
  Text  
sender   Opcional   Agrega el nombre con hasta 11 caracteres alfanuméricos del remitente que contrataste. Si no lo tienes contratado, este parámetro se ignora.

  Nota 1:   El remitente personalizado es un servicio que puedes contratar y que te permite enviar mensajes con el nombre de tu empresa en vez de un número, si te interesa información de su contratación, escríbenos en el chat.
  Text  
reference   Opcional   Regresa la referencia del mensaje enviado Por defecto   false  
  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 No hay ningún registro asociado con este número
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_type incorrecto
              
curl -X POST "/protected/{{format}}/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 => "/protected/{{format}}/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("/protected/{{format}}/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("/protected/{{format}}/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 = '/protected/{{format}}/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 = "/protected/{{format}}/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")!)
}

              
                
No available
              
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
              
curl -X POST "/protected/{{format}}/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 => "/protected/{{format}}/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("/protected/{{format}}/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("/protected/{{format}}/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 = 'h/protected/{{format}}/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 = "/protected/{{format}}/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")!)
}

              
                
No available
              
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   Se solicita por cuestión de estandarización, siempre se debe enviar 52 que es el código correspondiente a México   Number  
code_length   Opcional   Longitud del código de verificación. Longitud de 4 a 10 caracteres. Por defecto   4  .
  Nota:   Este parámetro se ignora si se solicita reenvío y se toma el valor inicial.
  Number  
expiration_date   Opcional   Fecha de expiración para el código de verificación. Por defecto 24 hrs. Máximo 3 días. Formato de ejemplo   YYYY-MM-DD HH:mm:ss  .
  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 alfanumérico de 4 caracteres a menos que se especifique lo contrario con los parámetro code_type y code_length.
  false   Conserve el mismo código de verificación que generó la última vez
  Nota:   Es necesario incluir el parámetro code_type, de lo contrario el nuevo código generado se creará bajo el formato alfanumerico
  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   Devuelve el código de verificación generado   1  . Por defecto   0  .
  Boolean  
code_type   Opcional   Tipo de código generado, por defecto alfanumérico Por defecto   alphanumeric  
  alphanumeric   letras y números.
  numeric   números.
  letters   letras.
  Nota:   Es necesario incluir el parámetro reset_code para cambiar el código, de lo contrario se enviará el código actual con el formato especificado durante su creación
  Text  
template   Opcional   Envía como valor, solo la letra de la plantilla que quieres utilizar.
Los parámetros {{company}} y {{code}} serán utilizados como variables dentro de tu plantilla. Por defecto   a  
  a   {{company}} El codigo de verificacion es: {{code}}
  b   Ingresa el siguiente codigo en tu app de {{company}} para validar tu cuenta: {{code}}
  c   Ingresa el codigo {{code}} para activar tu cuenta de {{company}}
  d   El codigo de autenticacion para {{company}} 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}}
  k   {{company}}: {{code}} es tu codigo de seguridad
  l   Tu codigo de verificacion {{company}} es: {{code}} No compartas este codigo con nadie.
  m   Tu codigo {{company}} es: {{code}}
  n   Usa la clave {{code}} para ingresar a {{company}}
  Text  
sender   Opcional   Agrega el nombre con hasta 11 caracteres alfanuméricos del remitente que contrataste. Si no lo tienes contratado, este parámetro se ignora.

  Nota 1:   El remitente personalizado es un servicio que puedes contratar y que te permite enviar mensajes con el nombre de tu empresa en vez de un número, si te interesa información de su contratación, escríbenos en el chat.
  Text  
reference   Opcional   Regresa la referencia del mensaje enviado Por defecto   false  
  Boolean  
Estatus del proceso
Código Mensaje
verification_01 Código generado exitosamente
verification_03 No hay ningún registro asociado con este número
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_type incorrecto
              
curl -X POST "/protected/{{format}}/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 => "/protected/{{format}}/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("/protected/{{format}}/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("/protected/{{format}}/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 = '/protected/{{format}}/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 = "/protected/{{format}}/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")!)
}

              
                
No available
              
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) Restablecimiento

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 “Restablecimiento”, lo que te permitirá correr el proceso de registro nuevamente. Es importante resaltar que este método no envía mensaje alguno, únicamente restablece (reinicia) el registro asociado a dicho número.

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   Se solicita por cuestión de estandarización, siempre se debe enviar 52 que es el código correspondiente a México   Number  
reset_code   Opcional   Reinicia el código de verificación, por defecto false
  true  Genera un nuevo código aleatorio alfanumérico de 4 caracteres a menos que se especifique lo contrario con los parámetro code_type y code_length.
  false   Conserve el mismo código de verificación que generó la última vez
  Boolean  
Estatus del proceso
Código Mensaje
verification_01 Usuario reiniciado correctamente
verification_03 No existe registro del usuario que intentas reiniciar
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_18 Lada no soportada
              
curl -X POST "/protected/{{format}}/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 => "/protected/{{format}}/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("/protected/{{format}}/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("/protected/{{format}}/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 = '/protected/{{format}}/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 = "/protected/{{format}}/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")!)
}

              
                
No available
              
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>

Crear agenda

Agrega una nueva agenda junto con su descripción y campos personalizados.

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
agenda_name   Obligatorio   Nombre de la agenda   Text  
agenda_description   Opcional   Descripción de la agenda   Text  
custom_field_1   Opcional   Nombre para campo personalizado 1   Text  
custom_field_2   Opcional   Nombre para campo personalizado 2   Text  
custom_field_3   Opcional   Nombre para campo personalizado 3   Text  
custom_field_4   Opcional   Nombre para campo personalizado 4   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
agenda_02 Nombre de agenda indefinido
agenda_03 El nombre de la agenda ya se encuentra registrada
agenda_04, agenda_05 Error al crear la agenda
              
  curl -X POST "/agendas/add" -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 => "/agendas/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("/agendas/add")
  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("/agendas/add");
  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 = '/agendas/add'
  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 = "/agendas/add"
  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)
  
              
                
No available
              
                
No available
              
                
No available
              
Respuesta:
    {
      "success": true,
      "message": Agenda creada correctamente
      "status": 200,
      "list_key": "aaaaabbbbbbcccc"
      "code": "agenda_01"
    }

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
              
curl -X POST "/agendas/get" -H "apikey: your_apikey" -d

            
                
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "/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("/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("/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 = '/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 = "/agendas/get"
headers = {
  'apikey':your_apikey
}
data = {}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)

              
                
No available
              
                
No available
              
                
No available
              
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 indefinido
change_name_03 Nombre de agenda no definido
change_name_04 Error al modificar el nombre de la agenda
              
curl -X POST "/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 => "/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("/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("/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 = '/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 = "/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)

              
                
No available
              
                
No available
              
                
No available
              
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 indefinido
              
curl -X POST "/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 => "/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("/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("/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 = '/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 = "/agendas/delete"
headers = {
  'apikey':your_apikey
}
data = {
  'list_key':your_list_key
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)

              
                
No available
              
                
No available
              
                
No available
              
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 indefinido
              
curl -X POST "/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 => "/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("/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("/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 = '/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 = "/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)

              
                
No available
              
                
No available
              
                
No available
              
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 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  
find_country_code   Opcional   Si el número contiene el código de país y no los puedes separar para mandar  number , puedes enviar  number  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 el número como se encuentra en el atributo  number 
  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
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
              
curl -X POST "/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 => "/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("/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("/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 = '/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 = "/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")!)

              
                
No available
              
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   Obligatorio   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 indefinido
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 indefinido
              
curl -X POST "/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 => "/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("/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("/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 = '/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 = "/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)

              
                
No available
              
                
No available
              
                
No available
              
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

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
              
curl -X POST "/webhook/get" -H "apikey: your_apikey"

            
                
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "/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("/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("/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 = '/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 = "/webhook/get"
headers = {
  'apikey':your_apikey
}
data = {}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)

              
                
No available
              
                
No available
              
                
No available
              
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.
              
curl -X POST "/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 => "/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("/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("/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 = '/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 = "/webhook/status"
headers = {
  'apikey':your_apikey
}
data = {
  'status':your_status
}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)

              
                
No available
              
                
No available
              
                
No available
              
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
              
curl -X POST "/webhook/delete" -H "apikey: your_apikey"

            
                
$headers = array(
  "apikey: your_apikey"
);
curl_setopt_array($ch = curl_init(), array(
  CURLOPT_URL => "/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("/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("/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 = '/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 = "/webhook/delete"
headers = {
  'apikey':your_apikey
}
data = {}
r = requests.post(url = targetURL, data = data, headers = headers)

print(r.text)

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

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
México   52