Domina variables en Make: Guía Paso a Paso

Fundamentos Esenciales de las Variables en Make.com

¿Qué son las variables en Make y por qué son cruciales para tus automatizaciones?

En el universo de la automatización de procesos, una variable es esencialmente un contenedor de datos dinámico y reutilizable. Imagina que estás construyendo un flujo de trabajo (o escenario en la terminología de Make) y necesitas pasar información de un paso a otro. En lugar de tener datos fijos y estáticos, una variable te permite almacenar información que puede cambiar con cada ejecución. Por ejemplo, el nombre de un cliente, la fecha de un pedido o el resultado de un cálculo. Esta capacidad es lo que transforma un escenario simple en una automatización robusta y verdaderamente inteligente.

La importancia de las variables es crucial: permiten la personalización y la eficiencia. Sin ellas, tus escenarios estarían limitados a realizar la misma acción con los mismos datos una y otra vez. Las variables introducen flexibilidad. Puedes capturar un dato de una aplicación (como un nuevo correo en Gmail), guardarlo en una variable llamada email_cliente, y luego usar esa misma variable para buscar al cliente en tu CRM, añadirlo a una lista de correo en Mailchimp y enviarle un mensaje personalizado. Son el pilar para el mapeo de datos entre diferentes módulos Make, permitiendo que la información fluya de manera lógica y coherente a lo largo de todo el flujo de trabajo, adaptándose a las circunstancias de cada ejecución específica.

Contenedores Dinámicos: Almacenan información que cambia en cada ejecución del escenario.
Reutilización: Permiten usar un mismo dato en múltiples pasos y módulos sin tener que obtenerlo repetidamente.
Personalización: Hacen posible que las automatizaciones se adapten, por ejemplo, enviando mensajes con el nombre del cliente.
Eficiencia: Optimizan los flujos de trabajo al reducir la necesidad de operaciones redundantes y complejas.

Cómo crear y configurar tu primera variable con el módulo «Set a variable»

Crear tu primera variable en Make es un proceso intuitivo que desbloquea un nuevo nivel de control sobre tus escenarios. Todo comienza con el módulo de herramientas, un componente fundamental para manipulaciones internas. Para empezar, dentro de tu escenario, haz clic en el botón ‘+’ para añadir un nuevo módulo y busca la sección «Tools». Dentro de este panel, encontrarás una herramienta llamada «Set a variable».

Una vez seleccionado el módulo, se abrirá su panel de configuración, que consta de varios campos clave:

Variable name (Nombre de la variable): Aquí asignas un nombre único y descriptivo a tu variable. Es una buena práctica usar nombres claros como nombreCliente o fechaPedido para entender fácilmente qué dato contiene.
Variable value (Valor de la variable): Este es el corazón del módulo. Aquí defines qué información se guardará. Puedes escribir un valor estático (como un texto fijo o un número), o, lo que es más potente, puedes realizar un mapeo de datos arrastrando un valor desde un módulo anterior. Por ejemplo, puedes mapear el campo «Subject» de un trigger de Gmail para que el valor de la variable sea el asunto del último correo recibido.
Variable lifetime (Tiempo de vida de la variable): Esta opción es crítica y define la persistencia del dato.
- One cycle (Un ciclo): La variable solo existirá durante una única ejecución completa del escenario. Es la opción más común.
- Across multiple cycles (Múltiples ciclos): La variable retiene su valor entre diferentes ejecuciones del mismo escenario. Esto es útil para crear contadores o para pasar información entre ejecuciones programadas.

Una vez configurado, cualquier módulo posterior en el flujo de trabajo podrá acceder al valor de esta variable simplemente buscándola en el panel de mapeo.

Módulos en Make: Guía de Funcionamiento para Automatizar

Tipos de datos que puedes almacenar: de texto a arrays

