Domina los Operadores en Make: La Guía Esencial

Fundamentos de los Operadores en Make y el Poder del Router

Introducción a los Operadores: ¿Qué son y por qué son cruciales en tus automatizaciones?

Los operadores en Make.com (anteriormente conocido como Integromat) son módulos especializados que no se conectan a una aplicación externa, sino que controlan el flujo de datos dentro de tus escenarios. Son la pieza fundamental del Control de flujo (Flow Control), permitiéndote construir lógicas complejas que van mucho más allá de las simples automatizaciones lineales (A → B). Mientras que los módulos estándar extraen o envían datos a servicios como Google Sheets o Slack, los operadores actúan como el cerebro de tu automatización de flujos de trabajo, dirigiendo, dividiendo, transformando y agrupando la información en su camino.

¿Por qué son tan cruciales? Porque los procesos del mundo real rara vez son lineales. A menudo necesitas tomar decisiones basadas en datos, procesar listas de elementos uno por uno o consolidar información antes de realizar una acción final. Sin operadores, tus escenarios serían rígidos y limitados. Con ellos, puedes bifurcar escenarios, manejar errores y procesar datos de manera dinámica y eficiente. En la interfaz de Make, encontrarás estos potentes módulos en la parte inferior del listado de herramientas, dentro de una sección dedicada llamada «Flow Control». Dominar estos operadores es el paso definitivo para transformar tus ideas en automatizaciones robustas y escalables.

El Operador Router: Cómo bifurcar tus escenarios paso a paso

El Router en Make es uno de los operadores más utilizados y conceptualmente más sencillos, pero su impacto es inmenso. Su función principal es tomar un único paquete de datos (un bundle) que recibe de un módulo anterior y clonarlo para enviarlo por múltiples rutas o ramas de forma simultánea. Imagínalo como un distribuidor en una tubería de agua: una entrada principal de agua se divide en varias salidas, y cada una sigue su propio camino independiente. Esto te permite ejecutar diferentes secuencias de acciones a partir de un único evento disparador (trigger).

La configuración del Router es sorprendentemente simple. A diferencia de otros módulos de Make, el Router no tiene campos internos que configurar. Simplemente lo añades a tu escenario y lo conectas después del módulo cuyo resultado quieres distribuir. A partir de ese momento, puedes añadir nuevas rutas simplemente arrastrando el conector desde el Router hacia un nuevo módulo. Cada módulo que conectes al Router se convertirá en el inicio de una nueva rama independiente. Por ejemplo, si conectas tres módulos al Router, los datos del trigger se enviarán a los tres simultáneamente, y cada una de las tres ramas se ejecutará en paralelo. Este proceso es clave para bifurcar escenarios y maximizar la eficiencia de un solo trigger.

Casos de Uso Prácticos del Router: Optimiza tus flujos de trabajo

La verdadera potencia del Router en Make se manifiesta en los casos de uso prácticos, donde la eficiencia y la lógica son primordiales. Su capacidad para ejecutar múltiples acciones a partir de un solo disparador abre un abanico de posibilidades para optimizar cualquier automatización de flujos de trabajo.

Qué son los Webhooks: Guía Completa para Automatizar Tareas

Un ejemplo clásico es la gestión de redes sociales. Imagina que publicas un nuevo artículo en tu blog (el trigger podría ser un feed RSS). En lugar de crear tres escenarios separados, puedes usar un Router para distribuir el contenido:

• Trigger: Nuevo artículo en Feed RSS.
• Router: Divide el flujo.
  • Ruta 1: Formatea un mensaje para Twitter (más corto, con hashtags) y lo publica.
  • Ruta 2: Crea una publicación más elaborada para LinkedIn, incluyendo la imagen destacada y un texto profesional.
  • Ruta 3: Envía el artículo a un canal de Telegram con una notificación personalizada.

Otro caso de uso fundamental es la gestión de respuestas de formularios. Supongamos que un cliente potencial rellena un formulario de contacto en tu web con diferentes opciones («Solicitar presupuesto», «Soporte técnico», «Información general»).

