Regístrate y prueba GRATIS sin compromisos
 ES
Iniciar sesión Regístrate
EN
  • Inicio
  • API SMS

API de envío SMS http/POST

La API SMS http/POST está diseñada para técnicos y clientes que quieran conectar sus aplicaciones con la plataforma de mensajería SMS de LabsMobile.

Las funcionalidades de la API SMS http/POST son:

Esta documentación explica detalladamente el proceso de integración y automatización de estas funcionalidades.

Para iniciar una integración con la API http/POST son imprescindibles los siguientes requisitos:

  • Una cuenta de LabsMobile asociada con un nombre de usuario (correo electrónico de registro). Crea una cuenta aquí.
  • Token API utilizado como contraseña y generado desde la sección Configuración API de tu cuenta.
  • URL del endpoint de la API http/POST y los valores de los parámetros para realizar la petición.

A tener en cuenta

La API http/POST de LabsMobile es una API REST que utiliza el protocolo HTTP POST, el formato JSON para el intercambio de información y una URL base común para todas las peticiones: https://api.labsmobile.com/json/

Es recomendable utilizar una URL que incluya el protocolo HTTPS en cualquier versión de nuestra API.

Autenticación

El método de autenticación utilizado es Auth Basic HTTP.

Este tipo de autenticación consta de unas credenciales username:tokenapi que se incluyen en el encabezado de la petición HTTP codificado en base64().

Ejemplo de valor de encabezado de autenticación:
Authorization: Basic 9yewaXic21vYmlsZqS5jmSk04enFTbUU=

Recomendación Se pueden generar tokens API desde la Configuración API de la cuenta. Recomendamos cambiar el token frecuentemente y utilizar diferentes tokens para cada uso, conexión o integración.

Configuración y filtros

A continuación se detallan variables de configuración y aspectos de seguridad importantes en una integración con la API de envío SMS http/GET:

  • Dirección IP desde donde se enviarán los mensajes. Si se activa esta opción, sólo se admitirán peticiones de la lista de dirección IPs introducida. Esta funcionalidad es opcional, por defecto se aceptarán mensajes de cualquier IP.
  • Remitente por defecto (por defecto LABSMOBILE). Sólo algunos operadores permiten la asignación dinámica y con valor alfanumérico del campo remitente.
  • Límite de mensajes diario, por defecto 100.000 sms/día.
  • Límite de mensajes por batch, por defecto 10.000 sms/petición.
  • Filtro por países, para que sólo se procesen mensajes de una lista de países.
  • Filtro anti-duplicados, para evitar enviar mensajes iguales a un mismo destinatario.

Todos estos parámetros se pueden activar y modificar en la Configuración API y Preferencias de la cuenta.

Importante Se establece un máximo de 10 peticiones por segundo. Malos usos, abusos o un mayor volumen de peticiones provocarán un bloqueo temporal o permanente de la cuenta y/o dirección IP.

Recomendación Recomendamos activar las Recargas automáticas para que siempre existan créditos disponibles en la cuenta y no se interrumpa el servicio de envío SMS.

Envío de mensajes SMS

Petición para el envío de mensajes SMS de forma individual o masiva.

Con esta funcionalidad se pueden enviar mensajes en tiempo real o de forma programada para un día y hora específicos. Además, se pueden añadir otros parámetros como el remitente, etiqueta, identificador, modo simulado, etc.

ENDPOINT

POST https://api.labsmobile.com/json/send

  • Ampliar todo

    PARÁMETROS

    Los parametros o datos se envían en el cuerpo una llamada http/POST en formato JSON. A continuación se describen los valores y funcionalidad de todos los parámetros.

    Ejemplo formato JSON 
    {
"message":"Message text",
"tpoa":"Sender",
"recipient":
  [
    {"msisdn":"12015550123"},
    {"msisdn":"12015550124"},
    {"msisdn":"12015550125"},
  ],
"test":"1",
"subid":"L-203",
"label":"from]=websms;[user]=admin[campaign]=salesJanuary"
}

  • RESULTADO

    El resultado se obtiene en formato JSON con los siguientes elementos:

Código de ejemplo

Envío de mensaje estándar a un único destinatario:

Envío individual 
curl --user myUsername:myToken -X POST \
  https://api.labsmobile.com/json/send \
  -H 'Cache-Control: no-cache' \
  -H 'Content-Type: application/json' \
  -d '{"message":"Your verification code is 123", "tpoa":"Sender","recipient":[{"msisdn":"12015550123"}]}'
              