La versatilidad de las variables en Make reside en su capacidad para almacenar una amplia gama de tipos de datos. No se limitan a simples fragmentos de texto; pueden manejar estructuras complejas que son fundamentales para interactuar con diferentes APIs y aplicaciones. Entender estos tipos es esencial para manipular la información correctamente y evitar errores en tus flujos de trabajo.

Los principales tipos de datos que puedes almacenar son:

Texto (Text): Es el tipo más común. Almacena cualquier cadena de caracteres, como nombres, direcciones de correo electrónico, mensajes, etc. Por ejemplo: "juan.perez@email.com".
Numérico (Number): Guarda valores numéricos, tanto enteros como decimales. Es fundamental para realizar cálculos, contar elementos o almacenar precios. Por ejemplo: 19.99.
Booleano (Boolean): Representa un valor de verdadero o falso (true o false). Es crucial para lógicas condicionales, como en filtros o módulos Switch, para determinar el camino que debe seguir un escenario.
Fecha (Date): Almacena información de tiempo y fecha en un formato estandarizado ISO 8601. Aunque a veces se vea como texto, Make lo reconoce como un objeto de fecha, permitiendo realizar cálculos como añadir días o comparar fechas. Por ejemplo: 2025-10-26T15:00:00Z.
Array: Un array (o matriz) es una lista ordenada de elementos. Puede contener una lista de textos, números, o incluso otros objetos. Es extremadamente útil cuando una API devuelve múltiples resultados, como una lista de productos de un pedido o los archivos adjuntos de un email. Por ejemplo, una variable productos podría contener ["Camiseta", "Pantalón", "Zapatos"].
Colección (Collection): Una colección es un conjunto de pares clave-valor, similar a un objeto JSON. Es perfecta para almacenar datos estructurados, como los detalles completos de un contacto (nombre, email, teléfono).

Tipo de Dato	Descripción	Ejemplo Práctico
Texto	Cadena de caracteres alfanuméricos.	`nombreUsuario = "Ana García"`
Numérico	Valores enteros o decimales.	`precioProducto = 49.95`
Booleano	Valor lógico de verdadero o falso.	`pagoConfirmado = true`
Fecha	Marca de tiempo estandarizada.	`fechaEntrega = 2025-11-15T10:30:00Z`
Array	Lista ordenada de elementos.	`etiquetas = ["marketing", "lead", "urgente"]`
Colección	Conjunto de datos estructurados (clave-valor).	`cliente = { "nombre": "Carlos", "id": 123 }`

Caso Práctico 1: Unificando datos de una API

Uno de los problemas más comunes al trabajar con una API externa es que los datos no siempre llegan en el formato exacto que necesitas. Un ejemplo perfecto es la integración con APIs del tiempo, que a menudo proporcionan la URL de un icono meteorológico de forma incompleta, esperando que el desarrollador añada el protocolo (http: o https:).

Imaginemos un escenario que se activa para obtener el pronóstico del tiempo.

Módulo «HTTP – Make a request»: Primero, configuramos este módulo para llamar a una API del tiempo (como WeatherAPI o OpenWeatherMap). Le pasamos la ubicación y la API nos devuelve una respuesta JSON con datos como la temperatura, la descripción del tiempo y una URL para el icono del tiempo, por ejemplo: //cdn.weatherapi.com/weather/64x64/day/116.png.
El Problema: Si intentas usar esa URL directamente en un módulo de notificación o en una página web, el enlace estará roto porque le falta el «https:» al principio.
La Solución con Variables: Aquí es donde entra en juego el módulo «Set a variable». Justo después del módulo HTTP, añadimos este módulo de «Tools» y lo configuramos de la siguiente manera:
- Variable name: urlIconoCompleta
- Variable value: En este campo, no mapeamos directamente el dato de la API. En su lugar, escribimos https: y, justo después, mapeamos el campo de la URL del icono que nos devolvió el módulo HTTP. El resultado en el campo de configuración se verá así: https:{{1.data.current.condition.icon}}.

