LOX24 is your worldwide SMS service

The interface for your SMS business messaging

You can easily send and receive your SMS through our cloud SMS interface. Our SMS gateway offers you European data protection, guaranteed delivery and low prices.

Our SMS interfaces and products

Your SMS gateway to 880 networks worldwide

Send and receive SMS worldwide and uncomplicated via our SMS Gateway

State-of-the-art REST API

SSL encrypted HTTP API for the single and bulk SMS

Various interfaces

For integration into your application we offer HTTPS and mail interfaces

Sending and receiving SMS

Send SMS, receive incoming messages and delivery reports

99.9% availability and 24/7 mail support

Send your SMS worldwide securely and in a few seconds

Send bulk SMS with tracking via web and API

Web interface with import function

Send your bulk SMS directly from the website with import of your numbers

Short link campaigns with tracking

Success control with evaluation of click rates and who clicked on your links

API for SMS marketing

Bulk SMS not only via the web account but also with our interface

SMS distribution list with opt-in/out

Maintain SMS distribution list online and integrated opt-out function for your SMS

Send appointment reminders and confirmations by SMS

Integration for Google Calendar

Send your SMS reminders directly from your Google Calendar

Integration for Outlook 365

From Outlook 2010 you can also send SMS reminders with our plugin

Confirmations and reminders

Send not only appointment reminders, but also confirmations

Dynamic text templates

Have dates from the calendar entry automatically inserted into your SMS texts

Send SMS directly from Outlook

Plugin with high compatibility

Send from Outlook 2010 and all newer version inlcuding Outlook 365

Access to the address book

Use the familiar Outlook address book to send your SMS messages

Text templates and signatures

Make your work easier with text templates for your SMS texts

Appointment reminders from the calendar

Also send SMS directly from Outlook calendar if needed

Two-factor authentication via SMS and voice call

Increase the security of your systems with 2FA

Another factor via SMS or voice call increases the security of your login

Voice calls and SMS with one interface

Send verification codes via SMS and voice call using the same API

Worldwide availability

All networks worldwide are covered even when roaming

European data protection

Your codes can be deleted for security directly after transmission

Fraud prevention with scoring

Higher security for online transactions

Whether orders or login, our system reliably detects fraudsters

Identify problematic customers

Detect anonymous VPN users or false data with our API

Scoring and detailed information

Our scoring gives you an overall impression supplemented with further data

European data protection

Our service is GDPR compatible and we are located in Germany

Success Stories

Examples for

SMS projects of our customers

Do you speak php?

Our API is compatible with all modern programming languages

With the help of curl you can easily use our HTTP interface in PHP and send SMS.

GO SMS

With Go io/ioutil and net/http are imported and the SMS data can be transferred to the SMS API.

Python gives you a number of different ways to interact with our SMS gateway. For example, you can use urllib, Requests, Octopus or HTTPie.

C# SMS

The WebRequest.Create method does the work for you and transfers the most important data of your SMS to our gateway.

				
					#!/usr/bin/env bash
curl -X POST https://api.lox24.eu/sms \
  -H 'Content-Type: application/json' \
  -H 'X-LOX24-AUTH-TOKEN: 1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx' \
  -d '{
    "sender_id": "My Sender",
    "phone": "+49751234567",
    "source": 111,
    "service_code": "direct",
    "text": "Test message",
    "delivery_at": 1573724611,
    "is_unicode": true,
    "callback_data": "123456",
    "voice_lang": "DE"
}'

				
			
				
					<?php

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

$token = '1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx';

$body = [
    'sender_id' => 'My Sender',
    'text' => "First line\nSecond line",
    'service_code' => 'direct',
    'phone' => '+49751234567',
    'delivery_at' => 1573724611,
    'is_unicode' => true,
    'callback_data' => '123456',
    'voice_lang' => 'DE',
];

