Die zuverlässigste SMS API

SMS API für Ihre App

Die SMS API von LOX24 ist eine leistungsfähige und zuverlässige Lösung für den Versand und Empfang von SMS-Nachrichten. Mit der SMS API können Sie Ihre Anwendungen an das LOX24 SMS Gateway anbinden und SMS an Ihre Kunden, Partner oder Mitarbeiter weltweit versenden.

banner-img
LOX24

Eine bewährte SMS-API ohne Kopfschmerzen

Viele Schnittstellen und Sprachen

Wir bieten Ihnen verschiedene API Schnittstellen wie http/mail/soap/kannel für den SMS-Versand und SMS-Empfang. Codebeispiele für PHP, Go, Java, Ruby uvm.

Höchste Verfügbarkeit und Qualität

Durch mehrfache Redundanz garantieren wir eine Verfügbarkeit von 99,9% und einen Durchsatz von 10 SMS pro Sekunde. Unsere SMS kommen an und zwar sofort!

Günstige Preise ohne Fixkosten

Der SMS Versand ist bereits ab einem Cent je nach Land möglich und wir berechnen keine Grund- oder Einrichtungsgebühr. Es gibt keine versteckten Kosten.

Deutscher Datenschutz

Unsere Server befinden sich alle in Deutschland und wir sind bei der Bundesnetzagentur lizensiertes Telekommunikationsunternehmen.

Echtszeit-Statistiken

Sie erhalten Zustellberichte und haben jederzeit Zugriff auf Ihren Einzelverbindungsnachweis mit Daten zur Zustellquote. Sie können den Erfolg Ihrer Kampagne oder jeder einzelnen SMS sofort messen.

Sicherheit und Support

Der SMS Gateway ist "state of the art". Verschlüsselung und IP-Sperren sorgen dafür, dass unbefugte keinen Zugriff auf Ihre Daten haben. Unser Support steht Ihnen per Mail jederzeit zur Verfügung.

Die wichtigsten Daten

Die LOX24 SMS API

Ein SMS API ist eine Software-Schnittstelle, die es ermöglicht, automatisiert Kurznachrichten an Kunden oder andere Personen zu versenden. Eine SMS API verwendet dazu ein SMS-Gateway, um die Nachrichten zwischen dem Telekommunikationsnetz und dem Internet zu vermitteln.

Unsere SMS API ermöglicht den Massenversand von Textnachrichten, die Erstellung personalisierter Nachrichten, den automatischen Empfang von Antworten und die Verfolgung von Zustellberichten. Sicherheit und Datenschutz haben höchste Priorität.

Unsere SMS API ermöglicht eine einfache und schnelle Integration in Ihre bestehenden Systeme und Anwendungen. Wir bieten Ihnen eine klare mehrsprachige Dokumentation mit Codebeispielen, Hilfsbibliotheken und technischen Support.

Die LOX24 SMS API bietet hohe Verfügbarkeit, Skalierbarkeit und Performance. Wir garantieren eine extrem hohe Zustellrate, geringe Latenzzeiten, redundante Infrastruktur und Notfallmanagement.

Wir bieten ein transparentes und wettbewerbsfähiges Preismodell ohne Grundgebühr, Einrichtungsgebühr und Mindestumsatz. Außerdem bieten wir eine kostenlose Testversion, flexible Zahlungsoptionen, keine versteckten Gebühren und eine faire Abrechnung pro SMS.

Ihre App mit 880 Netzen weltweit verbinden

SMS API für jeden Anwendungszweck

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.

mobile-img

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.

mobile-img

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.

mobile-img

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.

mobile-img

SMS Support

Privatsphäre wahren

SMS sind diskreter als Telefonanrufe oder E-Mails, die leicht von anderen Personen eingesehen oder abgefangen werden können. SMS ermöglichen es den Nutzern, ihre Privatsphäre zu schützen und ihre Anliegen vertraulich zu behandeln.

Schnelle und sichere Übermittlung

SMS werden innerhalb von Sekunden gesendet und empfangen, ohne dass eine Internetverbindung erforderlich ist. SMS sind auch sicherer als andere Messaging-Dienste, die oft gehackt oder manipuliert werden können. SMS bieten eine verifizierte Kommunikation, da sie eindeutige Absender- und Empfängernummern verwenden, die nicht gefälscht werden können.

Einfache Bedienung und Kompatibilität

SMS sind einfach zu schreiben und zu lesen, ohne dass eine spezielle Anwendung heruntergeladen oder ein Konto eingerichtet werden muss. SMS funktionieren auf allen Mobiltelefonen, egal ob alt oder neu, und sind mit allen Betriebssystemen kompatibel.

mobile-img

Massen-SMS mit Tracking per Web und API versenden

Web-Interface mit Importfunktion

Versenden Sie Ihre Massen-SMS direkt über die Website mit Import Ihrer Nummern

Kurzlink-Kampagnen mit Tracking

Erfolgskontrolle mit Auswertung der Klickraten und wer auf Ihre Links geklickt hat

API für SMS-Marketing

Massen-SMS nicht nur über den Web-Account sondern auch mit unserer Schnittstelle

SMS Verteiler mit Opt-In/Out

SMS-Verteiler online pflegen und integrierte Opt-Out Funktion für Ihre SMS

mobile-img
Senden und Empfangen Sie SMS mit nur wenigen Zeilen Code

Unsere API ist kompatibel mit allen modernen Programmiersprachen

php-logo

Mit Hilfe von curl können Sie in PHP ganz einfach unsere HTTP Schnittstelle nutzen und SMS verschicken.

GO SMS

Mit Go werden io/ioutil und net/http importiert und schon können die Daten der SMS an die SMS-API übertragen werden.

python

Mit Python haben Sie eine Reihe von verschiedenen Möglichkeiten mit unserem SMS-Gateway zu interagieren. Sie könnenbeispielsweise urllib, Requests, Octopus oder HTTPie verwenden.

C# SMS

Die WebRequest.Create Methode übernimmt die Arbeit für Sie und überträgt die wichtigsten Daten Ihre SMS an unseren 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 für mehr als 6745 Anwendungen

SMS API auch ohne Programmierer

Sie möchten die Vorteile der LOX24 SMS-API für Ihr Unternehmen nutzen, haben aber keinen Programmierer, der Ihnen dabei helfen kann? Kein Problem. Wir haben die Lösung für Sie. Mit unserer Zapier-Integration können Sie Ihre Software ganz einfach und ohne Programmierkenntnisse an unsere API anbinden. Sie benötigen keine Unterstützung durch Ihre IT-Abteilung.

Mit unserer SMS-API-Lösung können Sie über Zapier mit mehr als 6.745 Anwendungen kommunizieren, die Sie für Ihr Geschäft nutzen. So können Sie Ihre Kommunikationsprozesse optimieren, Ihren Kundenservice verbessern und letztlich effektiv Zeit und Geld sparen.

Zapier und LOX24 SMS
News & Insights

Aktuelle Artikel

Your Global SMS provider