Recupera la entrada del código de verificación

GET

/verify_codes/{id}

Devuelve los detalles de un código de verificación específico, incluyendo su estado e historial.

Authorizations

token

Parameters

Path Parameters

required

string

/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/

UUID of the verification code request.

Responses

200

Verify code details

application/json

Respuesta de lectura del código de verificación. Contiene los detalles completos de la solicitud del código de verificación, incluyendo el estado actual, el historial de entrega y la información de costos.

object

Identificador único (UUID) de la solicitud del código de verificación.

string

user_id

ID del usuario que creó la solicitud del código de verificación.

integer

phone

Número de teléfono del destinatario en formato internacional.

string

code

El valor del código de verificación. Si se estableció is_code_deleted y la tarea se completó, el código estará ausente.

string | null

code_length

Longitud del código de verificación.

integer | null

lang

Idioma utilizado para la plantilla del mensaje.

string

Allowed values: EN DE FR IT ES PL NL RO PT CS HU SV DA FI SK HR TR RU BG UK

routing_strategy

Lista ordenada de canales de entrega que se configuraron para esta solicitud.

Array<object>

object

channel

Tipo de canal de entrega.

string

Allowed values: telegram voice sms

timeout_sec

Tiempo de espera en segundos antes de recurrir al siguiente paso. Solo aplicable para el canal de telegram.

integer | null

sender_id

Identificador del remitente utilizado para este canal.

string | null

template

Plantilla de mensaje personalizada utilizada para este canal.

string | null

status

Estado actual del código de verificación: 0 = Nuevo, 5 = En progreso, 10 = Éxito, 20 = Fallido, 100 = Error.

integer

Allowed values: 0 5 10 20 100

delivered_channel

El canal que entregó exitosamente el código de verificación. Null si aún no se ha entregado o si la entrega falló.

string | null

Allowed values: telegram voice sms

cost

Costo total de la solicitud de verificación en céntimos de euro. Null hasta que se complete el procesamiento.

integer | null

currency

Código de moneda para el costo.

string | null

payload

Datos de payload personalizados de la solicitud original.

string | null

created_at

Marca de tiempo Unix de cuándo se creó el código de verificación.

integer

updated_at

Marca de tiempo Unix de la última actualización.

integer

history

Historial de procesamiento para cada intento de canal. Una entrada por paso de enrutamiento.

Array<object>

object

UUID de la entrada del historial.

string

channel

Tipo de canal para este intento.

string

Allowed values: telegram voice sms

status

Estado de este intento de canal: 0 = Nuevo, 5 = En progreso, 10 = Éxito, 20 = Fallido, 100 = Error.

integer

processed_at

Marca de tiempo Unix de cuándo se procesó este paso.

integer

external_id

ID del mensaje del proveedor externo.

string | null

is_code_deleted

Si el código de verificación ha sido eliminado del almacenamiento después de ser enviado al destinatario.

boolean | null

Examples

multi_channel

Verify code response with multi-channel routing

Successful response after creating a verification code with a 3-step routing strategy. Telegram and voice channels failed, SMS succeeded.

{
  "id": "d7ad7539-fb8f-4dbb-a7f7-7c40babec969",
  "user_id": 12345,
  "phone": "+491701234567",
  "routing_strategy": [
    {
      "channel": "telegram",
      "timeout_sec": 30
    },
    {
      "channel": "voice",
      "sender_id": "LOX24",
      "template": "Your code is {{code}}"
    },
    {
      "channel": "sms",
      "sender_id": "LOX24",
      "template": "Your code is {{code}}"
    }
  ],
  "status": 10,
  "delivered_channel": "sms",
  "cost": 120,
  "currency": "EUR",
  "code": "1234",
  "code_length": 4,
  "payload": "yours payload here",
  "lang": "EN",
  "created_at": 1779903448,
  "updated_at": 1779903510,
  "history": [
    {
      "id": "bccaff09-59f2-11f1-a685-7c10c91d54a1",
      "channel": "telegram",
      "status": 20,
      "processed_at": 1779903478,
      "external_id": "tg_msg_001"
    },
    {
      "id": "bccaff09-59f2-11f1-a685-7c10c91d54a2",
      "channel": "voice",
      "status": 20,
      "processed_at": 1779903490,
      "external_id": "voice_msg_002"
    },
    {
      "id": "bccaff09-59f2-11f1-a685-7c10c91d54a3",
      "channel": "sms",
      "status": 10,
      "processed_at": 1779903510,
      "external_id": "sms_msg_003"
    }
  ],
  "is_code_deleted": false
}

