Cómo enviar SMS a través de la API SMPP usando Python

El protocolo Short Message Peer-to-Peer (SMPP) API es ampliamente utilizado para intercambiar mensajes SMS entre entidades como ESMEs (Entidades Externas de Mensajes Cortos) y SMSCs (Centros de Servicio de Mensajes Cortos). Para los usuarios de la plataforma Ozeki SMS Gateway, entender las interacciones a nivel de protocolo SMPP es crucial para optimizar el rendimiento, depurar errores y realizar integraciones personalizadas. Esta guía explica las PDUs (Unidades de Datos de Protocolo) de SMPP necesarias para establecer, mantener y usar una conexión SMPP API para enviar mensajes SMS, con ejemplos prácticos en Python.

Cómo enviar SMS a través de la API SMPP usando Python (Pasos rápidos)

1. Verifica las credenciales SMPP
2. Escribe y ejecuta el script en Python
3. Verifica el resultado

Cómo enviar SMS a través de la API SMPP usando Python (Tutorial en video)

En este video, aprenderás cómo enviar mensajes SMS usando Python a través de la API SMPP con Ozeki SMS Gateway. El tutorial muestra cómo configurar un usuario SMPP, conectarse usando la biblioteca smpplib y enviar un SMS con unas pocas líneas de código. También verás cómo mantener la conexión activa y manejar informes de entrega. Al final, tendrás un script en Python funcional listo para enviar mensajes SMS vía SMPP.

Paso 1 - Seleccionar usuario SMPP

En la interfaz de Ozeki SMS Gateway, ve a la sección "Usuarios y aplicaciones" y selecciona el usuario SMPP previamente creado. Este usuario es necesario para establecer la conexión SMPP desde Python.

Paso 2 - Detalles de conexión

Después de seleccionar el usuario SMPP, ve a la pestaña "Ayuda" y verás los detalles de conexión como dirección IP, número de puerto, nombre de usuario y contraseña. Estos valores se usarán en tu código Python para conectarte al SMS Gateway.

Paso 3 - Pegar el código Python

Abre tu IDE o editor de Python y pega el código de conexión SMPP del "Ejemplo completo de cliente Python SMPP API para enviar SMS" usando la biblioteca smpplib. Este código inicia la conexión y prepara el entorno para enviar SMS.

Paso 4 - Reemplazar datos

Actualiza los valores de marcador de posición en el código con tus credenciales SMPP reales (host, puerto, nombre de usuario, contraseña) y los números de teléfono que deseas usar para enviar mensajes.

Paso 5 - Éxito

Ejecuta el script. Si todo está configurado correctamente, en la interfaz de Ozeki SMS Gateway, el smpp_user creado mostrará en el registro que fue exitoso, confirmando que la conexión está activa y lista para enviar mensajes.

Cómo establecer una conexión SMPP API en Python para mensajería SMS

Para enviar SMS a través de la API SMPP, primero debes servidor SMPP de Ozeki SMS Gateway. Aquí se explica cómo hacerlo en Python usando la biblioteca smpplib:

import smpplib

# Parámetros de conexión
HOST = 'tu.servidor.ozeki'
PORT = 2775
SYSTEM_ID = 'tu_usuario'
PASSWORD = 'tu_contraseña'

# Crear cliente
client = smpplib.client.Client(HOST, PORT)

# Vincular como transmisor
client.connect()
client.bind_transmitter(
    system_id=SYSTEM_ID,
    password=PASSWORD,
)

print("Vinculación exitosa al servidor SMPP")

PDUs clave para la configuración de conexión

Mantener una conexión SMPP API estable en Python para enviar SMS

Las conexiones SMPP requieren señales periódicas de keep-alive para evitar tiempos de espera. Aquí se explica cómo implementarlo en Python:

import time
import threading

def send_enquire_link():
    while True:
        try:
            client.enquire_link()
            print("PDU enquire_link enviada")
        except Exception as e:
            print(f"Error al enviar enquire_link: {e}")
        time.sleep(30)  # Enviar cada 30 segundos

# Iniciar hilo keep-alive
keepalive_thread = threading.Thread(target=send_enquire_link)
keepalive_thread.daemon = True
keepalive_thread.start()

