The low-cost SMS API

The SMS API for your app

The SMS API from LOX24 is a powerful and reliable solution for sending and receiving SMS messages. With the SMS API you can connect your applications to the LOX24 SMS Gateway and send SMS to your customers, partners or employees worldwide.


A proven SMS API without the headaches

Many interfaces and languages

We offer various API interfaces such as rest/http/mail/soap/kannel for SMS sending and receiving. Code examples for PHP, Go, Java, Ruby and many more.

Highest availability and quality

Through multiple redundancy, we guarantee 99.9% availability and a throughput of at least 10 SMS per second. Our text messages arrive immediately!

Favorable prices without fixed costs

Sending SMS is possible from as little as one cent depending on the country and we do not charge any basic or setup fee. There are no hidden costs.

European data protection

Our servers are all located in Germany and we are a telecommunications company licensed with the German Federal Network Agency.

Real-time statistics

You receive delivery reports and have access to your itemized bill with delivery rate data at any time. You can immediately measure the success of your campaign or each individual SMS.

Security and support

The SMS gateway is "state of the art". Encryption and IP blocking ensure that unauthorized persons cannot access your data. Our support is available to you by e-mail at any time.

The most important data


An SMS API is a software interface that makes it possible to send automated short messages to customers or other people. An SMS API uses an SMS gateway to transmit messages between the telecommunications network and the Internet.

Our SMS API allows you to send bulk text messages, create personalized messages, automatically receive replies and track delivery reports. Security and data protection have top priority.

Our SMS API enables quick and easy integration into your existing systems and applications. We offer you clear multilingual documentation with code examples, help libraries and technical support.

The LOX24 SMS API offers high availability, scalability and performance. We guarantee an extremely high delivery rate, low latency, redundant infrastructure and emergency management.

We offer a transparent and competitive pricing model with no basic fee, set-up fee or minimum turnover. We also offer a free trial, flexible payment options, no hidden fees and fair billing per SMS.

Connect your app to 880 networks worldwide

SMS API for every application

SMS Verifzierung

Einfache Integration und Skalierung

SMS können über eine REST-SMS-API nahtlos in Anmelde- oder Login-Prozesse integriert werden. SMS bieten auch eine einfache und schnelle Skalierbarkeit durch lokales Know-how und eine tiefe Integration mit den Netzbetreibern.

Hohe Netzabdeckung und Erreichbarkeit

SMS können praktisch jeden erreichen, unabhängig von seinem Standort, seinem Gerät oder seiner Internetverbindung. SMS benötigen nur ein kurzes Empfangssignal, um gesendet oder empfangen zu werden.

Einfache Handhabung

SMS sind einfacher als andere Messaging-Dienste, was Ihren Kundendienst entlastet. Daneben können Sie die Verifizierung mit Zapier oder Auth0 auch ganz ohne Programmierer nutzen.


SMS in der Gesundheit

Erreichbarkeit und den Informationsfluss

SMS können die Erreichbarkeit und den Informationsfluss zwischen Ärzten, Patienten und anderen Leistungserbringern im Gesundheitswesen verbessern. Zum Beispiel können Ärzte SMS nutzen, um Termine zu bestätigen oder zu erinnern, Befunde oder Rezepte zu übermitteln oder Patienten über wichtige Gesundheitsfragen zu informieren.

Effizienz und die Qualität

SMS können die Effizienz und Qualität der Gesundheitsversorgung verbessern, indem sie Wartezeiten verkürzen, die Auslastung optimieren und die Therapietreue fördern. Zum Beispiel können Ärzte SMS nutzen, um Patienten an die Einnahme von Medikamenten oder die Durchführung von Selbsttests zu erinnern oder um Feedback oder Umfragen zur Patientenzufriedenheit einzuholen.

Kosten senken

SMS können die Kosten des Gesundheitswesens senken, indem sie die Zahl versäumter Termine, unnötiger Besuche oder vermeidbarer Komplikationen verringern. Ärzte können SMS beispielsweise nutzen, um Patienten über die Verfügbarkeit von Impfungen oder Präventionsmaßnahmen zu informieren oder um Patienten mit chronischen Erkrankungen zu überwachen und zu beraten.


SMS Logistik

Schnelle und zuverlässige Benachrichtigung

SMS können verwendet werden, um LKW-Fahrer über Zeit, Ort und Anforderungen ihrer Lieferungen zu informieren. SMS werden innerhalb von Sekunden gesendet und empfangen, ohne dass eine Internetverbindung erforderlich ist. SMS haben eine hohe Öffnungsrate von 95 Prozent innerhalb von drei Minuten.

Einfache Bestätigung und Rückmeldung