401

El ID de cliente o la clave API no están activos o no son válidos.

403

La cuenta no está activada. Espere o póngase en contacto con el servicio de asistencia.

404

No se ha encontrado el recurso

429

La dirección IP fue bloqueada temporalmente, ya que durante poco tiempo se enviaron muchas solicitudes con credenciales no válidas. Espere y pruebe más tarde.

Code Samples

#!/usr/bin/env bash
curl -X GET https://api.lox24.eu/verify_codes/d7ad7539-fb8f-4dbb-a7f7-7c40babec969 \
  -H 'X-LOX24-AUTH-TOKEN: 1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx'

using System;
using System.IO;
using System.Net;
using System.Text;

namespace Lox24.Api
{
    class GetVerifyCodesItem
    {
        static void Main()
        {
            string key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";
            string verifyCodeId = "d7ad7539-fb8f-4dbb-a7f7-7c40babec969";
            string url = $"https://api.lox24.eu/verify_codes/{verifyCodeId}";

            var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
            httpWebRequest.ReadWriteTimeout = 100000;
            httpWebRequest.ContentType = "application/json; charset=utf-8";
            httpWebRequest.Accept = "application/json";
            httpWebRequest.Method = "GET";
            httpWebRequest.Headers.Add("X-LOX24-AUTH-TOKEN", key);

            try
            {
                using (HttpWebResponse resp = (HttpWebResponse)httpWebRequest.GetResponse())
                {
                    if (resp.StatusCode == HttpStatusCode.OK) {
                        Console.WriteLine("Success:{0} {1}", (int)resp.StatusCode, "verify code resource response");
                    } else {
                        Console.WriteLine("Error: wrong response code {0}", (int)resp.StatusCode);
                    }

                    Stream respStream = resp.GetResponseStream();
                    using (StreamReader sr = new StreamReader(respStream, Encoding.UTF8))
                    {
                        string responseText = sr.ReadToEnd();
                        Console.WriteLine("responseText : {0}", responseText);
                    }
                }
            }
            catch (System.Net.WebException ex)
            {
                var webResponse = ex.Response as System.Net.HttpWebResponse;
                Console.WriteLine("Error:{0}", webResponse.StatusCode);

                switch (webResponse.StatusCode)
                {
                    case HttpStatusCode.Unauthorized:
                        Console.WriteLine("Error:401 Client ID or API key isn't active or invalid!");
                        break;
                    case HttpStatusCode.Forbidden:
                        Console.WriteLine("Error:403 Account isn't activated.");
                        break;
                    case HttpStatusCode.NotFound:
                        Console.WriteLine("Error:404 Resource not found");
                        break;
                    case HttpStatusCode.InternalServerError:
                    case HttpStatusCode.BadGateway:
                    case HttpStatusCode.ServiceUnavailable:
                    case HttpStatusCode.GatewayTimeout:
                        Console.WriteLine("System error! Please contact to LOX24 support!");
                        break;
                }
            }
        }
    }
}