• Trigger: Nueva respuesta en Typeform/Google Forms.
• Router: Clona la respuesta y la envía por tres caminos.
  • Ruta 1: Si el usuario eligió «Solicitar presupuesto», envía un email al equipo de ventas y crea una tarea en Asana.
  • Ruta 2: Si eligió «Soporte técnico», crea un ticket automáticamente en Zendesk o Jira.
  • Ruta 3: En todos los casos, añade el email del contacto a una lista de correo en Mailchimp (esta ruta no necesitaría un filtro posterior).

Estos ejemplos demuestran cómo el Router no solo ahorra tiempo de configuración, sino que centraliza la lógica de automatización, haciendo los escenarios en Make más limpios, organizados y fáciles de mantener.

Caso de Uso	Trigger	Ramas del Router	Módulos Involucrados
Distribución de Contenido	Nuevo post en WordPress (vía RSS)	1. Twitter, 2. LinkedIn, 3. Facebook	Módulos de Twitter, LinkedIn, Facebook
Gestión de Leads	Nuevo envío de Formulario	1. Equipo de Ventas, 2. CRM, 3. Newsletter	Módulos de Email, Pipedrive, Mailchimp
Notificaciones Internas	Nuevo cliente en Stripe	1. Canal de Slack, 2. Hoja de cálculo	Módulos de Slack, Google Sheets
Procesamiento E-commerce	Nuevo pedido en Shopify	1. Notificar al almacén, 2. Enviar factura	Módulos de Gmail, Invoice Ninja

Filtros y Routers: La combinación perfecta para la lógica condicional

Si bien el Router es excelente para enviar los mismos datos por múltiples caminos, su verdadero poder se desbloquea cuando se combina con filtros. Por sí solo, el Router ejecuta todas las ramas sin distinción. Sin embargo, en la mayoría de los casos prácticos, no querrás que todas las rutas se ejecuten siempre. Querrás que una ruta específica solo se active si se cumple una condición determinada. Aquí es donde entran en juego los filtros.

Después de bifurcar escenarios con un Router, puedes (y a menudo debes) colocar un filtro en el conector que une el Router con el primer módulo de una rama. Este filtro actúa como una puerta de control. Antes de permitir que los datos pasen y la rama se ejecute, el filtro evaluará una condición que tú definas. Si la condición es verdadera, la puerta se abre y la automatización continúa por esa rama. Si es falsa, el flujo de datos se detiene en seco para esa ruta específica, sin consumir operaciones adicionales.

Por ejemplo, retomando el caso del formulario de contacto:

1. Trigger: Nueva respuesta de formulario.
2. Router: Clona la respuesta.
3. Ruta de Ventas: Colocas un filtro en esta ruta con la condición: «La respuesta a la pregunta ‘Motivo de contacto’ contiene ‘Ventas'». Solo si esto es cierto, se enviará el email al equipo comercial.
4. Ruta de Soporte: Añades otro filtro con la condición: «La respuesta a la pregunta ‘Motivo de contacto’ contiene ‘Soporte'». Solo en este caso se creará el ticket en el sistema de soporte.

Esta combinación de Router + Filtro es la base del control de flujo condicional en Make y te permite construir lógicas complejas y segmentadas de manera eficiente y visual.

---

Manejo Avanzado de Datos con el Iterator

Comprendiendo los Arrays: El problema que el Iterator soluciona

Para entender la necesidad del Iterator en Make, primero debemos comprender qué es un array. En el contexto de la automatización de flujos de trabajo y las APIs, un array es una colección o lista de elementos similares agrupados en un solo paquete de datos. Imagina que haces un pedido online de tres productos; los detalles de tu pedido (cliente, dirección) son datos únicos, pero los productos en sí (producto A, producto B, producto C) vendrán dentro de un array llamado «Líneas de pedido». Otro ejemplo es cuando un módulo como «Google Sheets – Search Rows» busca filas que coincidan con un criterio; si encuentra 5 filas, el resultado será un array que contiene esas 5 filas.

El problema fundamental que enfrentan muchos usuarios de Make.com es que, por defecto, los módulos subsiguientes solo saben cómo procesar el primer elemento de un array. Si el módulo de Google Sheets devuelve 5 filas y el siguiente paso es «Crear una tarea en Asana», Make solo creará una tarea para la primera fila, ignorando las otras cuatro. Aquí es donde el Iterator se convierte en una herramienta indispensable. Su única función es tomar un array y «desempaquetarlo», procesando cada uno de sus elementos de forma individual y secuencial. Resuelve el desafío del manejo de arrays permitiendo que se ejecute una serie de acciones para cada elemento de la lista, en lugar de solo para el conjunto completo o su primer ítem.