Al ejecutar el flujo de trabajo, la variable urlIconoCompleta ahora contendrá el valor https://cdn.weatherapi.com/weather/64x64/day/116.png. Este es un dato limpio, completo y listo para ser utilizado en cualquier paso posterior del escenario, como insertarlo en un correo electrónico o en un mensaje de Slack. Este simple paso de concatenar texto con un dato de una API soluciona un problema de integración real y demuestra cómo las variables son esenciales para limpiar y preparar datos «en vuelo».

Error en escenario de Make: Qué pasa y cómo solucionarlo

El Poder de las Funciones para Transformar y Adaptar tus Datos

Introducción a las funciones de Make: tus herramientas de transformación

Si las variables son los contenedores de tus datos, las funciones de Make son las herramientas de precisión que te permiten modificarlos, darles forma y adaptarlos a tus necesidades. Son la clave para la transformación de datos avanzada. Mientras que una variable simplemente almacena un valor (como «JUAN PÉREZ» o «2025-12-25»), una función puede tomar ese valor y convertirlo en algo nuevo (como «Juan Pérez» o «25 de Diciembre»).

Make organiza estas herramientas en un práctico panel de funciones, accesible desde cualquier campo donde puedas mapear datos. Este panel está dividido en categorías lógicas para facilitar su uso:

Funciones Generales: Incluyen herramientas versátiles como if(), switch() o get() que sirven para la lógica condicional y la recuperación de datos.
Funciones Matemáticas: Para realizar todo tipo de cálculos, desde sumas simples hasta operaciones más complejas.
Funciones de Texto: Un conjunto potente para manipular cadenas de texto: unir, dividir, reemplazar, cambiar mayúsculas, etc.
Funciones de Fecha y Hora: Imprescindibles para formatear, analizar y realizar cálculos con fechas, asegurando la correcta comunicación entre apps.
Funciones de Array: Diseñadas para trabajar con listas de datos, permitiendo extraer elementos o transformar un array completo.

Entender y utilizar estas funciones es lo que separa un escenario básico de un flujo de trabajo verdaderamente potente y a prueba de errores. Permiten limpiar datos sucios, estandarizar formatos y preparar la información para que el módulo de destino la acepte sin problemas.

Funciones de texto imprescindibles: split, trim, upper, lower y capitalize

Las funciones de texto son, con diferencia, algunas de las más utilizadas en la automatización de procesos, ya que gran parte de los datos que manejamos son textuales. Dominar las funciones clave puede ahorrarte horas de trabajo manual y prevenir errores de formato. Permiten parsear datos y estandarizarlos sobre la marcha.

split(texto; separador): Esta función es increíblemente útil para dividir una cadena de texto en un array (una lista) de elementos, basándose en un carácter separador. Su caso de uso más común es separar un nombre completo en nombre y apellido. Por ejemplo, split("Juan Pérez"; " ") devolverá un array con dos elementos: ["Juan", "Pérez"]. Luego puedes usar get() para acceder a cada parte por separado.
trim(texto): A menudo, los datos que provienen de formularios web o de la entrada manual de usuarios contienen espacios en blanco innecesarios al principio o al final. Estos espacios pueden causar fallos en búsquedas o comparaciones. La función trim() elimina estos espacios. Por ejemplo, trim(" juan@email.com ") devolverá "juan@email.com", un dato limpio y listo para ser usado.
upper(texto) y lower(texto): La estandarización es clave para la integridad de los datos. Estas funciones convierten un texto a mayúsculas o minúsculas, respectivamente. Son perfectas para normalizar datos como direcciones de correo electrónico, códigos postales o números de seguimiento, asegurando que las comparaciones y búsquedas funcionen correctamente. upper("es") devuelve "ES", útil para códigos de país.
capitalize(texto): Esta función pone en mayúscula la primera letra de cada palabra en un texto, y el resto en minúsculas. Es ideal para dar un formato limpio y profesional a nombres propios o títulos que pueden haber sido introducidos de forma inconsistente. capitalize("JUAN PÉREZ") devolverá "Juan Pérez".

