A2P SMS Provider da Europa para o mundo

Com a interface SMS do LOX24 A2P pode enviar SMS automáticos a partir da sua própria aplicação. O envio de SMS A2P via LOX24 é rápido, fiável e fácil de manusear.

O seu gateway mundial de SMS

SMS über den SMS Gateway versenden

Diferenças entre A2P, P2P e Enterprise SMS.

A2P SMS significa”Application-to-Person” SMS, ou seja, o envio de SMS a partir de um software para um utilizador normal. Normalmente, o software é uma aplicação que é operada por uma empresa. Esta aplicação envia SMS automaticamente para os telefones dos utilizadores finais. Estes podem ser clientes mas também empregados da empresa.

Exemplos:

  • Notificações da empresa de cartões de crédito sobre transacções
  • Confirmações de reserva
  • Lembretes de nomeação de médicos e workshops
  • Códigos de segurança ao entrar num website ou do banco antes de fazer um pagamento (2FA autenticação de dois factores)

A2P SMS também pode ser referido como Business SMS, ou em países anglófonos como Enterprise ou Professional SMS.

Isto está em contraste com o P2P SMS. Neste caso, o SMS não é enviado a partir de uma aplicação, mas sim de um telefone, de forma bastante clássica. Estes são, por exemplo, SMS privados ou também SMS comerciais não automatizados, para os quais, por exemplo, o assistente do médico tem de enviar à mão lembretes de marcação de consulta.

As suas vantagens

Porquê enviar A2P com LOX24?

Várias interfaces

Oferecemos várias interfaces API tais como http/mail/soap/kannel para envio e recepção de SMS.

Máxima disponibilidade

Através de redundância múltipla, garantimos uma disponibilidade de 99,9% e uma taxa de transmissão de 10 SMS por segundo.

Preços vantajosos sem custos fixos

Os SMS podem ser enviados a partir de apenas um cêntimo, dependendo do país, e não cobramos uma taxa de base ou de instalação.

Protecção de dados na Alemanha

Os nossos servidores estão todos localizados na Alemanha e somos uma empresa de telecomunicações licenciada com a Agência Federal de Redes.

Estatísticas e relatórios de entrega

Recebe relatórios de entrega e tem acesso à sua factura discriminada com os dados da taxa de entrega em qualquer altura.

Alta segurança

O SMS Gateway é "state of the art". A encriptação e o bloqueio de IP asseguram que pessoas não autorizadas não tenham acesso aos seus dados.

Envio de A2P SMS via interface

O nosso API é assim tão simples

Com a ajuda do encaracolamento pode facilmente utilizar a nossa interface HTTP em PHP e enviar SMS.

GO SMS

Com Go, io/ioutil e net/http são importados e os dados SMS podem ser transferidos para a API SMS.

Com Python tem várias formas diferentes de interagir com o nosso gateway de SMS. Por exemplo, pode utilizar urllib, Pedidos, Octopus ou HTTPie.

C# SMS

O método WebRequest.Create faz o trabalho por si e transfere os dados mais importantes dos seus SMS para a nossa porta de entrada.

				
					#!/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();

				
			

Temos a solução para as suas perguntas!

Claro que, como fornecedor alemão, estamos sujeitos à Regulamento Geral de Proteção de Dados e à Lei Alemã das Telecomunicações.

Naturalmente, pode registar-se connosco sem qualquer obrigação e receber 50 cêntimos de crédito de teste gratuito para o seu primeiro SMS.

Sim, apoiamos mais de 800 redes em todo o mundo. O preço dos SMS é muitas vezes até ligeiramente mais barato do que o dos SMS para a Europa.

Todos os nossos servidores estão localizados exclusivamente na Alemanha. Garantimos a segurança dos seus dados.

Não, pode cancelar a qualquer momento sem aviso prévio. Mas estamos certos de que ficará satisfeito connosco.

Serviços similares

Teste agora a API do SMS!

Integre hoje a nossa API de SMS na sua aplicação. Com 50 cêntimos de crédito gratuito, pode testar o gateway de SMS sem quaisquer obrigações.