Configuración y Mapeo del Iterator

Añadir y configurar un Iterator en Make es un paso crucial para el correcto procesamiento de datos en listas. Este operador se encuentra, al igual que el Router, en la sección de herramientas de Control de flujo (Flow Control). El proceso para implementarlo en un escenario es lógico y directo, y se centra en un único campo de configuración clave.

La guía paso a paso sería la siguiente:

1. Identificar la fuente del array: Primero, localiza el módulo en tu escenario que genera el array que necesitas procesar. Esto podría ser un módulo de API que devuelve múltiples resultados, un «Search Rows» de Google Sheets, un «Watch Orders» de Shopify que incluye las líneas de pedido, o cualquier otro módulo que produzca una colección de elementos.
2. Añadir el Iterator: Haz clic en el signo de más (+) para añadir un nuevo módulo y selecciona el Iterator desde las herramientas de «Flow Control». Debes colocarlo inmediatamente después del módulo que genera el array.
3. Configurar el campo «Array»: Al abrir la configuración del Iterator, verás un campo principal llamado «Array». Aquí es donde ocurre la magia. Debes «mapear» (arrastrar y soltar) la variable del array desde el módulo anterior a este campo. Las variables de tipo array en Make se distinguen por tener corchetes [] al final de su nombre (por ejemplo, Line items[]). Al seleccionar esta variable, le estás diciendo al Iterator qué paquete de datos específico debe desempaquetar.

Una vez configurado, el Iterator se interpondrá entre tu fuente de datos y los módulos de acción. Por cada elemento que encuentre dentro del array mapeado, ejecutará todos los módulos que le sigan una vez, creando así un bucle de procesamiento individual para cada ítem.

Ejemplo Práctico con una API: Procesando múltiples resultados

Imaginemos un escenario práctico para ilustrar el poder del Iterator en Make al interactuar con una API. Supongamos que queremos obtener una lista de los próximos partidos de La Liga desde una API de deportes y guardar cada partido en una base de datos de Airtable para nuestro análisis.

El flujo de trabajo sin un Iterator sería problemático:

• Paso 1: Módulo HTTP – Make a request: Hacemos una llamada GET a la API api.deportes.com/partidos?liga=laliga.
• Respuesta de la API: La API devuelve un array JSON con 10 objetos, donde cada objeto representa un partido ({ "equipo_local": "Real Madrid", "equipo_visitante": "FC Barcelona", "fecha": "2025-10-26" }, etc.).
• Paso 2: Módulo Airtable – Create a Record: Intentamos guardar la información en Airtable.
• Resultado sin Iterator: Airtable solo crearía un registro, correspondiente al primer partido del array (Real Madrid vs FC Barcelona). Los otros 9 partidos serían completamente ignorados por el escenario en Make.

Ahora, veamos cómo el Iterator soluciona este problema y permite procesar datos en lote:

• Paso 1: Módulo HTTP – Make a request: La misma llamada a la API.
• Paso 2: Módulo Iterator: Añadimos el Iterator. En su campo «Array», mapeamos el array de partidos que devuelve la API.
• Paso 3: Módulo Airtable – Create a Record: Conectamos el módulo de Airtable después del Iterator. Ahora, al mapear los campos en Airtable (Equipo Local, Equipo Visitante, Fecha), usaremos las variables que provienen del Iterator, no del módulo HTTP directamente.
• Resultado con Iterator: Make ejecutará el Paso 3 (Crear Registro en Airtable) un total de 10 veces, una por cada partido en el array. Cada ejecución será una operación independiente que consumirá los datos del partido correspondiente. Al final, tendremos 10 nuevos registros en nuestra base de Airtable, uno para cada partido, logrando una automatización completa y correcta.

Ejemplo Práctico en E-commerce: Gestionando líneas de pedido

El manejo de arrays es una tarea diaria en el mundo del e-commerce, y el Iterator en Make es la herramienta perfecta para ello. Consideremos un caso de uso muy común: procesar los artículos individuales de un nuevo pedido en una tienda de Shopify. Cuando se genera un nuevo pedido, el trigger de Shopify en Make («Watch Orders») proporciona toda la información en un solo paquete de datos. Dentro de este paquete, los productos específicos comprados se encuentran en un array, comúnmente llamado Line Items[].

