API OTP

La API OTP está diseñada para técnicos y clientes que quieran envíar códigos OTP a través del canal SMS.

Los códigos OTP (One Time Password) son códigos de un sólo uso utilizados en procesos de verificación o autenticación 2fa (Two Factor Authentication).

Para iniciar una integración con la API OTP 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 OTP y los valores de los parámetros para realizar las peticiones.

Colección Postman API OTP
Descargar

A tener en cuenta

La API OTP de LabsMobile utiliza parámetros HTTP GET y una URL base común para todas las peticiones: https://api.labsmobile.com/otp/

También es posible realizar envíos de código OTP por SMS con nuestra API http/POST eligiendo todos los aspectos como reintentos, validaciones, formato del OTP, etc.

Autenticación

El método de autenticación utilizado en cualquier petición de la API OTP es Basic Auth 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.

Enviar código OTP

Creación de un código OTP para un número y entorno determinados.

Esta petición genera un código OTP nuevo para un número móvil y un entorno indicados. Se enviará un SMS al número con el texto donde aparece el código OTP.

Los códigos OTP y procesos de validación se enmarcan en un entorno para identificar el proyecto, aplicación o versión a la que pertenece.

Importante Al enviar un código OTP se anularán todos los códigos anteriores pendientes de validar para este número y entorno y se generará un nuevo código. En el caso de que se quiera reenviar un código OTP para el mismo proceso de validación se debe utilizar la función Reenviar código OTP.

ENDPOINT

GET https://api.labsmobile.com/otp/sendCode

Ampliar todo
PARÁMETROS
Los parámetros o datos se envían en variables http/GET en la propia URL de la petición. A continuación se describen los valores y funcionalidad de todos los parámetros:
phone_number string obligatorio
Número de teléfono móvil al que se quiere enviar el código OTP. Los números deben cumplir el formato internacional E.164, incluyendo el código de país sin "00" ni "+".
Ejemplo: &phone_number=167923402323
env string
Entorno donde se enmarca esta petición. Es posible establecer un entorno vacío o nulo. Un mismo número puede validarse en varios entornos..
Ejemplo: &env=VerifApp
message string
Texto del mensaje SMS que recibirá el destinatario del código OTP. El texto debe contener la variable %CODE% que será reemplazada por el código OTP. Por defecto, el valor del texto del mensaje es: The code to verify your phone number is %CODE%
Ejemplo: &message=Tu%20codigo%3A%20%25CODE%25
sender string
Campo remitente del mensaje SMS. Puede tener un valor numérico (longitud máxima 16 dígitos) o alfanumérico (capacidad máxima 11 caracteres).
La asignación y personalización del remitente sólo está disponible en algunos países y operadores. En caso contrario, el remitente será un valor numérico (shortcode o longcode) estático. Valor por defecto: NumCheck.
Ejemplo: &sender=MyBRAND
digits integer
Número de dígitos del código OTP a generar. Valor por defecto 6, mínimo de 4 y máximo de 9.
Ejemplo: &digits=4
test 0 | 1
Activación del modo simulado de envío para pruebas y monitorización.
Si se asigna un valor 1 a este parámetro, los mensajes no se enviarán a los destinatarios y no se descontará ningún crédito. Los mensajes enviados en modo simulado se podrán consultar en el Histórico y otras herramientas.
Ejemplo: &test=1
RESULTADO
El resultado se obtiene en el cuerpo (body) de la respuesta HTTP y puede contener los siguientes valores:
Valores de estado
0 Petición incorrecta o con error en el envío o procesado del código OTP.
1 Petición de creación y envío de código OTP exitosa.

curl --user myUsername:myToken -X GET  \
https://api.labsmobile.com/otp/sendCode?env=verifApp&sender=MyBRAND&phone_number=12015550123&message=The+code+to+verify+your+username+is%25CODE%25

