With LOX24's filter functions you can limit your costs and protect yourself against attacks and malfunctions. It is an insurance for your SMS dispatch, no matter if you send your SMS via API or another gateway.
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.
LOX24
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
The LOX24 SMS API
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 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
- Verification
- Health
- Logistics
- Man-machine
- Support
- Marketing
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 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.
Mensch-Maschine-Kommunikation
Verfügbarkeit
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 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
Send and receive SMS with just a few lines of code
Our API is compatible with all modern programming languages
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.
- curl
- php
- go
- c#
- python
- java
- javascript
#!/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"
}'
'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 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.
News & Insights
Current articles
Follow these steps to send SMS and voice notifications in Symfony. Integrating SMS notifications into your Symfony application can significantly improve user experience and engagement.
With Mail2SMS you can send SMS directly by e-mail without the need for any technical knowledge. A mail SMS gateway is a service that converts e-mails into SMS and forwards them to the desired recipients.
LOX24 SMS integrates seamlessly with RSA SecurID, a leading identity and access management platform, providing a secure and convenient way to verify users via SMS.
You can send SMS with the PowerShell. Simply use the SMS API interface from LOX24. In this article, we show you how to do it.
Text messages are an effective way of reaching your customers and increasing sales.