Die Filterfunktionen von LOX24 ermöglichen Ihre Kosten zu deckeln und sich vor Angriffen und Fehlfunktionen zu schützen. Es handelt sich um eine Versicherung für Ihren SMS Versand, egal ob Sie Ihre SMS per API verschicken oder über einen anderen Gateway.
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.

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
-
Verifzierung
-
Gesundheit
-
Logistik
-
Mensch-Maschine
-
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
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.
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
Senden und Empfangen Sie SMS weltweit und unkomplizert über unseren SMS Gateway
Modernste REST-API
SSL verschlüsselte HTTP API für den Einzel- und Massen-SMS
Verschiedene Schnittstellen
Versand und Empfang von SMS
Senden Sie SMS, empfangen Sie eingehende Nachrichten und Zustellberichte
99,9% Verfügbarkeit und 24/7 Mail Support
Versenden Sie Ihre SMS weltweit sicher und in wenigen Sekunden
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
Terminerinnerungen und Bestätigungen per SMS verschicken
Integration für den Google Kalender
Senden Sie Ihre SMS Erinnerungen direkt aus Ihrem Google Kalender
Integration für Outlook 365
Ab Outlook 2010 senden Sie mit unserem Plugin ebenfalls SMS Erinnerungen
Bestätigungen und Erinnerungen
Senden Sie nicht nur Terminerinnerungen, sondern auch Bestätigungen
Dynamische Textvorlagen
Lassen Sie in Ihre SMS-Texte automatisch Daten aus dem Kalendereintrag einfügen
SMS direkt aus Outlook versenden
Plugin mit hoher Kompatibilität
Senden Sie aus Outlook 2010 und allen neueren Version inkl. Outlook 365
Zugriff auf das Adressbuch
Nutzen Sie das gewohnte Outlook Adressbuch um Ihre SMS zu versenden
Textvorlagen und Signaturen
Erleichtern Sie sich die Arbeit mit Textvorlagen für Ihre SMS-Texte
Terminerinnerungen aus dem Kalender
Senden Sie bei Bedarf auch SMS direkt aus dem Outlook Kalender
Zwei-Faktor-Authentifizierung per SMS und Sprachanruf
Erhöhen Sie die Sicherheit Ihrer Systeme mit 2FA
Ein weiterer Faktor per SMS oder Sprachanruf steigert die Sicherheit Ihres Login
Sprachanrufe und SMS mit einer Schnittstelle
Senden Sie über die gleiche API Verifizierungscodes per SMS und Sprachanruf
Weltweite Verfügbarkeit
Alle Netze weltweit werden abgedeckt auch im Roaming
Deutscher Datenschutz
Ihre Pins können zur Sicherheit direkt nach der Übermittlung gelöscht werden
Betrugsprävention mit Scoring
Höhere Sicherheit bei Online Transaktionen
Ob Bestellungen oder Login, unser System erkennt Betrüger zuverlässig
Problematische Kunden indentifizieren
Erkennen Sie Nutzer von anonymen VPNs oder falsche Daten mit unserer API
Scoring und Detailinformationen
Unser Scoring gibt Ihnen einen Gesamteindruck ergänzt mit weiteren Daten
Deutscher Datenschutz
Unser Dienst ist DGSVO kompatibel mit deutschem Standort
Senden und Empfangen Sie SMS mit nur wenigen Zeilen Code
Unsere API ist kompatibel mit allen modernen Programmiersprachen
Mit Hilfe von curl können Sie in PHP ganz einfach unsere HTTP Schnittstelle nutzen und SMS verschicken.
Mit Go werden io/ioutil und net/http importiert und schon können die Daten der SMS an die SMS-API übertragen werden.
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.
Die WebRequest.Create Methode übernimmt die Arbeit für Sie und überträgt die wichtigsten Daten Ihre SMS an unseren 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 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.
News & Insights
Aktuelle Artikel
Folgen Sie diesen Schritten, um SMS- und Sprachbenachrichtigungen in Symfony zu versenden. Die Integration von SMS-Benachrichtigungen in Ihre Symfony-Anwendung kann die Benutzerfreundlichkeit und das Engagement erheblich verbessern.
Per Mail2SMS senden Sie SMS direkt per E-Mail, ohne dass technische Kenntnisse erforderlich sind . Ein Mail SMS-Gateway ist ein Dienst, der E-Mails in SMS umwandelt und an die gewünschten Empfänger weiterleitet.
LOX24 SMS lässt sich nahtlos in RSA SecurID, eine führende Plattform für Identitäts- und Zugangsmanagement, integrieren und bietet so eine sichere und bequeme Möglichkeit Benutzer per SMS zu verifizieren.
Mit der PowerShell können Sie SMS versenden. Nutzen Sie dazu einfach die SMS API Schnittstelle von LOX24. In diesem Artikel zeigen wir Ihnen, wie es geht.
Textnachrichten sind ein wirksames Mittel, um Ihre Kunden zu erreichen und den Umsatz zu steigern.