#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    
    char *env = "verifApp";
    char *sender = "MyBRAND";
    char *phone_number = "12015550123";
    char *message = "The code to verify your username is %CODE%";

    curl = curl_easy_init();
    if(curl) {
        char *encoded_env = curl_easy_escape(curl, env, 0);
        char *encoded_sender = curl_easy_escape(curl, sender, 0);
        char *encoded_phone_number = curl_easy_escape(curl, phone_number, 0);
        char *encoded_message = curl_easy_escape(curl, message, 0);

        char url[1024];
        snprintf(url, sizeof(url),
                 "https://api.labsmobile.com/otp/sendCode?env=%s&sender=%s&phone_number=%s&message=%s",
                 encoded_env, encoded_sender, encoded_phone_number, encoded_message);

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }
        curl_free(encoded_env);
        curl_free(encoded_sender);
        curl_free(encoded_phone_number);
        curl_free(encoded_message);
        curl_easy_cleanup(curl);
    }

    return 0;
}

using System;
using RestSharp;

namespace SendOtp
{
  class Program
  {
    static void MainSend(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/otp/sendCode", Method.Get);

      request.AddQueryParameter("env", "verifApp");
      request.AddQueryParameter("sender", "MyBRAND");
      request.AddQueryParameter("phone_number", "12015550123");
      request.AddQueryParameter("message", "The code to verify your username is %CODE%");

      request.AddHeader("Cache-Control", "no-cache");
      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;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class App {
  public static void main(String[] args) throws UnirestException, UnsupportedEncodingException {

    String env = URLEncoder.encode("verifApp", "UTF-8");
    String sender = URLEncoder.encode("MyBRAND", "UTF-8");
    String phoneNumber = URLEncoder.encode("12015550123", "UTF-8");
    String message = URLEncoder.encode("The code to verify your username is %CODE%", "UTF-8");

    String url = String.format("https://api.labsmobile.com/otp/sendCode?env=%s&sender=%s&phone_number=%s&message=%s",
                                env, sender, phoneNumber, message);

    Unirest.setTimeouts(0, 0);

    HttpResponse<String> response = Unirest.get(url)
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .asString();

    System.out.println("Response content: " + response.getBody());
  }
}

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

$curl = curl_init();

$env = "verifApp";
$sender = "MyBRAND";
$phone_number = "12015550123";
$message = "The code to verify your username is %CODE%";

$url = 'https://api.labsmobile.com/otp/sendCode?';
            $url .= 'env='.  urlencode($env) .'&';
            $url .= 'sender='.  urlencode($sender) .'&';
            $url .= 'phone_number=' .  urlencode($phone_number) .'&';
            $url .= 'message=' .  urlencode($message);

curl_setopt_array($curl, array(
  CURLOPT_URL => $url,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic '.$auth_basic
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

import requests, base64, urllib.parse

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

data = {
    'env':'verifApp',
    'sender': 'MyBRAND',
    'phone_number': '12015550123',
    'message':'The code to verify your username is %CODE%'
}

url = "https://api.labsmobile.com/otp/sendCode?"+urllib.parse.urlencode(data, doseq=True)
payload = {}
headers = {
  'Authorization': 'Basic %s' % credentials,
}

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

print(response.text)

const axios = require('axios');

const env = "verifApp";
const sender = "MyBRAND";
const phone_number = "12015550123";
const message = "The code to verify your username is %CODE%";

let config = {
  method: 'get',
  maxBodyLength: Infinity,
  url: `https://api.labsmobile.com/otp/sendCode?env=${encodeURIComponent(env)}&sender=${encodeURIComponent(sender)}&phone_number=${encodeURIComponent(phone_number)}&message=${encodeURIComponent(message)}`,
  headers: { 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
};

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

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

url = URI("https://api.labsmobile.com/otp/sendCode")

data = {
  'env' => 'verifApp',
  'sender' => 'MyBRAND',
  'phone_number' => '12015550123',
  'message' => 'The code to verify your username is %CODE%'
}

url.query = URI.encode_www_form(data)
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")

response = https.request(request)
puts response.read_body

Reenviar código OTP

Reenvío de un código OTP para un número y entorno determinados.

Es importante realizar la llamada a esta función para enviar siempre el mismo código OTP para un mismo proceso de validación.

Importante Si no existe un código generado para el número y entorno enviados se creará un nuevo código OTP de igual forma que hace lo hace la función Enviar código OTP.

ENDPOINT

GET https://api.labsmobile.com/otp/resendCode

Ampliar todo
PARÁMETROS
Los parámetros o datos se envían en variables http/GET en la propia URL de la petición. A continuación se describen los valores y funcionalidad de todos los parámetros:
phone_number string obligatorio
Número de teléfono móvil al que se quiere enviar el código OTP. Los números deben cumplir el formato internacional E.164, incluyendo el código de país sin "00" ni "+".
Ejemplo: &phone_number=167923402323
env string
Entorno donde se enmarca esta petición. Es posible establecer un entorno vacío o nulo. Un mismo número puede validarse en varios entornos..
Ejemplo: &env=VerifApp
message string
Texto del mensaje SMS que recibirá el destinatario del código OTP. El texto debe contener la variable %CODE% que será reemplazada por el código OTP. Por defecto, el valor del texto del mensaje es: The code to verify your phone number is %CODE%
Ejemplo: &message=Tu%20codigo%3A%20%25CODE%25
sender string
Campo remitente del mensaje SMS. Puede tener un valor numérico (longitud máxima 16 dígitos) o alfanumérico (capacidad máxima 11 caracteres).
La asignación y personalización del remitente sólo está disponible en algunos países y operadores. En caso contrario, el remitente será un valor numérico (shortcode o longcode) estático. Valor por defecto: NumCheck.
Ejemplo: &sender=MyBRAND
digits integer
Número de dígitos del código OTP a generar. Valor por defecto 6, mínimo de 4 y máximo de 9.
Ejemplo: &digits=4
test 0 | 1
Activación del modo simulado de envío para pruebas y monitorización.
Si se asigna un valor 1 a este parámetro, los mensajes no se enviarán a los destinatarios y no se descontará ningún crédito. Los mensajes enviados en modo simulado se podrán consultar en el Histórico y otras herramientas.
Ejemplo: &test=1
RESULTADO
El resultado se obtiene en el cuerpo (body) de la respuesta HTTP y puede contener los siguientes valores:
Valores de estado
0 Petición incorrecta o con error en el envío o procesado del código OTP.
1 Petición de creación y envío de código OTP exitosa.

curl --user myUsername:myToken -X GET  \
https://api.labsmobile.com/otp/resendCode?env=verifApp&sender=MyBRAND&phone_number=12015550123&message=The+code+to+verify+your+username+is%25CODE%25

#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    
    char *env = "verifApp";
    char *sender = "MyBRAND";
    char *phone_number = "12015550123";
    char *message = "The code to verify your username is %CODE%";

    curl = curl_easy_init();
    if(curl) {
        char *encoded_env = curl_easy_escape(curl, env, 0);
        char *encoded_sender = curl_easy_escape(curl, sender, 0);
        char *encoded_phone_number = curl_easy_escape(curl, phone_number, 0);
        char *encoded_message = curl_easy_escape(curl, message, 0);

        char url[1024];
        snprintf(url, sizeof(url),
                 "https://api.labsmobile.com/otp/resendCode?env=%s&sender=%s&phone_number=%s&message=%s",
                 encoded_env, encoded_sender, encoded_phone_number, encoded_message);

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }
        curl_free(encoded_env);
        curl_free(encoded_sender);
        curl_free(encoded_phone_number);
        curl_free(encoded_message);
        curl_easy_cleanup(curl);
    }

    return 0;
}

using System;
using RestSharp;

namespace SendOtp
{
  class Program
  {
    static void MainSend(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/otp/resendCode", Method.Get);

      request.AddQueryParameter("env", "verifApp");
      request.AddQueryParameter("sender", "MyBRAND");
      request.AddQueryParameter("phone_number", "12015550123");
      request.AddQueryParameter("message", "The code to verify your username is %CODE%");

      request.AddHeader("Cache-Control", "no-cache");
      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;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class App {
  public static void main(String[] args) throws UnirestException, UnsupportedEncodingException {

    String env = URLEncoder.encode("verifApp", "UTF-8");
    String sender = URLEncoder.encode("MyBRAND", "UTF-8");
    String phoneNumber = URLEncoder.encode("12015550123", "UTF-8");
    String message = URLEncoder.encode("The code to verify your username is %CODE%", "UTF-8");

    String url = String.format("https://api.labsmobile.com/otp/resendCode?env=%s&sender=%s&phone_number=%s&message=%s",
                                env, sender, phoneNumber, message);

    Unirest.setTimeouts(0, 0);

    HttpResponse<String> response = Unirest.get(url)
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .asString();

    System.out.println("Response content: " + response.getBody());
  }
}

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

$curl = curl_init();

$env = "verifApp";
$sender = "MyBRAND";
$phone_number = "12015550123";
$message = "The code to verify your username is %CODE%";

$url = 'https://api.labsmobile.com/otp/resendCode?';
            $url .= 'env='.  urlencode($env) .'&';
            $url .= 'sender='.  urlencode($sender) .'&';
            $url .= 'phone_number=' .  urlencode($phone_number) .'&';
            $url .= 'message=' .  urlencode($message);

curl_setopt_array($curl, array(
  CURLOPT_URL => $url,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic '.$auth_basic
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

import requests, base64, urllib.parse

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

data = {
    'env':'verifApp',
    'sender': 'MyBRAND',
    'phone_number': '12015550123',
    'message':'The code to verify your username is %CODE%'
}

url = "https://api.labsmobile.com/otp/resendCode?"+urllib.parse.urlencode(data, doseq=True)
payload = {}
headers = {
  'Authorization': 'Basic %s' % credentials,
}

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

print(response.text)

const axios = require('axios');

const env = "verifApp";
const sender = "MyBRAND";
const phone_number = "12015550123";
const message = "The code to verify your username is %CODE%";

let config = {
  method: 'get',
  maxBodyLength: Infinity,
  url: `https://api.labsmobile.com/otp/resendCode?env=${encodeURIComponent(env)}&sender=${encodeURIComponent(sender)}&phone_number=${encodeURIComponent(phone_number)}&message=${encodeURIComponent(message)}`,
  headers: { 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
};

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

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

url = URI("https://api.labsmobile.com/otp/resendCode")

data = {
  'env' => 'verifApp',
  'sender' => 'MyBRAND',
  'phone_number' => '12015550123',
  'message' => 'The code to verify your username is %CODE%'
}

url.query = URI.encode_www_form(data)
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")

response = https.request(request)
puts response.read_body

Validar código OTP

Validar el código OTP correspondiente a un número y entorno concreto.

ENDPOINT

GET https://api.labsmobile.com/otp/validateCode

PARÁMETROS
phone_number string obligatorio
Número de teléfono que se quiere validar.
Ejemplo: &phone_number=167923402323
env string
Entorno donde se enmarca esta petición.
Ejemplo: &env=VerifApp
code string
El código que ha introducido el usuario y que se desea validar.
Ejemplo: &code=652871
timeframe int
Número de minutos durante los que el código OTP será válido desde su creación, es decir, la caducidad del código en minutos. Si no se informa este parámetro no existirá una limitación temporal. Este parámetro puede tener un valor entre 0 y 120.
Ejemplo: &timeframe=30
RESULTADO
El resultado se obtiene en el cuerpo (body) de la respuesta HTTP y puede contener los siguientes valores:
Valores de estado
0 Código OTP inexistente, caducado o incorrecto para este número.
1 Código OTP correcto y validado.

curl --user myUsername:myToken -X GET  \
https://api.labsmobile.com/otp/validateCode?env=verifApp&phone_number=12015550123&code=381102

#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    
    char *env = "verifApp";
    char *phone_number = "12015550123";
    char *code = "652871";

    curl = curl_easy_init();
    if(curl) {
        char *encoded_env = curl_easy_escape(curl, env, 0);
        char *encoded_phone_number = curl_easy_escape(curl, phone_number, 0);
        char *encoded_code = curl_easy_escape(curl, code, 0);

        char url[1024];
        snprintf(url, sizeof(url),
                 "https://api.labsmobile.com/otp/validateCode?env=%s&phone_number=%s&code=%s",
                 encoded_env, encoded_phone_number, encoded_code);

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }
        curl_free(encoded_env);
        curl_free(encoded_phone_number);
        curl_easy_cleanup(curl);
    }

    return 0;
}

using System;
using RestSharp;

namespace SendOtp
{
  class Program
  {
    static void MainSend(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/otp/validateCode", Method.Get);

      request.AddQueryParameter("env", "verifApp");
      request.AddQueryParameter("phone_number", "12015550123");
      request.AddQueryParameter("code", "652871");

      request.AddHeader("Cache-Control", "no-cache");
      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;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class App {
  public static void main(String[] args) throws UnirestException, UnsupportedEncodingException {

    String env = URLEncoder.encode("verifApp", "UTF-8");
    String phoneNumber = URLEncoder.encode("12015550123", "UTF-8");
    String code = URLEncoder.encode("652871", "UTF-8");


    String url = String.format("https://api.labsmobile.com/otp/validateCode?env=%s&phone_number=%s&code=%s",
                                env, phoneNumber, code);

    Unirest.setTimeouts(0, 0);

    HttpResponse<String> response = Unirest.get(url)
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .asString();

    System.out.println("Response content: " + response.getBody());
  }
}

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

$curl = curl_init();

$env = "verifApp";
$phone_number = "12015550123";
$code = "652871";

$url = 'https://api.labsmobile.com/otp/validateCode?';
            $url .= 'env='.  urlencode($env) .'&';
            $url .= 'phone_number=' .  urlencode($phone_number) .'&';
            $url .= 'code=' .  urlencode($code) .'&';

curl_setopt_array($curl, array(
  CURLOPT_URL => $url,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic '.$auth_basic
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

import requests, base64, urllib.parse

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

data = {
    'env':'verifApp',
    'phone_number': '12015550123',
    'code': '652871',

}

url = "https://api.labsmobile.com/otp/validateCode?"+urllib.parse.urlencode(data, doseq=True)
payload = {}
headers = {
  'Authorization': 'Basic %s' % credentials,
}

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

print(response.text)

const axios = require('axios');

const env = "verifApp";
const phone_number = "12015550123";
const code = "652871";

let config = {
  method: 'get',
  maxBodyLength: Infinity,
  url: `https://api.labsmobile.com/otp/validateCode?env=${encodeURIComponent(env)}&phone_number=${encodeURIComponent(phone_number)}&code=${encodeURIComponent(code)}`,
  headers: { 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
};

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

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

url = URI("https://api.labsmobile.com/otp/validateCode")

data = {
  'env' => 'verifApp',
  'phone_number' => '12015550123',
  'code' => '652871',
}

url.query = URI.encode_www_form(data)
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")

response = https.request(request)
puts response.read_body

Comprobar código OTP

Comprobación del estado del código OTP correspondiente a un número y entorno concreto.

ENDPOINT

GET https://api.labsmobile.com/otp/checkCode

PARÁMETROS
phone_number string obligatorio
Número de teléfono que se quiere comprobar y obtener el estado de su código OTP.
Ejemplo: &phone_number=167923402323
env string
Entorno donde se enmarca esta petición.
Ejemplo: &env=VerifApp
RESULTADO
El resultado se obtiene en el cuerpo (body) de la respuesta HTTP y puede contener los siguientes valores:
Valores de estado
0 Código OTP inexistente para este número y entorno o pendiente de validación.
1 Código OTP validado correctamente.

curl --user myUsername:myToken -X GET  \
https://api.labsmobile.com/otp/checkCode?env=verifApp&phone_number=12015550123

#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    
    char *env = "verifApp";
    char *phone_number = "12015550123";

    curl = curl_easy_init();
    if(curl) {
        char *encoded_env = curl_easy_escape(curl, env, 0);
        char *encoded_phone_number = curl_easy_escape(curl, phone_number, 0);

        char url[1024];
        snprintf(url, sizeof(url),
                 "https://api.labsmobile.com/otp/checkCode?env=%s&phone_number=%s",
                 encoded_env, encoded_phone_number);

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }
        curl_free(encoded_env);
        curl_free(encoded_phone_number);
        curl_easy_cleanup(curl);
    }

    return 0;
}

using System;
using RestSharp;

namespace SendOtp
{
  class Program
  {
    static void MainSend(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/otp/checkCode", Method.Get);

      request.AddQueryParameter("env", "verifApp");
      request.AddQueryParameter("phone_number", "12015550123");

      request.AddHeader("Cache-Control", "no-cache");
      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;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class App {
  public static void main(String[] args) throws UnirestException, UnsupportedEncodingException {

    String env = URLEncoder.encode("verifApp", "UTF-8");
    String phoneNumber = URLEncoder.encode("12015550123", "UTF-8");

    String url = String.format("https://api.labsmobile.com/otp/checkCode?env=%s&phone_number=%s",
                                env, phoneNumber);

    Unirest.setTimeouts(0, 0);

    HttpResponse<String> response = Unirest.get(url)
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .asString();

    System.out.println("Response content: " + response.getBody());
  }
}

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

$curl = curl_init();

$env = "verifApp";
$phone_number = "12015550123";

$url = 'https://api.labsmobile.com/otp/checkCode?';
            $url .= 'env='.  urlencode($env) .'&';
            $url .= 'phone_number=' .  urlencode($phone_number) .'&';

curl_setopt_array($curl, array(
  CURLOPT_URL => $url,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic '.$auth_basic
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

import requests, base64, urllib.parse

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

data = {
    'env':'verifApp',
    'phone_number': '12015550123',
}

url = "https://api.labsmobile.com/otp/checkCode?"+urllib.parse.urlencode(data, doseq=True)
payload = {}
headers = {
  'Authorization': 'Basic %s' % credentials,
}

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

print(response.text)

const axios = require('axios');

const env = "verifApp";
const phone_number = "12015550123";

let config = {
  method: 'get',
  maxBodyLength: Infinity,
  url: `https://api.labsmobile.com/otp/checkCode?env=${encodeURIComponent(env)}&phone_number=${encodeURIComponent(phone_number)}`,
  headers: { 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
};

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

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

url = URI("https://api.labsmobile.com/otp/checkCode")

data = {
  'env' => 'verifApp',
  'phone_number' => '12015550123',
}

url.query = URI.encode_www_form(data)
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")

response = https.request(request)
puts response.read_body

Listar entornos

Consulta de todos los entornos creados por una cuenta.

ENDPOINT

GET https://api.labsmobile.com/otp/getEnvList

Esta función no tiene parámetros y genera un resultado en formato JSON con la lista de entornos.

curl --user myUsername:myToken -X GET  \
https://api.labsmobile.com/otp/getEnvList

#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
  
    curl = curl_easy_init();
    if(curl) {

        char url[1024];
        snprintf(url, sizeof(url),"https://api.labsmobile.com/otp/getEnvList");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");

        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 SendOtp
{
  class Program
  {
    static void MainSend(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/otp/getEnvList", Method.Get);

      request.AddHeader("Cache-Control", "no-cache");
      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;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class App {
  public static void main(String[] args) throws UnirestException, UnsupportedEncodingException {

    String url = String.format("https://api.labsmobile.com/otp/getEnvList");

    Unirest.setTimeouts(0, 0);

    HttpResponse<String> response = Unirest.get(url)
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .asString();

    System.out.println("Response content: " + response.getBody());
  }
}

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

$curl = curl_init();

$url = 'https://api.labsmobile.com/otp/getEnvList';

curl_setopt_array($curl, array(
  CURLOPT_URL => $url,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic '.$auth_basic
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

import requests, base64

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

url = "https://api.labsmobile.com/otp/getEnvList"
payload = {}
headers = {
  'Authorization': 'Basic %s' % credentials,
}

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

print(response.text)

const axios = require('axios');

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

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

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

url = URI("https://api.labsmobile.com/otp/getEnvList")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")

response = https.request(request)
puts response.read_body

{"verifApp", "verifApp2", "envEx"}

Listar códigos OTP

Consulta de códigos OTP de un entorno o asociados a un número.

ENDPOINT

GET https://api.labsmobile.com/otp/getEnv

PARÁMETROS
Los parámetros env y msidn son filtros para obtener los códigos OTP enviados. Son filtros opcionales y si no se envía ningún parámetro se obtendrán como resultados todos los códigos OTP de la cuenta.
env string
Filtro del entorno donde se enmarca esta petición. Se devolverán todos los números de este entorno.
Ejemplo: &env=VerifApp
phone_number string
Filtro de número. Se devolverán todos códigos OTP de este número.
Ejemplo: &phone_number=167923402323
RESULTADO
El resultado se obtiene en formato JSON con la lista de códigos con los siguientes elementos:
msisdn string
Número asociado con el código OTP.
status 0 | 1 | 2
Estado del código OTP o petición de validación.
Valores de estado
0 Código OTP sin validación exitosa.
1 Código OTP validado correctamente.
2 Código OTP con validación caducada.
created YYYY-MM-DD HH:MM:SS
Día y hora (en uso horario UTC) de la creación del código OTP.
validated YYYY-MM-DD HH:MM:SS
Día y hora (en uso horario UTC) de la validación del código OTP. Valor nulo si no existe validación exitosa.

curl --user myUsername:myToken -X GET  \
https://api.labsmobile.com/otp/getEnv?env=verifApp&phone_number=12015550123

#include <stdio.h> 
#include <curl/curl.h> 

int main(void) {
    CURL *curl;
    CURLcode res;
    
    char *env = "verifApp";
    char *phone_number = "12015550123";

    curl = curl_easy_init();
    if(curl) {
        char *encoded_env = curl_easy_escape(curl, env, 0);
        char *encoded_phone_number = curl_easy_escape(curl, phone_number, 0);

        char url[1024];
        snprintf(url, sizeof(url),
                 "https://api.labsmobile.com/otp/getEnv?env=%s&phone_number=%s",
                 encoded_env, encoded_phone_number);

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_USERNAME, "myUsername");
        curl_easy_setopt(curl, CURLOPT_PASSWORD, "myToken");

        res = curl_easy_perform(curl);
        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }
        curl_free(encoded_env);
        curl_free(encoded_phone_number);
        curl_easy_cleanup(curl);
    }

    return 0;
}

using System;
using RestSharp;

namespace SendOtp
{
  class Program
  {
    static void MainSend(string[] args)
    {
      var client = new RestClient("https://api.labsmobile.com");
      var request = new RestRequest("/otp/getEnv", Method.Get);

      request.AddQueryParameter("env", "verifApp");
      request.AddQueryParameter("phone_number", "12015550123");

      request.AddHeader("Cache-Control", "no-cache");
      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;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class App {
  public static void main(String[] args) throws UnirestException, UnsupportedEncodingException {

    String env = URLEncoder.encode("verifApp", "UTF-8");
    String phoneNumber = URLEncoder.encode("12015550123", "UTF-8");

    String url = String.format("https://api.labsmobile.com/otp/getEnv?env=%s&phone_number=%s",
                                env, phoneNumber);

    Unirest.setTimeouts(0, 0);

    HttpResponse<String> response = Unirest.get(url)
        .basicAuth("myUsername", "myToken")
        .header("Cache-Control", "no-cache")
        .asString();

    System.out.println("Response content: " + response.getBody());
  }
}

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

$curl = curl_init();

$env = "verifApp";
$phone_number = "12015550123";

$url = 'https://api.labsmobile.com/otp/getEnv?';
            $url .= 'env='.  urlencode($env) .'&';
            $url .= 'phone_number=' .  urlencode($phone_number) .'&';

curl_setopt_array($curl, array(
  CURLOPT_URL => $url,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'Authorization: Basic '.$auth_basic
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

import requests, base64, urllib.parse

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

data = {
    'env':'verifApp',
    'phone_number': '12015550123',
}

url = "https://api.labsmobile.com/otp/getEnv?"+urllib.parse.urlencode(data, doseq=True)
payload = {}
headers = {
  'Authorization': 'Basic %s' % credentials,
}

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

print(response.text)

const axios = require('axios');

const env = "verifApp";
const phone_number = "12015550123";

let config = {
  method: 'get',
  maxBodyLength: Infinity,
  url: `https://api.labsmobile.com/otp/getEnv?env=${encodeURIComponent(env)}&phone_number=${encodeURIComponent(phone_number)}`,
  headers: { 
    'Authorization': 'Basic ' + Buffer.from("myUsername:myToken").toString('base64')
  },
};

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

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

url = URI("https://api.labsmobile.com/otp/getEnv")

data = {
  'env' => 'verifApp',
  'phone_number' => '12015550123',
}

url.query = URI.encode_www_form(data)
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = "Basic " + Base64.strict_encode64("myUsername:myToken")

response = https.request(request)
puts response.read_body

[
  {"34609033271", "1", "2016-01-03 12:32:08", "2016-01-03 12:34:40"},
  {"34699293203", "2", "2016-01-05 12:32:10", "2016-01-06 23:22:52"}
]

Errores

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

200	OK	Operación procesada correctamente.
400	Bad Request	Error en alguno de los parámetros.
401	Unauthorized	Error en las credenciales proporcionadas.
403	Forbidden	Petición bloqueada por filtros de seguridad o mal uso.
404	Not Found	Petición o comando no existente.
500	Internal Server Error	Error interno o desconocido.

Recursos de soporte

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

`0`	Petición incorrecta o con error en el envío o procesado del código OTP.
`1`	Petición de creación y envío de código OTP exitosa.

`0`	Código OTP inexistente, caducado o incorrecto para este número.
`1`	Código OTP correcto y validado.

`0`	Código OTP inexistente para este número y entorno o pendiente de validación.
`1`	Código OTP validado correctamente.

`0`	Código OTP sin validación exitosa.
`1`	Código OTP validado correctamente.
`2`	Código OTP con validación caducada.

API OTP

Autenticación

Enviar código OTP

ENDPOINT

PARÁMETROS

phone_number string obligatorio

env string

message string

sender string

digits integer

test 0 | 1

RESULTADO

Reenviar código OTP

ENDPOINT

PARÁMETROS

phone_number string obligatorio

env string

message string

sender string

digits integer

test 0 | 1

RESULTADO

Validar código OTP

ENDPOINT

PARÁMETROS

phone_number string obligatorio

env string

code string

timeframe int

RESULTADO

Comprobar código OTP

ENDPOINT

PARÁMETROS

phone_number string obligatorio

env string

RESULTADO

Listar entornos

ENDPOINT

Listar códigos OTP

ENDPOINT

PARÁMETROS

env string

phone_number string

RESULTADO

msisdn string

status 0 | 1 | 2

created YYYY-MM-DD HH:MM:SS

validated YYYY-MM-DD HH:MM:SS

Errores