Si queremos, por ejemplo, registrar cada producto vendido en una hoja de cálculo de Google Sheets para un análisis detallado del inventario, nos encontramos con el problema clásico:

• Trigger: Shopify – Watch Orders. Un cliente compra una camiseta y un par de pantalones. El array Line Items[] contiene dos elementos.
• Acción sin Iterator: Google Sheets – Add a Row.
• Resultado: Solo se registraría el primer artículo del pedido (la camiseta) en la hoja de cálculo. La información sobre los pantalones se perdería.

Para gestionar esto correctamente, debemos insertar un Iterator:

1. Trigger: Shopify - Watch Orders.
2. Iterator: Añadimos el Iterator y en su campo «Array» mapeamos la variable Line items[] del trigger de Shopify.
3. Acción: Google Sheets - Add a Row. Este módulo ahora se conecta después del Iterator. Al configurar las columnas de la hoja de cálculo (por ejemplo, «ID Pedido», «Nombre Producto», «SKU», «Cantidad», «Precio»), mapearemos las variables correspondientes que ahora expone el Iterator para cada línea de pedido.
4. Resultado: El escenario en Make ejecutará el módulo de Google Sheets dos veces. La primera ejecución añadirá una fila con los datos de la camiseta. La segunda ejecución añadirá otra fila con los datos de los pantalones. De esta manera, cada artículo vendido se registra de forma individual, permitiendo una gestión de inventario precisa, la creación de informes de ventas por producto y una visibilidad completa de la operativa del negocio. Este es un ejemplo perfecto de cómo procesar datos complejos de manera estructurada.

---

Agrupación y Consolidación con Array Aggregator

El Proceso Inverso al Iterator: ¿Qué es un Array Aggregator?

Si el Iterator en Make es la herramienta que toma un paquete (un array) y lo desarma en sus componentes individuales para procesarlos uno por uno, el Array Aggregator realiza la función exactamente opuesta. Su propósito es tomar una serie de ejecuciones o bundles individuales, que normalmente provienen de un Iterator, y volver a agruparlos en un único paquete de datos: un nuevo array. Este operador es fundamental cuando, después de haber realizado acciones individuales sobre cada elemento de una lista, necesitas realizar una acción final con el conjunto de datos consolidado.

Piénsalo como el final de una cadena de montaje. El Iterator desmontó un producto en piezas para que cada una fuera revisada individualmente. Una vez que todas las piezas han pasado la inspección, el Array Aggregator las vuelve a juntar en una caja para el envío final. En términos de automatización de flujos de trabajo, te permite, por ejemplo, procesar cada línea de un pedido y, al final, generar una única factura que resuma todos los artículos. Sin un agregador, estarías atascado con los datos fragmentados por el Iterator, sin una forma nativa de realizar una acción de resumen sobre el grupo completo dentro del mismo escenario en Make.

Tipos de Aggregators: Text Aggregator y otras herramientas

Dentro de las herramientas de Control de flujo (Flow Control) de Make.com, existen principalmente dos tipos de agregadores que sirven para consolidar datos, cada uno con un propósito específico. Comprender sus diferencias es clave para elegir el correcto según la tarea que necesites realizar.

El más común y versátil es el Array Aggregator. Su función, como hemos mencionado, es recolectar datos de múltiples ejecuciones y construir un nuevo array a partir de ellos. Al configurarlo, debes especificar el «Módulo de Origen» (generalmente el Iterator o un módulo dentro de su ruta) y luego definir la «Estructura de Destino», que es básicamente una plantilla de qué datos de cada ejecución quieres incluir en el nuevo array. Es ideal para cuando necesitas una lista estructurada para usarla en otro módulo o para realizar cálculos.

Por otro lado, tenemos el Text Aggregator. Esta es una variante más especializada que, en lugar de crear un array, consolida la información en un único bloque de texto. Funciona de manera similar: eliges un módulo de origen y luego especificas el texto que quieres extraer de cada ejecución. El Text Aggregator une estos fragmentos de texto, permitiéndote definir un «separador» (como una nueva línea, una coma o un guion) entre cada elemento. Es la herramienta perfecta para crear resúmenes, listas con formato para emails o informes de texto sin necesidad de procesar un array posteriormente.

