Recupera la colección de SMS entrantes

GET

/incomings

Obtener la lista de SMS entrantes ordenados por el campo received_at en orden descendente. El buzón contiene todos los SMS enviados, no enviados y terminados. Para las respuestas SMS la propiedad msg_uuid rellenada por la entidad /sms correspondiente.

Authorizations

token

Parameters

Query Parameters

page

integer

default: 1 >= 1

Página actual

_order[received_at]

string

default: asc

Allowed values: asc desc

Ordenar por fecha y hora de recepción del SMS entrante

text

string

Partial filtro de texto sin distinción entre mayúsculas y minúsculas SMS por el texto del mensaje

from

string

Partial filtro de texto que no distingue mayúsculas de minúsculas por número de teléfono del remitente

string

Partial filtro de texto sensible a mayúsculas y minúsculas por número de teléfono de entrada

msg_uuid

string

Exact filtrar por ID de SMS inicial

msg_uuid[]

Array<string>

Exact filtrar por ID de SMS inicial

Responses

200

Incomings collection

object

hydra:member

required

Array<object>

Incoming SMS

object

@id

JSON-LD ID

string

@type

JSON-LD type

string

@context

One of:

string
object

string

uuid

UUID único de entidad

string

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

Número de destinatario (internacional):

+491701234567 (E.164)
00491701234567
491701234567
01701234567 (si la cuenta está registrada en Alemania) se convertirá en +491701234567

Si el número no está en formato E.164, el servicio lo convertirá basándose en la dirección del usuario. Para evitar problemas con la conversión, utilice preferentemente E.164.

string

>= 4 characters <= 16 characters /^\+[1-9]\d{1,14}$/

from

Número de destinatario (internacional):

+491701234567 (E.164)
00491701234567
491701234567
01701234567 (si la cuenta está registrada en Alemania) se convertirá en +491701234567

Si el número no está en formato E.164, el servicio lo convertirá basándose en la dirección del usuario. Para evitar problemas con la conversión, utilice preferentemente E.164.

string

>= 4 characters <= 16 characters /^\+[1-9]\d{1,14}$/

received_at

Fecha y hora en que el servicio recibió el SMS

integer

text

Texto SMS

string | null

msg_uuid

ID del SMS que se replica

string | null

hydra:totalItems

integer

hydra:view

object

@id

string format: iri-reference

@type

string

hydra:first

string format: iri-reference

hydra:last

string format: iri-reference

hydra:previous

string format: iri-reference

hydra:next

string format: iri-reference

hydra:search

object

@type

string

hydra:template

string

hydra:variableRepresentation

string

hydra:mapping

Array<object>

object

@type

string

variable

string

property

string | null

required

boolean

Example

{
  "hydra:member": [
    {
      "@context": {
        "hydra": "http://www.w3.org/ns/hydra/core#"
      },
      "to": "+14155552671",
      "from": "+14155552671"
    }
  ],
  "hydra:view": {
    "@id": "string",
    "@type": "string",
    "hydra:first": "string",
    "hydra:last": "string",
    "hydra:previous": "string",
    "hydra:next": "string"
  }
}

Array<object>

Incoming SMS

object

uuid

UUID único de entidad

string

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

Número de destinatario (internacional):

+491701234567 (E.164)
00491701234567
491701234567
01701234567 (si la cuenta está registrada en Alemania) se convertirá en +491701234567

Si el número no está en formato E.164, el servicio lo convertirá basándose en la dirección del usuario. Para evitar problemas con la conversión, utilice preferentemente E.164.

string

>= 4 characters <= 16 characters /^\+[1-9]\d{1,14}$/

from

Número de destinatario (internacional):

+491701234567 (E.164)
00491701234567
491701234567
01701234567 (si la cuenta está registrada en Alemania) se convertirá en +491701234567

Si el número no está en formato E.164, el servicio lo convertirá basándose en la dirección del usuario. Para evitar problemas con la conversión, utilice preferentemente E.164.

string

>= 4 characters <= 16 characters /^\+[1-9]\d{1,14}$/

received_at

Fecha y hora en que el servicio recibió el SMS

integer

text

Texto SMS

string | null

msg_uuid

ID del SMS que se replica

string | null

Example

[
  {
    "to": "+14155552671",
    "from": "+14155552671"
  }
]

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.

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/incomings \
  -H 'X-LOX24-AUTH-TOKEN: 1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx'

using Newtonsoft.Json.Linq;
using System;
using System.IO;
using System.Net;
using System.Text;