package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {

  const Method = "GET"
  const URL = "https://api.lox24.eu/verify_codes/d7ad7539-fb8f-4dbb-a7f7-7c40babec969"
  const Token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx"

  client := &http.Client{}

  req, err := http.NewRequest(Method, URL, nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Add("X-LOX24-AUTH-TOKEN", Token)
  req.Header.Add("Accept", "application/json")

  res, err := client.Do(req)
  if err != nil {
    log.Fatal(err)
  }

  defer res.Body.Close()

  body, err := io.ReadAll(res.Body)
  if err != nil {
    log.Fatal(err)
  }

  switch res.StatusCode {
  case 200:
    fmt.Println(string(body))
  case 401:
    fmt.Println("Error: code = 401 - Client ID or API key isn't active or invalid!")
  case 403:
    fmt.Println("Error: code = 403 - Account isn't activated.")
  case 404:
    fmt.Println("Error: code = 404 - Resource not found")
  default:
    fmt.Printf("Error: code = %d\n", res.StatusCode)
  }
}

package eu.lox24.doc.verify_codes;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class GetVerifyCodesItem {

    public static void main(String[] args) {

        var key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";
        var verifyCodeId = "d7ad7539-fb8f-4dbb-a7f7-7c40babec969";
        var url = "https://api.lox24.eu/verify_codes/" + verifyCodeId;

        var httpRequest = HttpRequest.newBuilder(URI.create(url))
                .timeout(Duration.ofMillis(100000))
                .setHeader("Accept", "application/json")
                .setHeader("X-LOX24-AUTH-TOKEN", key)
                .GET()
                .build();

        var client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_1_1)
                .build();

        try {
            var httpResponse = client.send(httpRequest, HttpResponse.BodyHandlers.ofString());

            if (httpResponse.statusCode() == HttpURLConnection.HTTP_OK) {
                System.out.println("Success:" + httpResponse.statusCode() + " " + "verify code resource response");
                System.out.println("Response text : \n" + httpResponse.body());
            } else {
                switch (httpResponse.statusCode()) {
                    case HttpURLConnection.HTTP_UNAUTHORIZED:
                        System.out.println("Error:401 Client ID or API key isn't active or invalid!");
                        break;
                    case HttpURLConnection.HTTP_FORBIDDEN:
                        System.out.println("Error:403 Account isn't activated.");
                        break;
                    case HttpURLConnection.HTTP_NOT_FOUND:
                        System.out.println("Error:404 Resource not found");
                        break;
                    case HttpURLConnection.HTTP_INTERNAL_ERROR:
                    case HttpURLConnection.HTTP_BAD_GATEWAY:
                    case HttpURLConnection.HTTP_UNAVAILABLE:
                    case HttpURLConnection.HTTP_GATEWAY_TIMEOUT:
                        System.out.println("System error! Please contact to LOX24 support!");
                        break;
                    default:
                        System.out.println("Error: wrong response code " + httpResponse.statusCode());
                }
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*
 * Get verify code by ID
 */
const token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";
const verifyCodeId = "d7ad7539-fb8f-4dbb-a7f7-7c40babec969";

const https = require('https');
const options = {
    hostname: 'api.lox24.eu',
    path: `/verify_codes/${verifyCodeId}`,
    method: 'GET',
    headers: {
        'Accept': 'application/json',
        'X-LOX24-AUTH-TOKEN': token
    }
}

const req = https.request(options, res => {
    if (res.statusCode == 200) {
        console.log("Success: code = 200 - verify code resource response");
        res.on('data', d => { process.stdout.write(d) })
    }
    else if (res.statusCode == 401) console.log("Error: code = 401 - Client ID or API key isn't active or invalid!");
    else if (res.statusCode == 403) console.log("Error: code = 403 - Account isn't activated.");
    else if (res.statusCode == 404) console.log("Error: code = 404 - Resource not found");
})

req.on('error', error => {
    console.error(error)
})
req.end();

<?php

$verifyCodeId = 'd7ad7539-fb8f-4dbb-a7f7-7c40babec969';
$uri = "https://api.lox24.eu/verify_codes/{$verifyCodeId}";

$token = '1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx';

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $uri,
    CURLOPT_HTTPHEADER => [
        "X-LOX24-AUTH-TOKEN: {$token}",
        'Accept: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 20,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
]);

$response = curl_exec($curl);
$code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);

$data = json_decode($response, JSON_OBJECT_AS_ARRAY);

if(200 === $code) {
    echo 'Success: response data = ' . var_export($data, true);
} else {
    echo "Error: code = {$code}, data = " . var_export($data, true);
}

import json
import requests


token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx"
verify_code_id = "d7ad7539-fb8f-4dbb-a7f7-7c40babec969"

url = f'https://api.lox24.eu/verify_codes/{verify_code_id}'

headers = {
    'Accept': 'application/json',
    'X-LOX24-AUTH-TOKEN': token,
}

try:
    res = requests.get(url, headers=headers, timeout=100)
    if res.status_code != 200:
        res.raise_for_status()
    else:
        print(f'Success: code = {res.status_code} - verify code resource response')
        print("Response: ", json.dumps(res.json(), indent=4))

except requests.HTTPError:
    if res.status_code == 401:
        print("Error: code = 401 - Client ID or API key isn't active or invalid!")
    elif res.status_code == 403:
        print("Error: code = 403 - Account isn't activated.")
    elif res.status_code == 404:
        print("Error:404 Resource not found")
    elif res.status_code in (500, 502, 503, 504):
        print("System error! Please contact to LOX24 support!")
    else:
        print(f"Error: code {res.status_code}")
    print(json.dumps(res.json(), indent=4))