#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.labsmobile.com/json/send");
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
        curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");
        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, "Cache-Control: no-cache");
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        const char *data = "{\r\n  \"message\":\"Your verification code is 123\",\r\n  \"tpoa\":\"Sender\",\r\n  \"recipient\":\r\n    [\r\n      {\r\n        \"msisdn\":\"12015550123\"\r\n      }\r\n    ]\r\n}\r\n\r\n";
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                      curl_easy_strerror(res));
        curl_easy_cleanup(curl);
    }
    return 0;
}

            
using System;
using RestSharp;

namespace SendPostUni
{
  class Program
  {
    static void MainSend(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/json/send", Method.Post);
      request.AddHeader("Cache-Control", "no-cache");
      request.AddHeader("Content-Type", "application/json");
      request.AddHeader("Authorization", "Basic " + Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes("myUsername" + ":" + "myToken")));
      request.AddParameter("application/json", "{\r\n  \"message\":\"Your verification code is 123\",\r\n  \"tpoa\":\"Sender\",\r\n  \"recipient\":\r\n    [\r\n      {\r\n        \"msisdn\":\"12015550123\"\r\n      }\r\n    ]\r\n}\r\n\r\n", ParameterType.RequestBody);
      RestResponse response = client.Execute(request);
      if (response.ErrorException != null)
      {
        Console.WriteLine("Error: " + response.ErrorException.Message);
      }
      else
      {
        Console.WriteLine("Response content: " + response.Content);
      }
    }
  }
}

            
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;

public class App {
  public static void main(String[] args) throws UnirestException {
    Unirest.setTimeouts(0, 0);
    HttpResponse<String> response = Unirest.post("https://api.labsmobile.com/json/send")
        .header("Content-Type", "application/json")
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .body(
          "{\"message\":\"Your verification code is 123\", \"tpoa\":\"Sender\",\"recipient\":[{\"msisdn\":\"12015550123\"}]}")
        .asString();
    System.out.println("Status code: " + response.getBody());
  }
}
            