if(!$body = json_encode($body)) {
    die('JSON encoding error!');
}

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_POST => true,
    CURLOPT_URL => $uri,
    CURLOPT_POSTFIELDS => $body,
    CURLOPT_HTTPHEADER => [
        "X-LOX24-AUTH-TOKEN: {$token}",
        'Accept: application/json', // or application/ld+json
        'Content-Type: 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(201 === $code) {
    echo 'Success: response data = ' . var_export($data, true);
} else {
    echo "Error: code = {$code}, data = " . var_export($data, true);
}




				
			
				
					package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

func main() {

	const Method = "POST"
	const URL = "https://api.lox24.eu/sms"
	const Token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx"

	payload := map[string]interface{}{
		"sender_id":    "My Sender",
		"phone":        "+49751234567",
		"source":       111,
		"service_code": "direct",
		"text":         "Test message",
		"delivery_at":  1593724611,
		"is_unicode":   true,
		"callback_data": "123456",
		"voice_lang": "DE",
	}

	jsonPayload, _ := json.Marshal(payload)

	client := &http.Client{}

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

	req.Header.Add("X-LOX24-AUTH-TOKEN", Token)
	req.Header.Add("Content-Type", "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 201:
		fmt.Println((string(body)))
	case 400:
		fmt.Println("Error: code = 400 - Invalid input")
	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)
	}
}

				
			
				
					using Newtonsoft.Json;
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/sms";

            var data = new {
                sender_id = "My Sender",
                text = "Test message",
                service_code = "direct",
                phone = "+49751234567",
                delivery_at = 1573724611,
                is_unicode = true,
                callback_data = "123456",
                voice_lang = "DE"
            };

            string postdata = JsonConvert.SerializeObject(data);

            Console.WriteLine("Post data: {0}", postdata);

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

            using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
            {
                streamWriter.Write(postdata);
                streamWriter.Flush();
                streamWriter.Close();
            }
            try
            {
                using (HttpWebResponse resp = (HttpWebResponse)httpWebRequest.GetResponse())
                {

                    if(resp.StatusCode == HttpStatusCode.Created) {
                        Console.WriteLine("Success:{0} {1}", (int)resp.StatusCode, "sms resource created");
                    } else {
                        Console.WriteLine("Error: wrong response code {0} on create sms", (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.BadRequest: // 400
                        Console.WriteLine("Error:400 Invalid input");
                        break;
                    case HttpStatusCode.Unauthorized: // 401
                        Console.WriteLine("Error:401 Client ID or API key isn't active or invalid!");
                        break;
                    case HttpStatusCode.PaymentRequired: // 402
                        Console.WriteLine("Error:402 There are not enough funds on your account!");
                        break;
                    case HttpStatusCode.Forbidden: // 403
                        Console.WriteLine("Error:403 Account isn't activated. Please wait or contact to support!");
                        break;
                    case HttpStatusCode.NotFound: // 404
                        Console.WriteLine("Error:404 Resource not found");
                        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;
                }
            }
        }
    }

				
			
				
					import json
import requests


token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx"

url = 'https://api.lox24.eu/sms'


data = {
    'sender_id': "My Sender",
    'text' : "Test message",
    'service_code' : "direct",
    'phone': "+49751234567",
    'delivery_at': 1573724611,
    'is_unicode': True,
    'callback_data' => '123456',
    'voice_lang' => 'DE'
}

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

print("Post data : ", json.dumps(data, indent=4))

try:
    # timeout is 100 seconds, the payload is automatically converted to json format
    res = requests.post(url, headers=headers, json=data, timeout=100)
    if res.status_code != 201: # Created
        print("Error: Wrong response code on create sms")
        res.raise_for_status()
    else:
        print(f'Success: code = {res.status_code} - sms resource created')
        print("Response: ", json.dumps(res.json(), indent=4))

except requests.HTTPError:
    if res.status_code == 400:
        print("Error:400 Invalid input")
    elif res.status_code == 401:
        print("Error: code = 401 - Client ID or API key isn't active or invalid!")
    elif res.status_code == 402:
        print("Error:402 There are not enough funds on your account!")
    elif res.status_code == 403:
        print("Error: code = 403 - Account isn't activated. Please wait or contact to support!")
    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))



				
			
				
					package eu.lox24.doc.sms;