Función	Descripción	Ejemplo de Entrada	Ejemplo de Salida
`split()`	Divide un texto en un array usando un separador.	`split("producto1,producto2"; ",")`	`["producto1", "producto2"]` (Array)
`trim()`	Elimina espacios en blanco al inicio y al final.	`trim(" Pedido #123 ")`	`"Pedido #123"`
`upper()`	Convierte todo el texto a mayúsculas.	`upper("Confirmado")`	`"CONFIRMADO"`
`lower()`	Convierte todo el texto a minúsculas.	`lower("Cliente@EMAIL.com")`	`"cliente@email.com"`
`capitalize()`	Pone en mayúscula la primera letra de cada palabra.	`capitalize("ana maría lópez")`	`"Ana María López"`

Domina el tiempo: formatDate y parseDate para una comunicación perfecta entre apps

La gestión de fechas y horas es uno de los mayores desafíos en la automatización de procesos, ya que cada aplicación (Google Calendar, Slack, Trello, etc.) puede utilizar un formato de fecha diferente. Una app puede esperar «MM/DD/YYYY» mientras que otra genera «YYYY-MM-DDTHH:mm:ssZ». Este desajuste puede provocar fallos en la creación de eventos, el establecimiento de plazos o el registro de actividades. Aquí es donde las funciones formatDate() y parseDate() se vuelven indispensables para actuar como traductores universales.

Domina los Operadores en Make: La Guía Esencial

La función formatDate(fecha; formato) se utiliza para tomar un objeto de fecha de Make (el formato estándar ISO 8601 que usan las APIs) y presentarlo en un formato legible para humanos o específico para una aplicación. Por ejemplo, si tienes una variable de fecha {{now}} (que podría ser 2025-07-18T10:30:00.000Z) y quieres mostrarla en un correo electrónico en un formato amigable para España, usarías formatDate({{now}}; "DD/MM/YYYY HH:mm"). El resultado sería "18/07/2025 12:30". Puedes usar una gran variedad de tokens (YYYY para el año, MM para el mes, dd para el día, etc.) para construir el formato que necesites.

Por otro lado, la función parseDate(texto_fecha; formato) hace lo contrario: convierte una fecha en formato de texto (que no es reconocida como fecha por Make) en un objeto de fecha estándar que Make sí puede entender. Esto es crucial cuando recibes fechas de fuentes como hojas de cálculo o formularios web. Si un usuario introduce «18-07-2025» en una celda de Google Sheets, Make lo leerá como simple texto. Para poder usarlo en cálculos (por ejemplo, sumarle 7 días), primero debes «parsearlo»: parseDate("18-07-2025"; "DD-MM-YYYY"). Esto lo convierte en un objeto de fecha válido dentro de tu escenario.

formatDate(): Convierte una fecha de Make a un formato legible. De Máquina a Humano.
parseDate(): Convierte un texto a una fecha de Make. De Humano a Máquina.

Funciones de Array y la potencia de map() y get()

Cuando trabajas con APIs, es muy común recibir datos en forma de arrays (listas). Por ejemplo, un trigger de WooCommerce para un nuevo pedido puede devolver un array llamado «Line Items» que contiene todos los productos comprados. O una búsqueda en Gmail puede devolver un array de archivos adjuntos. Para trabajar con estos datos, necesitas las funciones de Array.

La función más básica y esencial es get(array; posición). Permite extraer un único elemento de un array basándose en su posición (índice). Es importante recordar que los arrays en programación suelen empezar en el índice 1 en el caso de Make. Si tienes un array de productos ["Camiseta", "Pantalón", "Zapatos"] y quieres obtener solo el primer producto, usarías get(miArrayDeProductos; 1), lo que devolvería "Camiseta".

