Bulk delete SMS messages

POST

/sms/ops/batch_delete

With this API you can delete SMS any messages

Authorizations

token

Code Samples

#!/usr/bin/env bash
curl -X POST https://api.lox24.eu/sms/ops/batch_delete?uuid=20f39273-0566-11ea-a637-96000028b339  \
  -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 text = "Test";

            var query = "text=" + text + "&uuid[]=ab6b6ceb-903a-11ea-aa81-96000028b339&uuid[]=7c7a6661-902e-11ea-aa81-96000028b339";
            string url = "https://api.lox24.eu/sms/ops/batch_delete?" + query;

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

            try
            {
                using (HttpWebResponse resp = (HttpWebResponse)httpWebRequest.GetResponse())
                {
                    if(resp.StatusCode == HttpStatusCode.OK) {
                        Console.WriteLine("Success: SMS was deleted!");
                    } else {
                        Console.WriteLine("Error: SMS wasn't deleted!");
                    }

                    Stream respStream = resp.GetResponseStream();
                    using (StreamReader sr = new StreamReader(respStream, Encoding.UTF8))
                    {
                        string responseText = sr.ReadToEnd();
                        Console.WriteLine("responseText : {0}", responseText);
                    }
                }

            }
            catch (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 = "POST"
  const URL = "https://api.lox24.eu/sms/ops/batch_delete?uuid=20f39273-0566-11ea-a637-96000028b339"
  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.sms;

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

    public static void main(String[] args) {

        var key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";

        var text = "";
        var query = "text=" + text + "&uuid[]=ab6b6ceb-903a-11ea-aa81-96000028b339&uuid[]=7c7a6661-902e-11ea-aa81-96000028b339";
        var url = "https://api.lox24.eu/sms/ops/batch_delete?" + query;

        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)
                .POST(HttpRequest.BodyPublishers.ofString(""))
                .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() + " " + "Success: SMS was canceled!");
                System.out.println("Response text : \n" + httpResponse.body());
            } else {
                System.out.println("Error: SMS wasn't canceled!");
                System.out.println("Response text : \n" + httpResponse.body());


                System.out.println("Error: " + 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_NOT_FOUND: // 404
                        System.out.println("Error:404 Resource not found");
                        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 = "uuid[]=44657141-9830-11ea-aa81-96000028b339&uuid[]=5dd2ba0e-9830-11ea-aa81-96000028b339&_order[created_at]=desc";

const https = require('https');
const options = {
    hostname: host,
    path: '/sms/ops/batch_delete?' + query,
    method: 'POST',
    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 - Count of the deleted SMS");
        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/sms/ops/batch_delete';

$filters = [
    //'text' => 'Test',
    'uuid' => [
        '8481900d-86ce-11ea-aa81-96000028b339',
        'd5ceb189-86cd-11ea-aa81-96000028b339',
    ],
];

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

echo $uri;

curl_setopt_array($curl, [
    CURLOPT_POST => true,
    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 'SMS canceled, info = ' . var_export($data, true);
} else {
    echo "Error: code = {$code}, data = " . var_export($data, true);
}

import json
import requests


token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx"
text = "Test"

query = f"text={text}&uuid[]=ab6b6ceb-903a-11ea-aa81-96000028b339&uuid[]=7c7a6661-902e-11ea-aa81-96000028b339"

url = f"https://api.lox24.eu/sms/ops/batch_delete?{query}"


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



try:
    # timeout is 100 seconds, the payload is automatically converted to json format
    res = requests.post(url, headers=headers, timeout=100)
    if res.status_code != 200: # Ok
        print("Error: SMS wasn't canceled")
        res.raise_for_status()
    else:
        print(f'Success: code = {res.status_code} - SMS was canceled')
        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))

Parameters

Query Parameters

_order[created_at]

string

default: asc

Allowed values: asc desc

Sort by timestamp when the entity was created

_order[gateway_sent_at]

string

default: asc

Allowed values: asc desc

Sort by timestamp when the message was transmitted to the mobile network

is_sent

boolean

Boolean filter SMS by the is_sent field to distinguish between already sent and not yet sent sms

is_unicode

boolean

Boolean filter SMS by the is_unicode field to distinguish between GSM and Unicode messages

uuid

string

Exact filter by SMS ID

uuid[]

Array<string>

Exact filter by SMS ID

iso2

string

Exact filter SMS by the phone’s country (ISO 3166-1 alpha-2)

iso2[]

Array<string>

Exact filter SMS by the phone’s countries (ISO 3166-1 alpha-2)

dlr_code

integer

Exact filter SMS by the delivery report status

dlr_code[]

Array<integer>

Exact filter SMS by the delivery report statuses

status_code

integer

Exact filter SMS by the status code

status_code[]

Array<integer>

Exact filter SMS by the statuses codes

gateway_sent_at

integer

Exact filter SMS by the send to gateway timestamp

gateway_sent_at[]

Array<integer>

Exact and range filter SMS by send to gateway timestamps

delivery_at

integer

Exact filter SMS by the delivery timestamp

delivery_at[]

Array<integer>

Exact and range filter SMS by the delivery timestamps

created_at

integer

Exact filter entities by the creation timestamp

created_at[]

Array<integer>

Exact and range filter entities by the creation timestamps

chars_count

integer

Range filter SMS by the message chars count

chars_count[]

Array<integer>

Exact and range filter SMS by the message chars count

parts_count

integer

Exact filter SMS by the message parts count

parts_count[]

Array<integer>

Exact and range filter SMS by the message parts count

bulk

string

Exact filter SMS by the Bulk

bulk[]

Array<string>

Exact and range filter SMS by the Bulk

source

integer

Exact filter SMS by the sources

source[]

Array<integer>

Exact and range filter SMS by the sources

text

string

Partial case-insensitive text filter SMS by the message text

phone

string

Partial text filter SMS by the phone number

sender_id

string

Partial text case-insensitive filter SMS by the sender number or text

string

Partial text filter SMS by the IP which created the message

key_id

integer

Exact filter entities by the used API key

key_id[]

Array<integer>

Exact filter entities by the used API keys

callback_data

string

Exact filter SMS by callback_data property

callback_data[]

Array<string>

Exact filter SMS by callback_data property

Responses

200

Count of the deleted SMS

object

deleted_sms_count

Count of the SMS which was deleted

integer

401

Client ID or API key isn’t active or invalid!

403

Account isn’t activated. Please wait or contact to support!

422

The request was well-formed but was unable to be followed due to semantic errors

429

IP address was temporary blocked, because during short time from it was sent many request with invalid credentials. Please wait and try later.