<?php 
$auth_basic = base64_encode("myUsername:myToken");

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.labsmobile.com/json/send",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => '{
    "message":"Your verification code is 123",
    "tpoa":"Sender",
    "recipient":
      [
        {
          "msisdn":"12015550123"
        }
      ]
  }',
  CURLOPT_HTTPHEADER => array(
    "Authorization: Basic ".$auth_basic,
    "Cache-Control: no-cache",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
            
import requests, base64, json


userToken = "myUsername:myToken"
credentials = (base64.b64encode(userToken.encode()).decode())

url = "https://api.labsmobile.com/json/send"

payload = json.dumps({
  "message": "Your verification code is 123",
  "tpoa": "Sender",
  "recipient": [
    {
      "msisdn": "12015550123"
    }
  ]
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic %s' % credentials,
  'Cache-Control': "no-cache"
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

            
const axios = require('axios');

const data = JSON.stringify({
  "message": "Your verification code is 123",
  "tpoa": "Sender",
  "recipient": [
    {
      "msisdn": "12015550123"
    }
  ]
});

let config = {
  method: 'post',
  maxBodyLength: Infinity,
  url: 'https://api.labsmobile.com/json/send',
  headers: { 
    'Content-Type': 'application/json', 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
  data : data
};

axios.request(config)
.then((response) => {
  console.log(JSON.stringify(response.data));
})
.catch((error) => {
  console.log(error);
});



            
require "uri"
require "json"
require 'base64'
require "net/http"

url = URI("https://api.labsmobile.com/json/send")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")
request.body = JSON.dump({
  "message": "Your verification code is 123",
  "tpoa": "Sender",
  "recipient": [
    {
      "msisdn": "12015550123"
    }
  ]
})

response = https.request(request)
puts response.read_body
Envío múltiple 
curl --user myUsername:myToken -X POST \
  https://api.labsmobile.com/json/send \
  -H 'Cache-Control: no-cache' \
  -H 'Content-Type: application/json' \
  -d '{"message":"Do not miss our Sale! Use code XXXX123 for 20% off.", "tpoa":"Sender","recipient":[{"msisdn":"12015550123"},{"msisdn":"12015550124"},{"msisdn":"12015550125"}]}'
              
#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
curl = curl_easy_init();
if(curl) {
  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
  curl_easy_setopt(curl, CURLOPT_URL, "https://api.labsmobile.com/json/send");
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
  curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
  curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
  curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");
  struct curl_slist *headers = NULL;
  headers = curl_slist_append(headers, "Cache-Control: no-cache");
  headers = curl_slist_append(headers, "Content-Type: application/json");
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  const char *data = "{\r\n  \"message\":\"Do not miss our Sale! Use code XXXX123 for 20% off.\",\r\n  \"tpoa\":\"Sender\",\r\n  \"recipient\":\r\n    [\r\n      {\r\n        \"msisdn\":\"12015550123\"\r\n      },\r\n      {\r\n        \"msisdn\":\"12015550124\"\r\n      },\r\n      {\r\n        \"msisdn\":\"12015550125\"\r\n      }\r\n    ]\r\n}\r\n\r\n";
  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
  res = curl_easy_perform(curl);
  if(res != CURLE_OK)
    fprintf(stderr, "curl_easy_perform() failed: %s\n",
       curl_easy_strerror(res));
    curl_easy_cleanup(curl);
   }
  return 0;
}

            
using System;
using RestSharp;

namespace SendPostMul
{
  class Program
  {
    static void MainSend(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/json/send", Method.Post);
      request.AddHeader("Cache-Control", "no-cache");
      request.AddHeader("Content-Type", "application/json");
      request.AddHeader("Authorization", "Basic " + Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes("myUsername" + ":" + "myToken")));
      request.AddParameter("application/json", "{\r\n  \"message\":\"Don't miss our Sale! Use code XXXX123 for 20% off.\",\r\n  \"tpoa\":\"Sender\",\r\n  \"recipient\":\r\n    [\r\n      {\r\n        \"msisdn\":\"12015550123\"\r\n      },\r\n      {\r\n        \"msisdn\":\"12015550124\"\r\n      },\r\n      {\r\n        \"msisdn\":\"12015550125\"\r\n      }\r\n    ]\r\n}\r\n\r\n", ParameterType.RequestBody);
      RestResponse response = client.Execute(request);
      if (response.ErrorException != null)
      {
        Console.WriteLine("Error: " + response.ErrorException.Message);
      }
      else
      {
        Console.WriteLine("Response content: " + response.Content);
      }
    }
  }
}

            
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;

public class App {
  public static void main(String[] args) throws UnirestException {
    Unirest.setTimeouts(0, 0);
    HttpResponse<String> response = Unirest.post("https://api.labsmobile.com/json/send")
        .header("Content-Type", "application/json")
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .body(
          "{\"message\":\"Don't miss our Sale! Use code XXXX123 for 20% off.\", \"tpoa\":\"Sender\",\"recipient\":[{\"msisdn\":\"12015550123\"},{\"msisdn\":\"12015550124\"},{\"msisdn\":\"12015550125\"}]}")
        .asString();
    System.out.println("Status code: " + response.getBody());
  }
}

            
<?php 
$auth_basic = base64_encode("myUsername:myToken");

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.labsmobile.com/json/send",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => '{
    "message":"Do not miss our Sale! Use code XXXX123 for 20% off.",
    "tpoa":"Sender",
    "recipient":
      [
        {
          "msisdn":"12015550123"
        },
        {
          "msisdn":"12015550124"
        },
        {
          "msisdn":"12015550125"
        }
      ]
  }',
  CURLOPT_HTTPHEADER => array(
    "Authorization: Basic ".$auth_basic,
    "Cache-Control: no-cache",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
            
import requests, base64, json


userToken = "myUsername:myToken"
credentials = (base64.b64encode(userToken.encode()).decode())

url = "https://api.labsmobile.com/json/send"

payload = json.dumps({
  "message": "Don't miss our Sale! Use code XXXX123 for 20% off.",
  "tpoa": "Sender",
  "recipient": [
    {
      "msisdn": "12015550123"
    },
    {
      "msisdn": "12015550124"
    },
    {
      "msisdn": "12015550125"
    }
  ]
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic %s' % credentials,
  'Cache-Control': "no-cache"
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
            
const axios = require('axios');

const data = JSON.stringify({
    "message": "Don't miss our Sale! Use code XXXX123 for 20% off.",
    "tpoa": "Sender",
    "recipient": [
      {
        "msisdn": "12015550123"
      },
      {
        "msisdn": "12015550124"
      },
      {
        "msisdn": "12015550125"
      }
    ]
})

let config = {
  method: 'post',
  maxBodyLength: Infinity,
  url: 'https://api.labsmobile.com/json/send',
  headers: { 
    'Content-Type': 'application/json', 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
  data : data
};

axios.request(config)
.then((response) => {
  console.log(JSON.stringify(response.data));
})
.catch((error) => {
  console.log(error);
});

            
require "uri"
require "json"
require 'base64'
require "net/http"

url = URI("https://api.labsmobile.com/json/send")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")
request.body = JSON.dump({
  "message": "Don't miss our Sale! Use code XXXX123 for 20% off.",
  "tpoa": "Sender",
  "recipient": [
    {
      "msisdn": "12015550123"
    },
    {
      "msisdn": "12015550124"
    },
    {
      "msisdn": "12015550125"
    }
  ]
})

response = https.request(request)
puts response.read_body
Resultado positivo 
{
  "subid": "65f33a88ceb3d",
  "code": "0",
  "message": "Message has been successfully sent."
}
Resultado erróneo 
{
  "subid": "65f7f7041385d",
  "code": "35",
  "message": "The account has no enough credit for this sending"
}

Consulta de saldo

Consulta sobre el número de créditos disponibles de una cuenta.

ENDPOINT

GET https://api.labsmobile.com/json/balance

Esta funcionalidad no tiene parámetros, basta con enviar unas credenciales correctas para identificar la cuenta al endpoint de consulta de saldo.

  • RESULTADO

    El resultado de cualquier petición API SMS http/POST se obtiene en formato JSON con los siguientes elementos:

Consulta de saldo 
curl --user myUsername:myToken -X GET \
  https://api.labsmobile.com/json/balance \
  -H 'Cache-Control: no-cache' \              
#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.labsmobile.com/json/balance");
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
        curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");
        struct curl_slist *headers = NULL;
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        const char *data = "";
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                      curl_easy_strerror(res));
        curl_easy_cleanup(curl);
    }
    return 0;
}
            
using System;
using RestSharp;

namespace BalancePost
{
  class Program
  {
    static void MainBalance(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/json/balance", Method.Get);
      request.AddHeader("Cache-Control", "no-cache");
      request.AddHeader("Content-Type", "application/json");
      request.AddHeader("Authorization", "Basic " + Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes("myUsername" + ":" + "myToken")));
      RestResponse response = client.Execute(request);
      if (response.ErrorException != null)
      {
        Console.WriteLine("Error: " + response.ErrorException.Message);
      }
      else
      {
        Console.WriteLine("Response content: " + response.Content);
      }
    }
  }
}
            
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;

public class App {
  public static void main(String[] args) throws UnirestException {
    Unirest.setTimeouts(0, 0);
    HttpResponse<String> response = Unirest.get("https://api.labsmobile.com/json/balance")
        .header("Content-Type", "application/json")
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .body("")
        .asString();
    System.out.println("Status code: " + response.getBody());
  }
}

            
<?php 
$auth_basic = base64_encode("myUsername:myToken");

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.labsmobile.com/json/balance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => array(
    "Authorization: Basic ".$auth_basic,
    "Cache-Control: no-cache",
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

            
import requests, base64, json

userToken = "myUsername:myToken"
credentials = (base64.b64encode(userToken.encode()).decode())

url = "https://api.labsmobile.com/json/balance"

payload = ""
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic %s' % credentials,
  'Cache-Control': "no-cache"
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)

            
const axios = require('axios');
let data = '';

let config = {
  method: 'get',
  maxBodyLength: Infinity,
  url: 'https://api.labsmobile.com/json/balance',
  headers: { 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
  data : data
};

axios.request(config)
.then((response) => {
  console.log(JSON.stringify(response.data));
})
.catch((error) => {
  console.log(error);
});

            
require "uri"
require "json"
require 'base64'
require "net/http"

url = URI("https://api.labsmobile.com/json/balance")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")
request.body = ""

response = https.request(request)
puts response.read_body
Resultado positivo 
{
  "code":0,
  "credits":"10"
}
Resultado erróneo 
{
  "code":"403",
  "message":"Forbidden"
}

Consulta de precios

Consulta sobre la tarifa (en créditos) de uno o varios países de destino.

ENDPOINT

GET https://api.labsmobile.com/json/prices

  • PARÁMETROS

    Los parámetros o datos se envían en el cuerpo de una llamada http/POST en formato JSON. A continuación se describen los valores y funcionalidad de todos los parámetros.

  • Ampliar todo

    RESULTADO

    El resultado se obtiene en formato JSON, XML o CSV con los siguientes elementos:

Consulta de precios 
curl --user myusername:mypassword -X POST \
  https://api.labsmobile.com/json/prices \
  -H 'Cache-Control: no-cache' \
  -H 'Content-Type: application/json' \
  -d '{"format":"JSON","countries":["ES","FR","US","MX"]}'          
#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.labsmobile.com/json/prices");
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
        curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");
        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, "Cache-Control: no-cache");
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        const char *data = "{\"format\":\"JSON\",\"countries\":[\"ES\",\"FR\",\"US\",\"MX\"]}";
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                      curl_easy_strerror(res));
        curl_easy_cleanup(curl);
    }
    return 0;
}

            
using System;
using RestSharp;