namespace Lox24.Api
{
    class client
    {
        static void Main()
        {
            string key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";
            string url = "https://api.lox24.eu/incomings?text=Test&msg_uuid[]=8481900d-86ce-11ea-aa81-96000028b339&msg_uuid[]=d5ceb189-86cd-11ea-aa81-96000028b339&page=1&_order[created_at]=desc";

            var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
            httpWebRequest.ReadWriteTimeout = 100000;
            httpWebRequest.Accept = "application/json"; // or "application/ld+json"
            httpWebRequest.Method = "GET";
            //httpWebRequest.KeepAlive = true;
            httpWebRequest.Headers.Add("X-LOX24-AUTH-TOKEN", key);
            httpWebRequest.Credentials = CredentialCache.DefaultNetworkCredentials;

            try
            {
                using (HttpWebResponse resp = (HttpWebResponse)httpWebRequest.GetResponse())
                {
                    int respCode = (int)resp.StatusCode;
                    Console.WriteLine("Success:{0} {1}", respCode, "Incoming SMS collection response");

                    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: // 401
                        Console.WriteLine("Error:401 Client ID or API key isn't active or invalid!");
                        break;
                    case HttpStatusCode.Forbidden: // 403
                        Console.WriteLine("Error:403 Account isn't activated. Please wait or contact to support!");
                        break;
                    case HttpStatusCode.InternalServerError: // 500
                    case HttpStatusCode.BadGateway: //502
                    case HttpStatusCode.ServiceUnavailable: // 503
                    case HttpStatusCode.GatewayTimeout: // 504
                        Console.WriteLine("System error! Please contact to LOX24 support!");
                        break;
                }
            }
        }
    }

package main

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

func main() {

  const Method = "GET"
  const URL = "https://api.lox24.eu/incomings"

  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 := ioutil.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. Please wait or contact to support!")
  default:
    fmt.Printf("Error: code = %d\n", res.StatusCode)
  }
}

package eu.lox24.doc.incomings;

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 GetIncomingsCollection {

    public static void main(String[] args) {

        var key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";
        var url = "https://api.lox24.eu/incomings?text=Test&msg_uuid[]=8481900d-86ce-11ea-aa81-96000028b339&msg_uuid[]=d5ceb189-86cd-11ea-aa81-96000028b339&page=1&_order[created_at]=desc";

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

        var client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_1_1) // Http 1.1 clients are kept alive be default
                .build();

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

            if (httpResponse.statusCode() == HttpURLConnection.HTTP_OK) {
                System.out.println("Success:" + httpResponse.statusCode() + " " + "incomings collection response");
                System.out.println("Response text : \n" + httpResponse.body());
            } else {
                System.out.println("Error: something went wrong, code(" + httpResponse.statusCode() + ")");

                switch (httpResponse.statusCode()) {

                    case HttpURLConnection.HTTP_UNAUTHORIZED: // 401
                        System.out.println("Error:401 Client ID or API key isn't active or invalid!");
                        break;
                    case HttpURLConnection.HTTP_FORBIDDEN: // 403
                        System.out.println("Error:403 Account isn't activated. Please wait or contact to support!");
                        break;
                    case HttpURLConnection.HTTP_INTERNAL_ERROR: // 500
                    case HttpURLConnection.HTTP_BAD_GATEWAY: //502
                    case HttpURLConnection.HTTP_UNAVAILABLE: // 503
                    case HttpURLConnection.HTTP_GATEWAY_TIMEOUT: // 504
                        System.out.println("System error! Please contact to LOX24 support!");
                        break;
                }

            }

        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

const host = 'api.lox24.eu';
const token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";

var query = "text=Test&msg_uuid[]=8481900d-86ce-11ea-aa81-96000028b339&msg_uuid[]=d5ceb189-86cd-11ea-aa81-96000028b339&page=1&_order[created_at]=desc";


const https = require('https');
const options = {
    hostname: host,
    path: '/incomings?' + query,
    method: 'GET',
    headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json',
        'X-LOX24-AUTH-TOKEN': token
    }
}

const req = https.request(options, res => {
    if (res.statusCode == 200) {
        console.log('Success: code = 200 - incoming messages collection 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. Please wait or contact to support!");
    }  else {
        console.log("Error: code = " + res.statusCode );
    }
})

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

req.end();

<?php

$token = '1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx';

$uri = 'https://api.lox24.eu/incomings';

$filters = [
    'text' => 'Test',
    'msg_uuid' => [
        '8481900d-86ce-11ea-aa81-96000028b339',
        'd5ceb189-86cd-11ea-aa81-96000028b339',
    ],
    'page' => 1,
    '_order' => [
        'received_at' => 'desc'
    ],
];

$uri .= $filters ? '?' . http_build_query($filters) : '';
$curl = curl_init();

echo $uri;

curl_setopt_array($curl, [
    CURLOPT_URL => $uri,
    CURLOPT_HTTPHEADER => [
        "X-LOX24-AUTH-TOKEN: {$token}",
        'Accept: application/json', // or application/ld+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"

url = "https://api.lox24.eu/incomings?text=Test&msg_uuid[]=8481900d-86ce-11ea-aa81-96000028b339&msg_uuid[]=d5ceb189-86cd-11ea-aa81-96000028b339&page=1&_order[created_at]=desc"

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

try:
    # timeout is 100 seconds
    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} - incomings collection 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. Please wait or contact to support!")
    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))