Sin embargo, la verdadera potencia para el mapeo de datos a gran escala viene con la función map(array; clave). Esta función es increíblemente avanzada y útil. Se utiliza para iterar sobre un array de colecciones (objetos) y extraer el valor de una misma clave de cada uno de ellos, devolviendo un nuevo array con solo esos valores. Imagina que un módulo de CRM te devuelve una lista de 5 usuarios, donde cada usuario es una colección con name, email y phone. Si solo necesitas las direcciones de correo electrónico para añadirlas a Mailchimp, usar map() es la solución perfecta. La fórmula map(arrayDeUsuarios; "email") devolvería un nuevo array que contendría únicamente las direcciones de correo: ["usuario1@email.com", "usuario2@email.com", ...]. Esto evita tener que usar repetidores complejos y simplifica enormemente los flujos de trabajo que manejan grandes volúmenes de datos estructurados.

Módulos y Estrategias Avanzadas para Escenarios Complejos

Gestión eficiente con «Set/Get Multiple Variables»

A medida que tus escenarios crecen en complejidad, la gestión de variables una por una con el módulo «Set a variable» puede volverse tediosa y desordenada. Para solucionar esto, Make ofrece dos herramientas de «Tools» extremadamente eficientes: «Set Multiple Variables» y «Get Multiple Variables». Estos módulos permiten definir o recuperar un lote de variables en un único paso, lo que mejora drásticamente la eficiencia del escenario y su legibilidad.

El módulo «Set Multiple Variables» te permite crear tantas variables como necesites dentro de una sola interfaz. Por ejemplo, al recibir un nuevo pedido de una tienda de e-commerce, en lugar de usar tres módulos «Set a variable» separados, puedes usar un único módulo «Set Multiple Variables» para definir:

nombreCliente mapeando el nombre del comprador.
emailCliente mapeando su correo electrónico.
idPedido mapeando el número de la orden.

Esta centralización es especialmente útil justo después de un trigger o de un Router. Puedes extraer toda la información crucial en un solo lugar y luego usar esas variables en las diferentes ramas del flujo.

De forma complementaria, el módulo «Get Multiple Variables» te permite recuperar los valores de variables existentes (especialmente aquellas con un tiempo de vida «across multiple cycles») para usarlos en un punto posterior del escenario. Esto ayuda a mantener el flujo limpio, ya que no tienes que mapear cada variable individualmente en los módulos que las necesitan, sino que puedes «cargarlas» todas a la vez cuando sea necesario.

Módulos de control de flujo: Sleep, Increment y Switch

Más allá de la manipulación de datos, el control del flujo de ejecución es vital para crear automatizaciones robustas y respetuosas con los servicios externos. Make proporciona módulos específicos para gestionar este flujo.

Sleep: Este módulo es simple pero fundamental. Su única función es introducir una pausa deliberada en la ejecución del escenario. Se configura con un número de segundos. ¿Por qué es útil? Muchas APIs tienen límites de velocidad (rate limiting), lo que significa que solo puedes hacer un cierto número de peticiones por minuto. Si estás procesando un gran lote de datos (por ejemplo, 100 registros de una hoja de cálculo), usar un Sleep(1) dentro de un bucle puede evitar que sobrecargues la API y recibas un error.
Increment function: Aunque es una función, a menudo se usa dentro de la lógica de control como un contador. Se encuentra dentro del módulo «Tools» y su propósito es incrementar un valor en 1 cada vez que se ejecuta. Es la base para crear bucles controlados (por ejemplo, «repetir esta acción 5 veces») o para realizar un seguimiento del número de elementos procesados, guardando el resultado en una variable.
Switch: Este es uno de los módulos de control de flujo más potentes, actuando como una versión avanzada de los filtros condicionales (IF). Mientras que un filtro solo tiene dos salidas (pasa o no pasa), un Switch permite dirigir el flujo por múltiples caminos diferentes basándose en el valor de una sola variable. Por ejemplo, puedes tener una variable estadoPedido y configurar el Switch para que:
- Si el valor es «Pagado», siga la ruta A (enviar al almacén).
- Si el valor es «Pendiente», siga la ruta B (enviar recordatorio de pago).
- Si el valor es «Cancelado», siga la ruta C (notificar al equipo de soporte).
- Además, incluye una ruta «Else» (de lo contrario) para cualquier otro valor no contemplado.