namespace Prices
{
  class Program
  {
    static void MainPrices(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/json/prices", Method.Post);
      request.AddHeader("Cache-Control", "no-cache");
      request.AddHeader("Content-Type", "application/json");
      request.AddHeader("Authorization", "Basic " + Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes("myUsername" + ":" + "myToken")));
      request.AddParameter("application/json", "{\"format\":\"JSON\",\"countries\":[\"ES\",\"FR\",\"US\",\"MX\"]}", ParameterType.RequestBody);
      RestResponse response = client.Execute(request);
      if (response.ErrorException != null)
      {
        Console.WriteLine("Error: " + response.ErrorException.Message);
      }
      else
      {
        Console.WriteLine("Response content: " + response.Content);
      }
    }
  }
}
            
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;

public class App {
  public static void main(String[] args) throws UnirestException {
    Unirest.setTimeouts(0, 0);
    HttpResponse<String> response = Unirest.post("https://api.labsmobile.com/json/prices")
        .header("Content-Type", "application/json")
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .body(
          "{\"format\":\"JSON\",\"countries\":[\"ES\",\"FR\",\"US\",\"MX\"]}")
        .asString();
    System.out.println("Status code: " + response.getBody());
  }
}
            
<?php 
$auth_basic = base64_encode("myUsername:myToken");

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.labsmobile.com/json/prices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => '{
    "format":"JSON",
    "countries":["ES","FR","US","MX"]
  }',
  CURLOPT_HTTPHEADER => array(
    "Authorization: Basic ".$auth_basic,
    "Cache-Control: no-cache",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
            
import requests, base64, json

userToken = "myUsername:myToken"
credentials = (base64.b64encode(userToken.encode()).decode())

url = "https://api.labsmobile.com/json/prices"

payload = json.dumps({
    "format":"JSON",
    "countries":["ES","FR","US","MX"]
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic %s' % credentials,
  'Cache-Control': "no-cache"
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
            
const axios = require('axios');

const data = JSON.stringify({
  "format":"JSON",
  "countries":["ES","FR","US","MX"]
});

let config = {
  method: 'post',
  maxBodyLength: Infinity,
  url: 'https://api.labsmobile.com/json/prices',
  headers: { 
    'Content-Type': 'application/json', 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
  data : data
};

axios.request(config)
.then((response) => {
  console.log(JSON.stringify(response.data));
})
.catch((error) => {
  console.log(error);
});

            
require "uri"
require "json"
require 'base64'
require "net/http"

url = URI("https://api.labsmobile.com/json/prices")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")
request.body = JSON.dump({
  "format":"JSON",
  "countries":["ES","FR","US","MX"]
})

response = https.request(request)
puts response.read_body
Resultado positivo 
{
  "FR":
    {
      "isocode":"FR",
      "prefix":"33",
      "name":"France",
      "credits":1.114
    },
  "DE":
    {
      "isocode":"DE",
      "prefix":"49",
      "name":"Germany",
      "credits":1.8
    }
}
Resultado erróneo 
{
    "code": "401",
    "message": "Unauthorized"
}

Gestión de envíos programados

Cancelación o ejecución de envíos programados pendientes.

ENDPOINT

POST https://api.labsmobile.com/json/scheduled

  • PARÁMETROS

    Los parámetros o datos se envían en el cuerpo de una llamada http/POST en formato JSON. A continuación se describen los valores y funcionalidad de todos los parámetros.

  • RESULTADO

    El resultado se obtiene en formato JSON con los siguientes elementos:

Cancelar programado 
curl --user myusername:mypassword -X POST \
  https://api.labsmobile.com/json/scheduled \
  -H 'Cache-Control: no-cache' \
  -H 'Content-Type: application/json' \
  -d '{"cmd":"cancel","subid":"5a9fe45c7adc3"}'         
#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.labsmobile.com/json/scheduled");
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
        curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");
        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, "Cache-Control: no-cache");
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        const char *data = "{\"cmd\":\"cancel\",\"subid\":\"5a9fe45c7adc3\"}";
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                      curl_easy_strerror(res));
        curl_easy_cleanup(curl);
    }
    return 0;
}

            
using System;
using RestSharp;