import org.json.JSONObject;

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

    public static void main(String[] args) {

        var key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";
        var url = "https://api.lox24.eu/sms";

        var json = new JSONObject();
        json.put("sender_id", "My Sender");
        json.put("text", "Test message");
        json.put("service_code", "direct");
        json.put("phone", "+49751234567");
        json.put("delivery_at", 1573724611);
        json.put("is_unicode", true);
        json.put("callback_data", "123456");
        json.put("voice_lang", "DE");

        var postData = json.toString();

        System.out.println("Post data: " + postData);

        var httpRequest = HttpRequest.newBuilder(URI.create(url))
                .timeout(Duration.ofMillis(100000))
                .setHeader("Content-Type", "application/json; charset=utf-8")
                .setHeader("Accept", "application/json") // or application/ld+json
                .setHeader("X-LOX24-AUTH-TOKEN", key)
                .POST(HttpRequest.BodyPublishers.ofString(postData))
                .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_CREATED) {
                System.out.println("Success:" + httpResponse.statusCode() + " " + "sms resource created");
                System.out.println("Response text : \n" + httpResponse.body());

            } else {

                System.out.println("Error: wrong response code " + httpResponse.statusCode() + " on create sms");

                switch (httpResponse.statusCode()) {

                    case HttpURLConnection.HTTP_BAD_REQUEST: // 400
                        System.out.println("Error:400 Invalid input");
                        break;
                    case HttpURLConnection.HTTP_UNAUTHORIZED: // 401
                        System.out.println("Error:401 Client ID or API key isn't active or invalid!");
                        break;
                    case HttpURLConnection.HTTP_PAYMENT_REQUIRED: // 402
                        System.out.println("Error:402 There are not enough funds on your account!");
                        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();
        }
    }
}

				
			
				
					/*
 * Post sms
 */
const token = "7b7c6063bab885ce79814b5ff1ee6885";

var postObj = {
    sender_id: 'My Sender',
    text: 'Test message',
    service_code: 'direct',
    phone: '+49751234567',
    delivery_at: 1573724611,
    is_unicode: true,
    callback_data: "123456",
    voice_lang: "DE"
};

var postdata = JSON.stringify(postObj);

const https = require('https');
const options = {
    hostname: 'api.lox24.eu',
    path: '/sms',
    method: 'POST',
    headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json',
        'Content-Length': postdata.length,
        'X-LOX24-AUTH-TOKEN': token
    }
}

const req = https.request(options, res => {
    if (res.statusCode == 201) {
        console.log("Success: code = 201 - sms resource created");
        res.on('data', d => { process.stdout.write(d) })
    }
    else if (res.statusCode == 400) console.log("Error: code = 400 - Invalid input");
    else if (res.statusCode == 401) console.log("Error: code = 401 - Client ID or API key isn't active or invalid!");
    else if (res.statusCode == 402) console.log("Error: code = 402 - There are not enough funds on your account!");
    else if (res.statusCode == 403) console.log("Error: code = 403 - Account isn't activated. Please wait or contact to support!");
})

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

				
			
SMS for your applications

SMS integration in your app

A lot of applications already support SMS sending with LOX24 out of the box, e.g. Bitrix24, Theorg and Synology. And for everyone else, there’s our Zapier integration to connect with more than 5000 applications.

News & Insights

Current articles

More than 5000 customers from all over the world use our SMS service.

Our clients include multinational companies as well as microenterprises. companies from Germany and from all over the world. Private associations and public institutions. Each of our customers is close to our hearts.

A service that convinces

Latest ratings

Your Global SMS provider