Variables de Sistema (System Variables): ¿Qué son y cómo usarlas?

Además de las variables que tú creas, Make proporciona un conjunto de Variables de Sistema predefinidas que contienen información contextual sobre la ejecución del escenario. Estas variables son increíblemente útiles para tareas de auditoría, registros (logs) y depuración, ya que ofrecen metadatos sobre el proceso en sí.

Se pueden encontrar y mapear desde la pestaña «System» en el selector de variables de cualquier módulo. Algunas de las más comunes y útiles son:

{{scenario.id}} y {{scenario.name}}: Devuelven el ID numérico y el nombre de tu escenario. Perfecto para incluir en notificaciones de error, para saber exactamente qué flujo falló.
{{execution.id}}: Proporciona un ID único para cada ejecución individual del escenario. Esencial para trazar un problema específico en el historial de ejecuciones.
{{now}} y {{timestamp}}: Devuelven la fecha y hora actuales. {{now}} es un objeto de fecha, mientras que {{timestamp}} es un número (segundos desde la época de Unix). {{now}} es ideal para registrar cuándo ocurrió un evento.
{{team.name}} y {{organization.name}}: Identifican el equipo y la organización a la que pertenece el escenario, útil en entornos corporativos.

Un caso de uso práctico es nombrar archivos de forma única. Al generar un informe en PDF o una imagen, puedes nombrar el archivo usando una combinación como Informe-Ventas-{{scenario.id}}-{{formatDate(now; "YYYY-MM-DD")}}.pdf. Esto asegura que cada archivo generado tenga un nombre único y contextual, evitando sobreescrituras y facilitando su organización.

Caso Práctico 2: Automatización de un reporte mensual

Vamos a construir un escenario de automatización compleja que combine muchos de los conceptos vistos para generar un reporte de ventas mensual.

Trigger (Google Sheets – Watch Rows): El escenario se activa una vez al mes y utiliza el módulo de Google Sheets para leer todas las filas de una tabla que contiene las ventas del último mes. Este módulo devuelve un array de colecciones, donde cada colección es una venta con «Producto», «Cantidad» y «Precio».
Módulo «Set Multiple Variables»: Inmediatamente después, usamos este módulo para inicializar y calcular datos clave.
- mesReporte: Usamos la función formatDate({{now}}; "MMMM YYYY") para obtener el nombre del mes y año del reporte (ej: «Julio 2025»).
- ventasTotales: Usamos la función matemática sum() y la función de array map() para calcular el total. La fórmula sería sum(map(trigger.rows; "Precio")). Esto primero extrae todos los precios en un nuevo array y luego los suma.
Módulo (Tools – Text aggregator): Para listar los productos vendidos, usamos la función map() de nuevo para extraer todos los nombres de los productos: map(trigger.rows; "Producto"). Esto nos da un array como ["Producto A", "Producto B", "Producto A"]. Para presentarlo de forma legible, podemos usar el módulo «Text aggregator» para unir este array en una sola cadena de texto separada por comas.
Módulo (Email – Send an email): Finalmente, configuramos un módulo de correo para enviar el resumen. Aquí es donde todo se une.
- Asunto: «Reporte de Ventas para {{1.mesReporte}}».
- Cuerpo del email: Usamos las variables y los datos procesados y formateados. «Hola equipo, aquí está el resumen de ventas de {{1.mesReporte}}. El total de ventas ha sido de ${{1.ventasTotales}}. Los productos vendidos este mes incluyen: {{3.text}}».

Este escenario demuestra cómo la combinación de triggers, variables, funciones de transformación de datos (formatDate, map, sum) y módulos de acción permite crear un reporte mensual completo y automatizado, ahorrando horas de trabajo manual y asegurando la precisión de los datos.