SMS können verwendet werden, um die Zustellung zu bestätigen, Fragen zu klären oder Probleme zu melden. SMS sind einfach zu schreiben und zu lesen, ohne dass eine spezielle Anwendung oder ein Konto erforderlich ist. SMS können auch automatische Antworten oder Funktionen wie Umfragen oder Abstimmungen enthalten.

Kosteneffizienz und Skalierbarkeit

SMS können verwendet werden, um mehrere Lkw-Fahrer gleichzeitig zu erreichen, ohne hohe Kosten zu verursachen. SMS bietet ein transparentes und wettbewerbsfähiges Preismodell, das auf der Anzahl der versendeten Nachrichten basiert. SMS bietet auch eine einfache und schnelle Skalierbarkeit zur Anpassung an den Kommunikationsbedarf.




SMS ist eine weit verbreitete Technologie, die von den meisten Mobiltelefonen unterstützt wird. Dies bedeutet, dass SMS-basierte MMK-Anwendungen ein breites Publikum erreichen können.

Kostengünstig und Effizient

SMS-Nachrichten sind im Allgemeinen sehr kostengünstig, was sie zu einer erschwinglichen Option für MMK-Anwendungen macht. SMS-Nachrichten können schnell und einfach gesendet und empfangen werden, was sie zu einem effizienten Mittel für die Kommunikation mit Kunden oder Benutzern macht.

Nachverfolgbarkeit und Sicherheit

SMS-Nachrichten können verfolgt werden, um sicherzustellen, dass sie erfolgreich zugestellt wurden. Außerdem ist eine verschlüsselte Übertragung möglich und die Überprüfung des Absenders.


SMS support

Have a conversation with your customers via SMS. Use the direct line to communicate with your customers via SMS. You yourself can integrate the communication into your normal support application. For example, have your customers respond to appointment reminders or status messages and receive that response directly in your normal mail help desk.

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 and receive SMS with just a few lines of code

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.


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.


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 \
  -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"


$uri = '';

$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,
        "X-LOX24-AUTH-TOKEN: {$token}",
        'Accept: application/json', // or application/ld+json
        'Content-Type: application/json',

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

$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 (

func main() {

	const Method = "POST"
	const URL = ""
	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 {

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

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

	defer res.Body.Close()

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {

	switch res.StatusCode {
	case 201:
	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!")
		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 = "";

            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()))
                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");
                    case HttpStatusCode.Unauthorized: // 401
                        Console.WriteLine("Error:401 Client ID or API key isn't active or invalid!");
                    case HttpStatusCode.PaymentRequired: // 402
                        Console.WriteLine("Error:402 There are not enough funds on your account!");
                    case HttpStatusCode.Forbidden: // 403
                        Console.WriteLine("Error:403 Account isn't activated. Please wait or contact to support!");
                    case HttpStatusCode.NotFound: // 404
                        Console.WriteLine("Error:404 Resource not found");
                    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!");

					import json
import requests

token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx"

url = ''

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))

    # timeout is 100 seconds, the payload is automatically converted to json format
    res =, headers=headers, json=data, timeout=100)
    if res.status_code != 201: # Created
        print("Error: Wrong response code on create sms")
        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!")
        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.time.Duration;

public class PostSmsCollection {

    public static void main(String[] args) {

        var key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";
        var url = "";

        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))
                .setHeader("Content-Type", "application/json; charset=utf-8")
                .setHeader("Accept", "application/json") // or application/ld+json
                .setHeader("X-LOX24-AUTH-TOKEN", key)

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

        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");
                    case HttpURLConnection.HTTP_UNAUTHORIZED: // 401
                        System.out.println("Error:401 Client ID or API key isn't active or invalid!");
                    case HttpURLConnection.HTTP_PAYMENT_REQUIRED: // 402
                        System.out.println("Error:402 There are not enough funds on your account!");
                    case HttpURLConnection.HTTP_FORBIDDEN: // 403
                        System.out.println("Error:403 Account isn't activated. Please wait or contact to support!");
                    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!");


        } catch (IOException | InterruptedException e) {

 * 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: '',
    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 => {

SMS API for your applications

SMS integration in your app

Would you like to take advantage of the LOX24 SMS API for your company, but don’t have a programmer who can help you? No problem. We have the solution for you. With our Zapier integration, you can easily connect your software to our API without any programming knowledge. You do not need any support from your IT department.

With our SMS API solution, you can communicate via Zapier with more than 6,745 applications that you use for your business. This allows you to optimize your communication processes, improve your customer service and ultimately save time and money.

Zapier und LOX24 SMS
News & Insights

Current articles

Your Global SMS provider