Operador	Función Principal	Resultado Final	Caso de Uso Típico
Array Aggregator	Agrupar bundles en un nuevo array	Un array [item1, item2, ...]	Recolectar precios para sumarlos, agrupar IDs para una consulta API
Text Aggregator	Unir texto de bundles en uno solo	Un bloque de texto "item1, item2, ..."	Crear una lista de productos vendidos para un email de resumen diario

Caso de Uso 1: Crear resúmenes y listados

El Text Aggregator brilla cuando necesitas compilar información dispersa en un formato legible y cohesionado, ideal para notificaciones, informes o resúmenes. Continuemos con nuestro ejemplo práctico de e-commerce donde un Iterator ha procesado cada artículo de un pedido de Shopify. Después de registrar cada producto en una base de datos, quizás queramos enviar un único email de resumen al equipo de almacén con una lista clara de todos los artículos que deben preparar.

Así es como se construiría el flujo en Make.com:

1. Trigger: Shopify - Watch Orders.
2. Iterator: Desempaqueta el array Line Items[].
3. Módulos intermedios (opcional): Acciones sobre cada artículo, como verificar stock.
4. Text Aggregator: Este es el paso clave. Lo añadimos como el paso final en la ruta que sigue al Iterator.
   • Source Module: Seleccionamos el Iterator como la fuente de los bundles.
   • Text: Aquí definimos cómo se verá cada línea del resumen. Podríamos mapear variables para crear un texto como: - Producto: {{2.name}} (SKU: {{2.sku}}), Cantidad: {{2.quantity}}\n. La \n al final es un carácter especial que instruye a Make para que inserte un salto de línea después de cada elemento.
5. Módulo de Email: Después del Text Aggregator, añadimos un módulo para enviar un email. En el cuerpo del correo, simplemente insertamos la variable de texto generada por el agregador.

El resultado será un correo electrónico perfectamente formateado con una lista como esta, generada a partir de un único campo de texto:

• Producto: Camiseta Clásica (SKU: TS-001), Cantidad: 1
• Producto: Vaqueros Slim Fit (SKU: JN-004), Cantidad: 1
• Producto: Calcetines de Deporte (SKU: SK-012), Cantidad: 3

Este método, que utiliza el Text Aggregator, es infinitamente más limpio y eficiente que intentar enviar un email por cada artículo del pedido.

Caso de Uso 2: Realizar cálculos sobre un conjunto de datos

El Array Aggregator es la herramienta fundamental cuando necesitas no solo agrupar datos, sino también realizar operaciones matemáticas sobre ese conjunto. Mientras que el Text Aggregator es para la presentación, el Array Aggregator es para el cálculo y el manejo de arrays estructurados. Siguiendo con el escenario de e-commerce, supongamos que después de procesar cada línea de pedido con un Iterator, queremos calcular el valor total de los productos vendidos o contar cuántos artículos diferentes había en el pedido.

Aquí te mostramos cómo usar el Array Aggregator para este fin:

1. Trigger e Iterator: El flujo comienza de la misma manera, con un trigger de Shopify y un Iterator en Make que procesa cada Line Item.
2. Array Aggregator: Al final de la ruta del Iterator, añadimos un Array Aggregator.
   • Source Module: Seleccionamos el Iterator.
   • Target structure: Aquí definimos qué queremos recolectar. Podríamos crear una estructura simple para recolectar solo los precios. Mapearíamos la variable price de cada línea de pedido.
   • Resultado del Aggregator: El módulo generará un nuevo array que contendrá únicamente los precios de los artículos. Por ejemplo: [19.99, 49.95, 7.50].
3. Realizar Cálculos: Ahora que tenemos un array numérico limpio, podemos usar las funciones de matemáticas integradas de Make. Añadimos un módulo Set Variable después del agregador.
   • Variable name: totalVenta.
   • Variable value: Usamos la función sum() y le pasamos el array generado por el agregador. La fórmula se vería así: {{sum(4.array)}}, donde 4.array es la referencia al output del Array Aggregator.

El resultado de esta operación será una única variable, totalVenta, con el valor 77.44. Este valor consolidado se puede usar para crear una factura, registrarlo en un sistema contable o enviarlo en una notificación de resumen, demostrando un control de flujo avanzado y una capacidad real para procesar datos de forma inteligente.