Enviar SMS con Python a través de la API SMPP

Aquí hay un ejemplo completo de cómo enviar un SMS y manejar la respuesta:

def send_sms(source_addr, destination_addr, message):
    try:
        # Enviar PDU submit_sm
        pdu = client.send_message(
            source_addr_ton=smpplib.consts.SMPP_TON_INTL,
            source_addr_npi=smpplib.consts.SMPP_NPI_ISDN,
            source_addr=source_addr,
            dest_addr_ton=smpplib.consts.SMPP_TON_INTL,
            dest_addr_npi=smpplib.consts.SMPP_NPI_ISDN,
            destination_addr=destination_addr,
            short_message=message,
            data_coding=0x00,  # Codificación GSM 7-bit
        )
        
        print(f"Mensaje enviado, ID del mensaje: {pdu.message_id}")
        
    except smpplib.exceptions.PDUError as e:
        print(f"Error PDU: {e}")
    except Exception as e:
        print(f"Error al enviar SMS: {e}")

# Ejemplo de uso
send_sms(
    source_addr="12345",
    destination_addr="+1234567890",
    message="¡Hola desde el cliente SMPP en Python!"
)

Manejo de informes de entrega

Para recibir informes de entrega en Python:

def handle_delivery_report(pdu):
    print(f"Informe de entrega recibido para el mensaje {pdu.receipted_message_id}")
    print(f"Estado: {pdu.message_state}")

# Configurar manejador de informes de entrega
client.set_message_received_handler(lambda pdu: handle_delivery_report(pdu))

Ejemplo completo de cliente Python SMPP API para enviar SMS

Aquí hay un ejemplo completo funcional:

import smpplib
import threading
import time

class SMPPClient:
    def __init__(self, host, port, system_id, password):
        self.client = smpplib.client.Client(host, port)
        self.client.set_message_received_handler(self.handle_message)
        
        # Vincular al servidor
        self.client.connect()
        self.client.bind_transceiver(
            system_id=system_id,
            password=password,
        )
        
        # Iniciar keep-alive
        self.start_keepalive()
    
    def start_keepalive(self):
        def _keepalive():
            while True:
                try:
                    self.client.enquire_link()
                except Exception:
                    try:
                        self.client.connect()
                        self.client.bind_transceiver(
                            system_id=SYSTEM_ID,
                            password=PASSWORD,
                        )
                    except Exception as e:
                        print(f"Error de reconexión: {e}")
                time.sleep(30)
        
        thread = threading.Thread(target=_keepalive)
        thread.daemon = True
        thread.start()
    
    def send_sms(self, from_addr, to_addr, message):
        try:
            return self.client.send_message(
                source_addr=from_addr,
                destination_addr=to_addr,
                short_message=message,
            )
        except Exception as e:
            print(f"Error al enviar: {e}")
            return None
    
    def handle_message(self, pdu):
        if pdu.command == "deliver_sm":
            print(f"Informe de entrega: {pdu.receipted_message_id} - {pdu.message_state}")
        else:
            print(f"Mensaje recibido: {pdu.short_message}")

# Uso
if __name__ == "__main__":
    client = SMPPClient(
        host="tu.servidor.ozeki",
        port=2775,
        system_id="tu_usuario",
        password="tu_contraseña"
    )
    
    # Enviar un mensaje
    client.send_sms(
        from_addr="12345",
        to_addr="+1234567890",
        message="¡Hola desde el cliente SMPP en Python completo!"
    )
    
    # Mantener en ejecución
    while True:
        time.sleep(1)

Conclusión

Esta guía te ha mostrado cómo trabajar con la API SMPP a nivel de protocolo usando Python. Implementando estos ejemplos con Ozeki SMS Gateway, puedes construir aplicaciones SMS robustas con características como gestión de conexión, envío de mensajes y manejo de informes de entrega. La biblioteca smpplib proporciona una forma conveniente de trabajar con PDUs SMPP mientras maneja los detalles de bajo nivel del protocolo por ti.

Recuerda manejar las excepciones adecuadamente en código de producción e implementar lógica de reconexión para máxima confiabilidad. El ejemplo completo incluye manejo básico de reconexión y funcionalidad keep-alive.