Retrieves the collection of blocked phone numbers

GET

/blocked_numbers

Retrieves the collection of blocked phone numbers with optional filtering by number or type

Authorizations

token

Parameters

Query Parameters

number

string

Filtrar por número de teléfono exacto

type

string

Filtrar por tipo exacto de número bloqueado

Responses

200

Blocked_numbers collection

object

hydra:member

required

Array<object>

Blocked phone number - JSON-LD read representation

object

@id

JSON-LD ID

string

@type

JSON-LD type

string

@context

One of:

string
object

string

required

Unique identifier

integer

>= 1

number

required

Phone number in international format

string

/^\+[0-9]{4,20}$/

type

required

Blocked number’s type:

1 - blocked by customer
2 - unsubscribed by user

integer

Allowed values: 1 2

added_at

required

Fecha en la que se añadió la entidad al sistema por el usuario

integer

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#"
      },
      "number": "+1234567890",
      "type": 1
    }
  ],
  "hydra:view": {
    "@id": "string",
    "@type": "string",
    "hydra:first": "string",
    "hydra:last": "string",
    "hydra:previous": "string",
    "hydra:next": "string"
  }
}

Array<object>

Blocked phone number - read representation

object

required

Unique identifier

integer

>= 1

number

required

Phone number in international format

string

/^\+[0-9]{4,20}$/

type

required

Blocked number’s type:

1 - blocked by customer
2 - unsubscribed by user

integer

Allowed values: 1 2

added_at

required

Fecha en la que se añadió la entidad al sistema por el usuario

integer

Example

[
  {
    "number": "+1234567890",
    "type": 1
  }
]

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/blocked_numbers \
  -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/blocked_numbers?page=1";

            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, "blocked numbers 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/blocked_numbers?page=1"
  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.blocked_number;

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

    public static void main(String[] args) {

        var key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";
        var url = "https://api.lox24.eu/blocked_numbers?page=1";

        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() + " " + "blocked numbers 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 = "page=1";

const https = require('https');
const options = {
    hostname: host,
    path: '/blocked_numbers?' + query,
    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 - blocked numbers list 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/blocked_numbers';

$filters = [
    'page' => 1,
];

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

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/blocked_numbers?page=1"

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} - blocked numbers 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))