namespace Prices
{
  class Program
  {
    static void MainPrices(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/json/scheduled", Method.Post);
      request.AddHeader("Cache-Control", "no-cache");
      request.AddHeader("Content-Type", "application/json");
      request.AddHeader("Authorization", "Basic " + Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes("myUsername" + ":" + "myToken")));
      request.AddParameter("application/json", "{\"cmd\":\"cancel\",\"subid\":\"5a9fe45c7adc3\"}", ParameterType.RequestBody);
      RestResponse response = client.Execute(request);
      if (response.ErrorException != null)
      {
        Console.WriteLine("Error: " + response.ErrorException.Message);
      }
      else
      {
        Console.WriteLine("Response content: " + response.Content);
      }
    }
  }
}
            
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;

public class App {
  public static void main(String[] args) throws UnirestException {
    Unirest.setTimeouts(0, 0);
    HttpResponse<String> response = Unirest.post("https://api.labsmobile.com/json/scheduled")
        .header("Content-Type", "application/json")
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .body(
          "{\"cmd\":\"cancel\",\"subid\":\"5a9fe45c7adc3\"}")
        .asString();
    System.out.println("Status code: " + response.getBody());
  }
}
            
<?php 
$auth_basic = base64_encode("myUsername:myToken");

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.labsmobile.com/json/scheduled",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => '{
    "cmd":"cancel",
    "subid":"5a9fe45c7adc3"
  }',
  CURLOPT_HTTPHEADER => array(
    "Authorization: Basic ".$auth_basic,
    "Cache-Control: no-cache",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
            
import requests, base64, json

userToken = "myUsername:myToken"
credentials = (base64.b64encode(userToken.encode()).decode())

url = "https://api.labsmobile.com/json/scheduled"

payload = json.dumps({
  "cmd":"cancel",
  "subid":"5a9fe45c7adc3"
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Basic %s' % credentials,
  'Cache-Control': "no-cache"
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
            
const axios = require('axios');

const data = JSON.stringify({
  "cmd":"cancel",
  "subid":"5a9fe45c7adc3"
});

let config = {
  method: 'post',
  maxBodyLength: Infinity,
  url: 'https://api.labsmobile.com/json/scheduled',
  headers: { 
    'Content-Type': 'application/json', 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
  data : data
};

axios.request(config)
.then((response) => {
  console.log(JSON.stringify(response.data));
})
.catch((error) => {
  console.log(error);
});

            
require "uri"
require "json"
require 'base64'
require "net/http"

url = URI("https://api.labsmobile.com/json/scheduled")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")
request.body = JSON.dump({
  "cmd":"cancel",
  "subid":"5a9fe45c7adc3"
})

response = https.request(request)
puts response.read_body
Resultado positivo 
{
  "code":"0",
  "message":"Scheduled messages successfully cancelled."
}
Resultado erróneo 
{
  "code":"52",
  "message":"Scheduled messages not found."
}

Recepción de estados

Obtención de los estados (entregado o error) de los mensajes enviados.

Con esta funcionalidad se recibe en una URL del cliente los eventos de confirmación de entrega o error de cada mensaje enviado.

Existen dos métodos para activar la recepción de estados en una URL:

  • Añadiendo una URL en el parámetro ackurl de la petición API de envío.
  • Introduciendo una URL en la Configuración API de la cuenta, en el campo URL de recepción de confirmaciones o errores de entrega.

En ambos casos cuando se produzca un estado de mensaje entregado o error se realizará una llamada http/GET a la URL proporcionada con los parámetros que se detallan a continuación.

  • Ampliar todo

    PARÁMETROS

Formato de la URL: ?acklevel=[gateway|operator|handset|error]&msisdn=[phone]&status=[ok|ko&desc=[REJECTD|EXPIRED|BLOCKED|UNDELIV|UNKNOWN]&subid=[identifier]&timestamp=YYYY-MM-DD%20HH:MM:SS

ReintentosSi la llamada http/GET genera un error al llamar a la URL (estados HTTP 4xx o 5xx) se reintentará la entrega hasta 5 veces en los siguientes intervalos: 30s, 5m, 30m, 6h, 1d.

Recepción de clics

Obtención de los clics en las URLs de los mensajes enviados.

Con esta funcionalidad se recibe en una URL del cliente los eventos de clic que se producen en los mensajes enviados.

Existen dos métodos para activar la recepción de clics en una URL:

  • Añadiendo una URL en el parámetro clickurl de la petición API de envío.
  • Introduciendo una URL en la Configuración API de la cuenta, en el campo URL de recepción de visitas o clics.

En ambos casos cuando se produzca un clic en una URL se realizará una llamada http/POST JSON a la URL proporcionada con los parámetros que se detallan a continuación.

  • Ampliar todo

    PARÁMETROS

Ejemplo JSON 
{
  ip : "98.139.180.149",
  useragent : "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0",
  subid : "5aa3ea8e5cdb6",
  msisdn : "5212221234567",
  timestamp : "2018-03-18 15:23:10"
}

ReintentosSi la llamada http/GET genera un error al llamar a la URL (estados HTTP 4xx o 5xx) se reintentará la entrega hasta 5 veces en los siguientes intervalos: 30s, 5m, 30m, 6h, 1d.

Importante Para poder recibir los clics es necesario que los mensajes SMS se entreguen con un dominio asociado a la plataforma LabsMobile (labsmo.bi o dominio personalizado configurado).

Recepción de mensajes

Recepción de mensajes SMS en los números virtuales contratados.

Con esta funcionalidad se reciben en una URL del cliente los mensajes SMS recibidos.

Para activar la recepción de mensajes SMS en una URL es necesario introducir una URL en la Configuración API de la cuenta, en el campo URL de recepción de mensajes.

Cuando se reciba un SMS realizará una llamada http/POST JSON a la URL proporcionada con los parámetros que se detallan a continuación.

  • Ampliar todo

    PARÁMETROS

Ejemplo JSON 
{
  "inbound_number":"12015576234",
  "service_number":"12015576234",
  "msisdn":"12015550123",
  "message":"Test message",
  "timestamp":"2014-06-07 19:21:43"
}

ReintentosSi la llamada http/GET genera un error al llamar a la URL (estados HTTP 4xx o 5xx) se reintentará la entrega hasta 5 veces en los siguientes intervalos: 30s, 5m, 30m, 6h, 1d.

Importante Para recibir mensajes SMS es necesario contratar números virtuales de envío y recepción SMS.

Errores

A continuación se describen los códigos de error HTTP que puede devolver una petición a la API SMS http/POST.

Códigos HTTP
Código HTTPDescripción
200 OKPetición procesada correctamente.
400 Bad RequestError en los parámetros de la petición. Se detalla y especifica el error en el código devuelto en el formato JSON.
401 UnauthorizedError en las credenciales o método de autenticación.
402 Payment RequiredError por falta de créditos en la cuenta.
403 ForbiddenPetición bloqueada por el filtro IP o por infringir alguna política de uso de la plataforma.
500 Internal Server ErrorError temporal o incidencia en el servicio

Esta es la lista completa de códigos de respuesta en el formato JSON:

Códigos de resultado en el JSON de respuesta
Código JSONDescripción
0Message has been successfully sent
10Missing XML data in request
11Badly formed XML in request
20The message element must be present in the request
21The message element cannot be empty
23There are no recipients
24Too many recipients
27This message contained one or more invalid character(s)
28Subid is exceeding maximum length
30There was an error while sending the message
35The account has no enough credit for this sending
39The value of the scheduled field is not a valid datetime format
41Scheduled messages cannot be send in test mode
51Compulsary fields not defined.
52Scheduled messages not found.

Recursos de soporte

Recomendamos consultes y tengas en cuenta los siguientes recursos de soporte en tu integración: