Desde: 03-Mar-2023
Hasta 09-Sep-2023
Modo Remoto

Como enviar y recibir sms usando Twilio

Omar Giancarlo

Descripción Corta:

Descubre cómo lograr el envío y recepción de SMS a Twilio. Configura la integración y envía mensajes de texto fácilmente en tus aplicaciones.

Demo
Código
Anterior Siguiente

Para lograr el envío y recepción de SMS a través de Twilio, es necesario tener Node.js instalado como servidor local para enviar los datos del mensaje, como el número y el cuerpo del texto, a un servicio en la nube y obtener una respuesta.

¿Qué es un SMS?

SMS son las siglas de Short Message Service, que en español significa “Servicio de Mensajes Cortos”. Es un servicio de comunicación que permite enviar y recibir mensajes de texto de hasta 160 caracteres a través de dispositivos móviles, como teléfonos celulares o a plataformas como Twilio. Es una forma rápida y económica de enviar información breve y relevante a un destinatario específico. A menudo se utiliza para enviar mensajes de texto, de texto, de verificación de dos factores, alertas de seguridad, notificaciones y mensajes de marketing, entre otros usos.

¿Qué es Twilio?

Twilio es una plataforma en la nube que permite a los desarrolladores integrar comunicaciones (como mensajes de texto, llamadas y video) en sus aplicaciones mediante API. Twilio proporciona una infraestructura escalable y segura para enviar y recibir mensajes de texto y realizar y recibir llamadas telefónicas en todo el mundo. Los desarrolladores pueden utilizar Twilio para agregar capacidades de comunicación a sus aplicaciones sin tener que construir toda la infraestructura subyacente por sí mismos. Además, Twilio ofrece herramientas para rastrear y analizar el uso de las comunicaciones en sus aplicaciones, lo que puede ayudar a los desarrolladores a mejorar la experiencia del usuario y hacer crecer su negocio. En resumen, Twilio es una plataforma que permite el envío y recepción de SMS, una forma rápida y económica de comunicación a través de dispositivos móviles. Puedes integrar Twilio para enviar y recibir SMS en tus aplicaciones.

Ahora que tenemos una idea general de que es cada cosa. Como dijimos en la introducción, el objetivo final es crear una simple aplicación que permita enviar y recibir mensajes SMS usando la plataforma de Twilio.

Para hacer esto utilizaré los servicios de Twilio. Explicaré los pasos que se debería seguir para lograrlo:

  1. Crear una cuenta en Twilio.
  2. Configurar el número de Twilio para enviar SMS.
  3. Ejecutar Node.js
  4. Configura la API de Twilio
  5. Instalar Express para Node.js.
  6. Crear un webhook en Twilio.

Para desarrollar el webhook que recibiría los mensajes SMS de Twilio, deberás crear una aplicación Node.js que exponga una URL a la que Twilio enviará los mensajes. En esta aplicación, utilizarás la librería de Twilio para recibir y procesar los mensajes de texto que lleguen al webhook.

Es importante que tengas una comprensión general de los conceptos de API y webhook, y que tengas una cuenta de Twilio configurada previamente. También es recomendable que estés familiarizado con los protocolos HTTP y HTTPS y con la gestión de peticiones y respuestas.

Crear una cuenta en Twilio

Para poder enviar y recibir SMS a través de Twilio, primero necesitas crear una cuenta en su plataforma y obtener un número de teléfono de Twilio. Para hacer esto primero debes registrarte y seguir los pasos que te va indicando Twilio.

Configurar el número de Twilio para enviar SMS

Una vez que hayas creado una cuenta en Twilio, deberás obtener un número de teléfono que permitirá enviar y recibir SMS en Twilio. Puedes hacerlo desde el panel de control de Twilio. En el momento que estoy creando este tutorial, Twilio está ofreciendo una versión gratis para envío y recepción de SMS, con un número de teléfono que ellos te asignan, sin embargo, para personalizar ese número tendremos que pagar por un número de teléfono propio.

Ejecutar Node.js

Para iniciar proyectos de Node.js y configurar el envío y recepción de SMS en Twilio. Sigue los siguientes pasos:

  1. Abre una terminal o línea de comandos: Para iniciar un proyecto de Node.js, deberás utilizar una terminal o línea de comandos. En Windows, puedes abrir la terminal utilizando el comando cmd en el menú de inicio. En mi caso estoy usando la terminal de VSC.
  2. Crea un nuevo directorio: Por ejemplo, puedes utilizar el comando mkdir mi-proyecto para crear un directorio llamado “mi-proyecto” o el nombre que ustedes le quieran poner.
  3. Inicia un nuevo proyecto de Node.js: Una vez que hayas creado el directorio, deberás inicializar un nuevo proyecto de Node.js utilizando el comando npm init. Este comando te guiará a través de la creación del archivo package.json, que es el archivo de configuración para tu proyecto.

Ejecuta la aplicación Node.js: Una vez que te encuentres en el directorio de tu proyecto, podrás ejecutar tu aplicación Node.js utilizando el comando node seguido del nombre del archivo que contiene tu aplicación. Por ejemplo, si tu aplicación se encuentra en el archivo index.js, puedes utilizar el comando node index.js para ejecutarla.

En index.js escribo console.log(‘Hola desde Node’), simplemente para verificar que todo esté configurado correctamente.

console.log('Hola desde Node')

Si todo está correctamente configurado, deberías ver el mensaje por consola que escribiste en index.js.

Instalar Express para Node.js

Este comando instalará la última versión de Express y sus dependencias en tu proyecto.

npm install express

Para definir la URL de tu aplicación que procesará los mensajes recibidos, debes crear un servidor HTTP utilizando Express y definir una ruta para procesar los mensajes de Twilio. Para asignar un puerto a tu aplicación, puedes especificar el número del puerto en el código de tu servidor HTTP. Por ejemplo, si deseas asignar el puerto 3000, puedes agregar el siguiente código en tu archivo index.js.

En este ejemplo, hemos creado un servidor HTTP en el puerto 3000 y hemos definido una ruta ‘/message’ que procesará los mensajes de Twilio. También hemos agregado un middleware para manejar el cuerpo de la solicitud POST.

const express = require('express');
const app = express();

app.set('port', process.env.PORT || 3000);

app.listen(app.get('port'), () => {
  console.log('Servidor esta en el puerto...', app.get('port'));
});

La línea de código app.set('port', process.env.PORT || 3000); en Express establece la variable port en el objeto app con un valor que se obtiene de la variable de entorno process.env.PORT.

La variable de entorno process.env.PORT es proporcionada por el sistema operativo o el proveedor de alojamiento web y se utiliza para indicar en qué puerto debe ejecutarse la aplicación.

Si la variable de entorno process.env.PORT no está definida, entonces el valor del puerto se establecerá en 3000.

Configura la API de Twilio

Para poder utilizar la API de Twilio en tu aplicación Node.js, deberás instalar la librería de Twilio para Node.js. Puedes hacerlo utilizando el comando npm install twilio en tu terminal.

npm install twilio

Para enviar un SMS a través de Twilio, necesitarás utilizar la API de Twilio. Para ello, deberás crear una instancia de la API de Twilio en tu aplicación Node.js utilizando el siguiente código:

const accountSid = 'TU_ACCOUNT_SID';
const authToken = 'TU_AUTH_TOKEN';
const client = require('twilio')(accountSid, authToken);

Reemplaza TU_ACCOUNT_SID y TU_AUTH_TOKEN con los valores correspondientes que encuentras en el panel de control de Twilio.

El código que se utiliza crea una instancia de la API de Twilio en tu aplicación Node.js. Básicamente, lo que esta haciendo es proporcionar las credenciales de Twilio (tu Account SID y tu Auth Token) para autenticarte y conectarte a la plataforma Twilio.

  • const accountSid = 'TU_ACCOUNT_SID'; Esta línea de código crea una constante llamada accountSid y le asigna el valor de tu Account SID de Twilio. El Account SID es una cadena de caracteres única que identifica tu cuenta de Twilio.
  • const authToken = 'TU_AUTH_TOKEN'; Esta línea de código crea una constante llamada authToken y le asigna el valor de tu Auth Token de Twilio. El Auth Token es una cadena de caracteres secreta que te permite autenticarte y conectarte a la plataforma Twilio.
  • const client = require('twilio')(accountSid, authToken); Esta línea de código crea una instancia de la API de Twilio utilizando tus credenciales de Twilio. La función require('twilio') importa la librería de Twilio que instalaste previamente, y le pasa tus credenciales de Twilio como parámetros para autenticar y conectar la instancia de la API de Twilio.

Con esta instancia de la API de Twilio, podrás utilizar los diferentes métodos y funciones proporcionados por Twilio para enviar mensajes SMS.

Una instancia en JavaScript se refiere a un objeto que ha sido creado a partir de una clase. En términos simples, una clase es como un plano o un molde que describe cómo debe ser un objeto. Una vez que tienes la clase, puedes crear objetos a partir de ella, que se conocen como instancias.

El uso de la instancia de la clase Twilio es fundamental para el envío y recepción de SMS a Twilio a través de su API. El objeto creado a partir de la clase Twilio nos permite interactuar con la plataforma mediante el uso de sus métodos y funciones.

Una vez que hayas configurado la API de Twilio, podrás enviar un SMS utilizando el método messages.create() de la instancia del cliente de Twilio. El siguiente código muestra un ejemplo de cómo enviar un mensaje de texto:

client.messages.create({
    body: 'Mensaje de prueba enviado a través de Twilio',
    from: 'TU_NUMERO_DE_TWILIO',
    to: 'EL_NUMERO_DE_DESTINO'
})
.then(message => console.log(message.sid))
.catch(error => console.error(error));

Reemplaza TU_NUMERO_DE_TWILIO y EL_NUMERO_DE_DESTINO con los números correspondientes.

Este código utiliza el método create() del objeto messages de la instancia del cliente de Twilio para enviar un SMS.

El método create() toma un objeto que especifica el cuerpo del mensaje, el número desde el cual se enviará el mensaje (from), y el número al cual se enviará el mensaje (to).

  • body: Es el cuerpo del mensaje que se desea enviar.
  • from: Es el número de Twilio desde el cual se enviará el mensaje. Este número es el que se te asignó cuando creaste tu cuenta de Twilio.
  • to: Es el número de teléfono al cual se enviará el mensaje.

Una vez que se han especificado los detalles del mensaje que se desea enviar, el método create() devuelve una promesa. La promesa se resuelve con un objeto message que contiene información sobre el mensaje que se envió, como el ID del mensaje (sid).

Finalmente, el código utiliza un then() para mostrar el ID del mensaje por consola si el envío fue exitoso, y un catch() para manejar cualquier error que pueda ocurrir durante el envío del mensaje.

Siguiendo estos pasos, podríamos enviar un SMS a través de Twilio utilizando Node.js. Sin embargo, me he encontrado con algunas complicaciones al momento de intentar conectar con la API de Twilio que a continuación las mensionaré.

Me arroja el siguiente error: SyntaxError: Unexpected token '.'

En una parte de este tutorial mensiono la version de node.js que estoy usando y mi sistema operativo. Bueno el error viene por ese lado que a continuación detallo.

SyntaxError: Unexpected token '.'
←[90m    at wrapSafe (internal/modules/cjs/loader.js:1060:16)←[39m
←[90m    at Module._compile (internal/modules/cjs/loader.js:1108:27)←[39m
←[90m    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1164:10)←[39m
←[90m    at Module.load (internal/modules/cjs/loader.js:993:32)←[39m
←[90m    at Function.Module._load (internal/modules/cjs/loader.js:892:14)←[39m
←[90m    at Module.require (internal/modules/cjs/loader.js:1033:19)←[39m
←[90m    at require (internal/modules/cjs/helpers.js:72:18)←[39m
    at Object.<anonymous> (F:\NODEJS PROYECTOS\SmsToWhatsapp\node_modules\←[4mtwilio←[24m\lib\index.js:28:34)
←[90m    at Module._compile (internal/modules/cjs/loader.js:1144:30)←[39m
←[90m    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1164:10)←[39m

El error indica que hay un token inesperado, específicamente el operador de opción nula (?.) que se usa en la línea 34 del archivo Twilio.js dentro del módulo twilio.

Este operador se introdujo en la versión de JavaScript ES2020, entonces la versión de Node.js no lo está reconociendo. Para solucionarlo, podría actualizar a una versión más reciente de Node.js. Por ejemplo, la versión 16.x que tenga soporte para ES2020. Sin embargo, en mi caso no puedo actualizar la versión de node.js por mi sistema operativo.

Si no puedes actualizar la versión de Node.js, podrías intentar eliminar el operador de opción nula (?.) de la línea 34 del archivo Twilio.js manualmente, Pero decido cambiar la versión de twilio por una versión anterior que no use este operador. Para cambiar la versión, ejecuto el siguiente comando en la terminal:

npm install twilio@3.60.0

Esto instalará la versión 3.60.0 de twilio, que es una versión anterior que no usa el operador de opción nula (?.). Y esta es la opción que escogí, dependiendo el caso ustedes van a escoger o una u otra.

Ahora si, en este punto ya pude enviar un SMS a través de Twilio.

Crear un webhook en Twilio

Un webhook es una URL a la que Twilio enviará los mensajes de texto que reciba en tu número de teléfono. Debes crear un webhook en Twilio que apunte a una URL de tu aplicación que procesará los mensajes recibidos. Es decir, cuando alguien envíe un mensaje de texto al número de teléfono que has asignado en Twilio, Twilio enviará automáticamente una solicitud HTTP POST a la URL que hayas especificado como webhook.

Una vez que hayas definido la ruta en tu aplicación con Express, puedes ingresar la URL completa de la ruta en el campo de texto al lado de la URL en la sección “A message comes in” en Twilio. Por ejemplo, si tu aplicación está alojada en tu computadora local en el puerto 3000 y tu ruta para procesar los mensajes es ‘/message’, la URL completa sería 'http://localhost:3000/message'.

Ojo acá, ya que Twilio solo permite agregar la URL, 'https://demo.twilio.com/welcome/sms/reply/', entonces tendrás que usar una herramienta externa para hacer un túnel y hacer accesible tu aplicación local en la web. Esto se debe a que Twilio no puede enviar mensajes a un servidor local que no sea accesible desde la web.

Una herramienta popular para hacer esto es Ngrok. Ngrok crea un túnel seguro a tu servidor local y te proporciona una URL pública que puedes usar para recibir solicitudes de Twilio.

En resumen, para crear un webhook en Twilio, debes seguir estos pasos:

  1. Ve a la sección “Phone Numbers” del panel de control.
  2. Haz clic en el número de teléfono que deseas utilizar para recibir mensajes de texto.
  3. En la sección “Messaging”, busca el campo “A message comes in” y selecciona “Webhook” en el menú desplegable.
  4. Ingresa la URL de tu aplicación que procesará los mensajes recibidos. Por ejemplo, si estás trabajando en una aplicación Node.js y tu servidor está alojado en localhost:3000, la URL sería http://localhost:3000/message.
  5. Asegúrate de que el método HTTP esté establecido en "HTTP POST".
  6. Haz clic en el botón “Save” para guardar la configuración.

Probar la aplicación en un servidor local utilizando Ngrok

Para probar la funcionalidad de envío y recepción de SMS a Twilio, puedes enviar un mensaje de texto a tu número de teléfono de Twilio desde tu teléfono móvil. Si todo está configurado correctamente, deberías ver el mensaje aparecer en la consola de tu aplicación Node.js.

Puedes utilizar Ngrok para crear un túnel a tu aplicación local y así permitir el envío y recepción de SMS a Twilio. Descárgalo en https://ngrok.com/download. Una vez que lo hayas descargado, descomprime el archivo y ejecútalo. Luego, puedes ejecutar el siguiente comando para crear un túnel a tu aplicación local en el puerto 3000:

ngrok http 3000

Una vez que hayas definido la ruta en tu aplicación Express, puedes ingresar la URL completa de la ruta en el campo de texto al lado de la URL en la sección “A message comes in” en Twilio. Por ejemplo, si tu aplicación está alojada en tu computadora local en el puerto 3000 y tu ruta para procesar los mensajes es ‘/message’, la URL completa sería ‘http://localhost:3000/message‘. Sin embargo me encontre con la sorpresa que twilio no admite url que sean locales y para esto tenia que crear un tunel que permita poder acceder desde fuera de la red local.

Esto proporcionará una URL pública que puedes usar como tu webhook en Twilio. Simplemente, pega esta URL en el campo “A message comes in” en la consola de Twilio y selecciona “HTTP POST” en el menú desplegable. Luego haz clic en “Save” para guardar la configuración.

https://1b10-186-57-167-254.sa.ngrok.io/message

Para probar si Twilio está recibiendo SMS, puedes enviar un mensaje de texto a tu número de teléfono de Twilio desde tu teléfono móvil. Si todo está configurado correctamente, deberías ver el mensaje aparecer en la consola de tu aplicación Node.js.

Posiblemente te encuentres con este error: Error 11200, este error hace referencia a la url que se esta utilizando para recibir las solicitudes post en Twilio.

El error 11200 de Twilio indica que la URL a la que Twilio está tratando de enviar una solicitud no está disponible o no es accesible. Este error generalmente se debe a que la URL especificada en el webhook de Twilio no está configurada correctamente.

Para solucionar este problema, asegúrate de que la URL en el webhook de Twilio apunte a la dirección correcta de tu aplicación. Si estás utilizando ngrok, asegúrate de que el servidor esté en ejecución y que la URL en el webhook de Twilio esté actualizada para reflejar la dirección proporcionada por ngrok.

https://1b10-186-57-167-254.sa.ngrok.io/message

También es posible que haya un problema con el firewall o la configuración de red que impide que Twilio se comunique con tu servidor. Verifica que el puerto que estás utilizando para la aplicación esté abierto en el firewall y que la configuración de red permita el tráfico entrante en ese puerto.

Mostrar mensaje recibido en la consola de la aplicación.

Para permitir el envío y recepción de SMS a Twilio, es necesario configurar el middleware body-parser para analizar el cuerpo de la solicitud HTTP POST.

Para instalar body-parser, puedes ejecutar el siguiente comando en la terminal:

npm install body-parser

Luego, en tu archivo index.js, deberás agregar las siguientes líneas para usar el middleware body-parser:

const express = require('express');
const bodyParser = require('body-parser');
const app = express();

// Parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false }));

// Parse application/json
app.use(bodyParser.json());

app.post('/message', (req, res) => {
  console.log(req.body);
});

Con estas líneas, tu aplicación debería poder analizar el cuerpo de la solicitud HTTP y así obtener los datos que Twilio envía.

Me ecuentro con el siguiente error que esta relacionado con la version de node js que estaba utilizando, que hacia referencia que las nuevas versiones de body-parser no usaba export, por lo tanto debia agregar al final la siguiente linea utilizando module.exports

Este error indica que hay un problema en la sintaxis del archivo donde se está usando la palabra clave export. Esto podría deberse a un problema de versiones de Node.js o una sintaxis incorrecta en el código.

Para resolver este problema, puedes intentar una de las siguientes soluciones:

  • Actualiza la versión de Node.js a una versión más reciente que sea compatible con la sintaxis de export.
  • Revisa la sintaxis del código y verifica que esté correctamente escrita y que no haya errores de sintaxis. Si estás usando una versión de Node.js anterior a la versión 14, es posible que no se admita la sintaxis de export y debas usar module.exports en su lugar.
  • Verifica si hay un problema en la instalación de ngrok o si se instaló correctamente. Si sospechas que este es el problema, puedes intentar reinstalar ngrok y verificar si esto resuelve el problema.
module.exports = app;

Aquí, estamos exportando la instancia de la aplicación de Express utilizando module.exports. Esto permitirá que otros módulos o archivos puedan importar y utilizar la aplicación en su propio código.

El codigo completo para enviar y recibir mensaje sms desde node js quedaria de la siguiente manera:

const express = require('express');
const bodyParser = require('body-parser');
const app = express();

// Parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false }));

// Parse application/json
app.use(bodyParser.json());

app.post('/message', (req, res) => {
  console.log(req.body);
});
app.get('/message', (req, res) => {
  res.send('Hola desde node js')
})

/* Establece el puerto en el que se ejecutará la aplicación en función de la variable de entorno process.env.PORT, y si no está definida, se establece en el puerto 3000 */
app.set('port', process.env.PORT || 3000);

app.listen(app.get('port'), () => {
  console.log('Servidor esta en el puerto...', app.get('port'));
});

const accountSid = '********************************';
const authToken = '*********************************';
const client = require('twilio')(accountSid, authToken);

client.messages.create({
    body: 'Este es un mensaje de prueba enviado a través de Twilio',
    from: '+numerodetwilio',
    to: '+numerodetelefonomovil'
})
.then(message => console.log(message.sid))
.catch(error => console.error(error));

module.exports = app;

El archivo json:

{
  "name": "smstowhatsapp",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "body-parser": "^1.20.2",
    "express": "^4.18.2",
    "ngrok": "^4.3.3",
    "twilio": "^3.60.0"
  }
}

Inicio del proyecto

Vamos a crear una aplicación sumamente sencilla con la cual veremos la biblioteca Twilio, la cual nos permite enviar y recibir mensajes de texto usando Twilio, y también vamos a crear un servidor web que se encarga de recibir los mensajes que nos envían nuestros clientes.

Este es un ejemplo sencillo, sin embargo, recomiendo que tengan bases en node.js, esto es bastante útil cuando estamos utilizando servicios web.

Lo primero que vamos a hacer es crear una carpeta completamente desde cero que en mi caso la voy a nombrar node-app-sms.

No Les recomiendo que le coloquen el nombre Twilio porque vamos a instalar una biblioteca llamada Twilio, entonces NPM por defecto no permite instalar bibliotecas con el mismo nombre.

Vamos a arrastrar nuestra carpeta dentro de nuestro editor de código, voy a utilizar visual Studio code, pero pueden utilizar cualquier otro editor. Ahora abrimos una terminal o una consola de tu sistema. Yo en este caso voy a utilizar la terminal integrada de VSC.

Como la terminal ya está ubicada dentro de mi carpeta, entonces ya se puede empezar a ejecutar comandos.

El primer comando que voy a ejecutar es el comando npm init -y.

Este es un comando de Node.js que permite crear un archivo, package.json este archivo es simplemente un archivo de descripción al que le puedo colocar el nombre, la descripción y sobre todo listar las dependencias o módulos que voy a necesitar para este proyecto.

Vamos a empezar instalando Twilio npm install twilio, esta es una biblioteca de NPM, es una biblioteca que nos da esta empresa, para poder empezar a utilizar sus servicios.

Para utilizar los servicios de esta empresa, tenemos que registrarnos en Twilio. Vamos a ir en Google Chrome o a tu navegador favorito y escribimos https://twilio.com, esta es la página oficial de la empresa.

Durante el proceso de registro deben confirmar un número de teléfono, simplemente colocan su número y le dan a verificar y con eso podrían continuar con el siguiente paso. En la siguiente van a ver una pantalla de bienvenida, que en este caso aquí me dice bienvenido a tu pantalla de personalización. Aquí realiza una seria de preguntas, como, si quiero escribir código, le voy a decir que sí, en cuál lenguaje, le voy a decir que con JavaScript y cuál es el objetivo de utilizar este servicio, en este caso es utilizar SMS. Hecho esto nos redirige al dashboard o panel de control.

Ahora lo que importa es obtener un número gratis, y para eso damos un clic en donde está el botón que dice obtener número de Twilio. Damos clic y Twilio nos asigna un número de teléfono, el cual ya se puede utilizar para comenzar a recibir mensajes de texto usando Twilio. Es decir, que cuando estamos utilizando una aplicación que envía y recibe mensajes de texto, vamos a tener que hacerlo a un teléfono.

Adicionalmente, también existe una manera de conectarse al servicio, utilizando un ACCOUNT SID y un AUTH TOKEN. Estos valores se deben mantener en secreto como cualquier otro dato. Ya que esto solo sirve para poder conectarse al servicio de Twilio, por defecto nos da una cantidad de dinero para que se prueben los servicios que están dentro de la misma plataforma.

Vamos a empezar. Vamos a ir a node.js, y creamos un archivo que se va a llamar index.js y como vamos a necesitar el ACCOUNT SID Y el AUTH TOKEN. Voy a crear un archivo que se encargue de almacenar esos datos sensibles. Para hacer vamos a crear un archivo llamado .env, estos son variables de entorno, ahora vamos a instalar un módulo que permita leer los datos que tendremos almacenados en este archivo, ese módulo se llama dotenv, entonces vamos a escribir en nuestra terminal npm install dotenv, este es un módulo que se instala muy rápido porque es muy liviano.

Ahora vamos a nuestro archivo index.js y escribimos lo siguiente:

require('dotenv').config()

Esta primera línea de código ya tengo la manera de leer el archivo .env, desde mi archivo index.js.

Ahora vamos al archivo .env y colocamos lo siguiente, aquí ustedes van a colocar sus propios datos.

ACCOUNT_SID=*********************************
AUTH_TOKEN=**********************************

Lo que estamos haciendo es crear dos variables, que básicamente almacenaran los valores que necesitamos para conectarnos a Twilio. Estos valores los vamos a sacar de nuestro panel de control en Twilio. Los copiamos y los pegamos respectivamente.

Ahora vamos a probar que nuestra aplicación esté funcionando. Para eso vamos a nuestro archivo index.js y escribimos lo siguiente:

const accountSid = process.env.ACCOUNT_SID;
const authToken = process.env.AUTH_TOKEN;

Para utilizar estos valores vamos a tener que guardarlos en una constante cada uno. De esta manera ya podemos utilizar Twilio. Lo primero que vamos a hacer es enviar un mensaje de texto a nuestro dispositivo móvil, para hacerlo escribimos lo siguiente:

const client = require('twilio')(accountSid, authToken)

Esta constante client va a recibir el módulo Twilio, y este módulo Twilio tiene una forma específica de como tiene que ser ejecutado, es decir, tiene que ser ejecutado con dos parámetros que son accountSid y authToken. Con esto ya estoy listo para enviar y recibir mensajes. Ahora vamos a escribir lo siguiente:

client.message.create({
     to: 
})

Con este código vamos a crear el mensaje de texto que vamos a enviar a un teléfono móvil. En este caso vamos a tener que pasarle unos parámetros, por ejemplo voy a tener que decirle a quien va dirigido el mensaje to, acá tendría que escribir un número de teléfono, pero no lo voy a escribir aquí, sino que lo voy a escribir en una variable de entorno en el archivo .env de la siguiente manera:

MY_PHONE_NUMBER = +5555555555

Continuamos en el archivo index.js:

client.message.create({
     to: process.env.MY_PHONE_NUMBER,
     from: '+1298893493',
     body: 'Hola mundo'
})
.then(message => console.log(message.sid))

Vamos a importar desde process.env mi variable llamada MY_PHONE_NUMBER. Adicionalmente, vamos a colocar desde donde están enviando este mensaje texto from. Acá vamos a colocar el número que me asigno Twilio. Y finalmente tenemos que colocar el mensaje de texto, y eso lo colocamos dentro de una propiedad llamada body que es una cadena.

Con esto, si ejecutamos nuestra aplicación tendríamos el mensaje de texto en nuestro dispositivo móvil. Cabe señalar que este código es una operación asíncrona, por lo tanto, tendremos que manejarlo con un, .then es decir, con una promesa. Entonces voy a decirle que una vez que envíe el mensaje, lo mostramos por consola con message.sid. Es decir, cuando enviamos el mensaje, este mensaje es guardado dentro de los servicios de Twilio y lo guarda con un ID, entonces en la consola podemos ver ese mensaje enviado.

Ahora vamos a guardar y ejecutamos nuestra aplicación, para esto escribimos:

node index.js

El código completo acá está:

// Archivo .env

ACCOUNT_SID=*********************************
AUTH_TOKEN=**********************************
MY_PHONE_NUMBER = +5555555555
//Archivo index.js

require('dotenv').config()

const client = require('twilio')(accountSid, authToken)

client.message.create({
     to: process.env.MY_PHONE_NUMBER,
     from: '+1298893493',
     body: 'Hola mundo'
})
.then(message => console.log(message.sid))

Nota:

Los archivos de configuración .env no están asociados con un lenguaje de programación específico. En su lugar, son archivos de texto plano que contienen variables de entorno y sus valores asociados.

Sin embargo, algunos lenguajes de programación, como JavaScript, Python y PHP, tienen bibliotecas y herramientas que permiten leer variables de entorno desde un archivo .env y cargarlas en una aplicación. Por ejemplo, en Node.js, la biblioteca dotenv es comúnmente utilizada para cargar variables de entorno desde un archivo .env.

En resumen, aunque los archivos de configuración .env en sí mismos no están vinculados a un lenguaje de programación específico, su uso en aplicaciones de software puede estar relacionado con varios lenguajes de programación.

Ahora vamos a recibir un mensaje y enviar una respuesta. En este caso para poder recibir un mensaje de texto es mucho mas facil por que no tenemos que utilizar el account sid ni el auth token. Simplemente vamos a crear una ruta de nuestro servidor y Twilio va a enviarnos ese nuevo mensaje a nuestro servidor. En otras palabras si yo envio un mensaje desde mi telefono movil, este no lo va a enviar directamente a mi servidor sino que primero lo va a enviar a twilio, y una vez twilio reciba el mensaje, nos lo va a enviar a nuestro servidor y mi servidor puede volver a responder con un mensaje, ese mensaje se lo envia a twilio y twilio nuevamente se lo envia al telefono movil.

Inicio

Esta es la continuacion de este proyecto donde primero vimos como podias enviar mensajes desde twilio.

Vamos a nuestro atrchivo index.js y escribimos lo siguiente:

require('dotenv').config();

const messagingResponse = require('twilio').twiml.MessagingResponse;

En este codigo vamos a requerir twilio, pero no vamos a requerir toda la bibilioteca sino que en este caso vamos a utilizar un metodo de twilio llamado twiml, este metodo basicamente nos permite recibir mensajes desde twilio. entonces le vamos a decir que lo que quiero recibir es un mensaje de respuesta MessagingResponse, y esto lo vamos a guardar en una costante llamada messagingResponse. Entonces con ya tengo una ,manera de responder cuando twilio envia un nuevo mensaje de texto. Ahora si twilio es el que me va a enviar un nuevo mensaje que proviene de un telefono movil, lo tengo que recibir en algun lugar y exactamente lo tengo que recibir a traves de la ruta de un servidor.

Para esto tenemos que crear un servidor, y para esto tendremos que instalar un modulo que nos permita crear un servidor. En este caso es Express y colocamos npm install express. Una vez instalado el modulo vamos a requerirlo para esto vamos a nuestro index.js y colocamos lo siguiente

const express = require('express')

Aca creamos una constante llamada express y almacenamos el modulo express, con esto ya tenemos el modulo y podemos empezar a crear un servidor.


const app = express();


app.post('/sms', (req, res)=>{
    const twiml = new MessagingResponse()
    twiml.message('Su mensaje ha sido recibido')
    res.writeHead(200, {'Content-Type': 'text/xml'})
    res.end(twiml.toString())
});

app.listen(4000, ()=>{
    console.log('Server en puerto 4000')
});

En este caso vamos a iniciar un servidor simplemente guardando en una constante app y una vez que inicia lo que vy a hacer es crear una ruta de mi servidor. Para esto voy a escribir app.post y crear una ruta /sms, es en esta ruta donde twilio va a enviar los mensajes que el telefono movil este enviando. Esto lo vamos a manejar respondiendo ese mensaje, para esto vamos a escribir una nueva constante llamada twiml que va a almacenar una instancia de MessagingResponse(). Una vez que tenemos ese objeto podemos acceder al metodo llamado message, este metodo message me permite enviar un mensaje, es decir me permite pasar una cadena. Seguido tenemos que manejar el tipo de respuesta, Por defecto lo que tenemos que enviar es una respuesta XML y lo hacemos con write.head que nos permite establecer la cabecera, con una respuesta 200, y el tipo de contenido que voy a enviar es en XML. Esto es para Twilio lo pueda recibir, y una vez lo recibe lo envia de nuevo al telefono movil del cliente a traves de un mensaje de texto. Finalmente vamos a terminar la respuesta utilizando res.end con twiml.toString. Y con esto ya tenemos un servidor que recibe un mensaje, ahora lo que vamos a hacer es ejecutar ese servidor.

Para ejecutar el servidor utilizamos app.listen y el numero del puerto, y una vez que inicie vamos a pedir que muestre por consola el puerto donde se esta ejeutando.

Ahora vamos a ejecutar nuestra aplicacion con el siguiente comando:

node index.js

El asunto aca es que Twilio no puede utilizar rutas locales, tiene que enviar a un servidor real, para esto vamos a utilizar un programa llamado ngrok. Este programa lo que hace es que permite hacer publico una direccion local.

Puedes utilizar Ngrok para crear un túnel a tu aplicación local y así permitir la recepción de SMS a Twilio. Descárgalo en https://ngrok.com/download. Una vez que lo hayas descargado, descomprime el archivo y ejecútalo. Luego, puedes ejecutar el siguiente comando para crear un túnel a tu aplicación local en el puerto 4000 es decir le estamos diciendo a ngrok que haga prublico el puerto 4000.

ngrok http 4000

Esto proporcionará una URL pública que puedes usar como tu webhook en Twilio. Simplemente, pega esta URL en el campo “A message comes in” que esta dentro de messaging y dentro del numero de telefono en la consola de Twilio y selecciona “HTTP POST” en el menú desplegable. Luego haz clic en “Save” para guardar la configuración. Entonces la ruta a la cual twilio tiene que enviar los mensajes es:

https://1b10-186-57-167-254.sa.ngrok.io/sms

Con esto ya estamos listos para enviar un mensaje a Twilio. Vamos al telefono movil, colocamos el numero que nos dio twilio, y el mensaje que queremos. Le damos a enviar. Y esto me deberia enviar una respuesta de vuelta a nuestro telefono movil. Ya que esto lo que esta haciendo es enviarlo a Twilio, Twilio lo envia a mi servidor, mi servidor lo procesa, y se lo vuelve a enviar a Twilio. y Twilio de vuelta me envia la respuesta.

Anterior Siguiente