Manual n8n: De Cero a Experto

Créditos:
* Solicitado por: Shuberth (mail@shub.sh)

Introducción a n8n: Conceptos Básicos y Visión General

n8n es una potente plataforma de automatización de flujos de trabajo diseñada para conectar diversas aplicaciones y servicios, permitiendo automatizar tareas repetitivas y complejas sin necesidad, en muchos casos, de conocimientos avanzados de programación. Se destaca por ser una herramienta flexible, personalizable y con un fuerte enfoque en la interoperabilidad a través de APIs.

¿Qué es n8n?

n8n (pronunciado "n-eight-n") se define como una herramienta de automatización de flujos de trabajo extensibles. Permite a los usuarios conectar diferentes aplicaciones y servicios para crear cadenas de acciones automatizadas. Sus características principales incluyen:

• Código Abierto (Open-Source): Aunque algunas fuentes mencionan una licencia propietaria junto al código abierto, el núcleo de n8n es open-source. Esto permite a los usuarios inspeccionar, modificar y contribuir al código. Ofrece una gran transparencia y flexibilidad.
• Opciones de Alojamiento: n8n puede ser autoalojado (self-hosted) en servidores propios (locales o en la nube privada) o utilizarse a través de su servicio en la nube (n8n Cloud). El autoalojamiento ofrece control total sobre los datos y la infraestructura, siendo potencialmente más económico para altos volúmenes de ejecución.
• Interfaz Visual e Intuitiva: Utiliza un sistema basado en nodos y conexiones visuales (drag-and-drop) que facilita la creación y comprensión de los flujos de trabajo, incluso para usuarios sin experiencia en programación.
• Extensibilidad y Personalización: Además de la interfaz visual, permite la inclusión de código personalizado (JavaScript, Python) dentro de los flujos, ofreciendo un nivel de personalización muy avanzado para tareas complejas.
• Enfoque API-First: Diseñado para interactuar fácilmente con APIs, simplificando la conexión entre servicios que de otra manera no se comunicarían.
• Capacidades de IA: Integra funcionalidades de Inteligencia Artificial para construir flujos de trabajo más inteligentes y agentes autónomos.

Ilustración: n8n como un hub central conectando diversas aplicaciones para la automatización.

Conceptos Clave

• Flujo de Trabajo (Workflow): Es la secuencia completa de acciones automatizadas. Comienza con un disparador (trigger) y continúa con una serie de nodos de acción conectados.

Ilustración: Representación visual de un flujo de trabajo básico en n8n: Disparador -> Acción 1 -> Acción 2.
* Nodo (Node): Representa una aplicación, servicio o una función específica dentro de un flujo de trabajo. Cada nodo realiza una tarea concreta (leer datos, enviar un email, actualizar una base de datos, etc.).
* Nodo Disparador (Trigger Node): Inicia la ejecución del flujo de trabajo. Puede ser un evento (ej. nuevo email recibido, formulario enviado), una programación horaria (cron), o una llamada manual (webhook).
* Nodo de Acción (Action Node): Ejecuta una tarea específica utilizando los datos recibidos del nodo anterior. n8n ofrece nodos para cientos de aplicaciones y servicios, así como nodos genéricos para lógica (IF, Switch), manipulación de datos, ejecución de código, llamadas HTTP, etc.

Ilustración: Diferencia conceptual entre un Nodo Disparador y un Nodo de Acción.
* Conexión (Connection): Líneas que unen los nodos, definiendo el flujo de datos y el orden de ejecución de las acciones.

• Flujo de Datos (Data Flow): Los datos (generalmente en formato JSON) pasan de un nodo a otro a través de las conexiones. Cada nodo puede modificar, añadir o utilizar estos datos.

Ilustración: Cómo los datos JSON fluyen y se transforman a través de los nodos en n8n.
* Credenciales (Credentials): Permiten a n8n autenticarse de forma segura con las diferentes aplicaciones y servicios utilizados en los flujos de trabajo.

Ilustración: n8n utilizando credenciales seguras para conectar con diversos servicios externos.
* Integraciones: n8n soporta oficialmente cientos de integraciones con aplicaciones populares (Google Sheets, Slack, Discord, OpenAI, bases de datos SQL, CRM, ERP, etc.) y su comunidad contribuye constantemente con nuevas integraciones.

Ventajas Frente a Otras Herramientas (Zapier, Make)

• Control y Privacidad: La opción de autoalojamiento da control total sobre los datos y la seguridad, un punto crucial para muchas empresas.
• Flexibilidad y Personalización: Permite flujos de trabajo más complejos y lógicos, incluyendo la ejecución de código personalizado, superando las limitaciones de plataformas más orientadas a flujos simples.
• Costo: El modelo autoalojado puede ser significativamente más económico, pagando solo por la infraestructura del servidor, sin límites artificiales en el número de flujos o ejecuciones (más allá de la capacidad del servidor). La versión cloud también ofrece planes competitivos.
• Código Abierto: Acceso al código fuente para auditoría, personalización y contribución.
• Comunidad Activa: Una gran comunidad que ofrece soporte, comparte flujos de trabajo y desarrolla nuevas integraciones.

Casos de Uso Comunes

n8n es extremadamente versátil y se puede utilizar para:

• Automatización de Marketing: Sincronizar leads entre CRM y plataformas de email marketing, publicar en redes sociales, generar informes de campañas.
• Ventas y CRM: Automatizar la creación de contactos, seguimiento de oportunidades, notificaciones de ventas.
• Soporte al Cliente: Crear tickets automáticamente desde emails o formularios, notificar a los agentes, sincronizar datos entre plataformas de soporte.
• Recursos Humanos: Automatizar procesos de onboarding, gestión de solicitudes de vacaciones.
• Finanzas: Procesamiento de facturas, recordatorios de pago, sincronización de datos contables.
• Desarrollo y Operaciones (DevOps): Automatizar despliegues, monitorización de sistemas, gestión de incidencias.
• Web Scraping: Extraer datos de sitios web de forma programada.
• Integración de Datos: Mover y transformar datos entre diferentes bases de datos, hojas de cálculo y aplicaciones.

Ilustración: Concepto de n8n sincronizando datos entre una base de datos, una hoja de cálculo y una aplicación en la nube.
* Notificaciones: Enviar alertas personalizadas a través de Slack, Discord, Email, SMS, etc., basadas en eventos específicos.
* Automatización del Hogar (Smart Home): Integrar y controlar dispositivos inteligentes.

Esta visión general sienta las bases para comprender el potencial de n8n. Las siguientes secciones del manual profundizarán en sus nodos, funcionalidades y ejemplos prácticos.

Parte 1: Resumen Rápido de n8n

Esta sección ofrece una visión general y concisa de n8n, ideal para entender rápidamente qué es, qué puede hacer y cómo empezar.

1. ¿Qué es n8n?

n8n es una plataforma de automatización de flujos de trabajo extensible y de código abierto (con opciones de autoalojamiento o en la nube). Permite conectar cientos de aplicaciones y servicios (más de 1047 integraciones confirmadas) para automatizar tareas repetitivas y complejas mediante una interfaz visual basada en nodos, aunque también permite código personalizado para mayor flexibilidad. Sus ventajas clave incluyen el control sobre los datos (especialmente si se autoaloja), una gran personalización y un coste potencialmente inferior a alternativas como Zapier o Make, de las que se diferencia principalmente por su naturaleza open-source y su capacidad para manejar flujos más complejos.

2. Conceptos Fundamentales (Resumen)

• Flujo de Trabajo (Workflow): La secuencia completa de pasos automatizados. Se visualiza en un lienzo donde se conectan nodos.
• Nodo (Node): Un bloque de construcción que representa una aplicación o una función. Realiza una tarea específica.
  • Disparador (Trigger): El nodo que inicia un flujo de trabajo (ej. cada hora, al recibir un webhook, al detectar un evento en una app).
  • Acción (Action): Un nodo que realiza una operación (ej. leer datos, enviar email, actualizar base de datos).
• Conexión (Connection): Las líneas que unen los nodos, definiendo el orden y el flujo de datos (generalmente en formato JSON).
• Credenciales (Credentials): Información de autenticación (API keys, logins) almacenada de forma segura para que n8n acceda a servicios externos.
• Ejecución (Execution): Una única instancia de un flujo de trabajo que se ha ejecutado o se está ejecutando.

3. Visión General de Nodos y Funcionalidades Clave

n8n organiza sus nodos en categorías. Algunos nodos y funcionalidades esenciales incluyen:

• Disparadores Comunes:
  • Webhook: Inicia el flujo al recibir una petición HTTP.
  • Cron: Inicia el flujo en intervalos de tiempo programados.
  • Disparadores Específicos de Apps: (ej. Gmail Trigger, Google Sheets Trigger) Inician flujos basados en eventos de esas apps.
• Servicios Populares (Acciones):
  • HTTP Request: Realiza llamadas a cualquier API REST.
  • Google Sheets: Lee, añade y actualiza filas en hojas de cálculo.
  • Slack/Discord/Telegram: Envía mensajes y notificaciones.
  • OpenAI/AI Agent: Integra capacidades de IA generativa y agentes.
  • MySQL/Postgres/MongoDB: Interactúa con bases de datos.
• Nodos de Lógica y Utilidades:
  • IF/Switch: Dirige el flujo basado en condiciones.
  • Set: Define o modifica datos dentro del flujo.
  • Code (antes Function/Function Item): Ejecuta código JavaScript o Python personalizado.
  • Merge: Combina datos de diferentes ramas del flujo.
• Funcionalidades Destacadas:
  • Debugging Visual: Permite inspeccionar los datos en cada paso.
  • Manejo de Errores: Configura qué hacer si un nodo falla.
  • Expresiones: Permite referenciar y manipular datos de nodos anteriores dinámicamente.
  • Sub-flujos (Execute Workflow): Permite reutilizar flujos de trabajo dentro de otros.

4. Primeros Pasos (Resumen)

Ilustración: Comparativa visual entre n8n Cloud (gestionado, fácil configuración) y n8n Autoalojado (control total, personalizable).

• Uso: Puedes registrarte en n8n Cloud (opción gestionada de pago) o Autoalojar n8n usando Docker (recomendado) o npm en tu propio servidor (gratuito, requiere gestión de infraestructura).
• Crear un Flujo Simple:
  1. Añade un disparador (ej. Manual para empezar).
  2. Añade un nodo de acción (ej. Send Email o Slack).
  3. Conecta los nodos.
  4. Configura las credenciales y los parámetros de cada nodo.
  5. Prueba el flujo (Test step) y actívalo (Activate).

5. ¿Por dónde seguir?

Este resumen cubre lo esencial. Para una comprensión profunda, ejemplos detallados, configuración avanzada, casos de uso complejos y dominio de todas las funcionalidades:

• Consulta la Parte 2: Guía Detallada de este manual.
• Explora la Documentación Oficial de n8n.
• Únete al Foro de la Comunidad de n8n para obtener ayuda y compartir ideas.

Parte 2: Guía Detallada

Bienvenido a la guía detallada de n8n. Esta sección profundiza en cada aspecto de la plataforma, desde sus fundamentos arquitectónicos hasta casos de uso avanzados y desarrollo personalizado. A diferencia del resumen rápido, aquí exploraremos cada concepto con ejemplos prácticos, explicaciones paso a paso y consideraciones importantes para que puedas dominar n8n y aplicarlo eficazmente en tus propios proyectos de automatización.

Capítulo 1: Fundamentos Profundos de n8n

Para utilizar n8n de manera efectiva y solucionar problemas complejos, es crucial comprender su arquitectura subyacente y los conceptos fundamentales que rigen su funcionamiento. Este capítulo sienta las bases para todo lo que sigue.

Arquitectura de n8n

n8n, aunque presenta una interfaz de usuario intuitiva, se compone de varios elementos que trabajan conjuntamente. Comprender estos componentes es especialmente importante si optas por autoalojar n8n.

• Servidor Principal (Main Process): Es el corazón de n8n. Gestiona la interfaz de usuario, almacena las definiciones de los flujos de trabajo y las credenciales (cifradas), y coordina la ejecución de los flujos. Cuando ejecutas un flujo manualmente o se dispara un evento, es el proceso principal el que inicia la ejecución.
• Interfaz de Usuario (UI): Es la aplicación web a la que accedes a través de tu navegador. Permite diseñar visualmente los flujos de trabajo, configurar nodos, gestionar credenciales y monitorizar ejecuciones. Se comunica con el servidor principal a través de una API.
• Base de Datos: n8n necesita una base de datos para persistir la información crucial. Por defecto, utiliza SQLite, que es adecuada para empezar y para instancias pequeñas. Sin embargo, para entornos de producción, especialmente con múltiples usuarios o ejecuciones concurrentes, se recomienda encarecidamente configurar una base de datos externa más robusta como PostgreSQL o MySQL. Aquí se almacenan los flujos de trabajo, las credenciales cifradas, el historial de ejecuciones y la información de los usuarios.
• Cola de Mensajes (Opcional pero Recomendado para Escala): Para manejar un gran volumen de ejecuciones de flujos de trabajo de manera eficiente y fiable, n8n puede configurarse para usar una cola de mensajes externa como Redis. En lugar de que el proceso principal ejecute directamente cada flujo, las tareas de ejecución se añaden a la cola. Esto desacopla la iniciación de la ejecución del procesamiento real.
• Workers (Procesos Trabajadores): Cuando se utiliza una cola de mensajes, los procesos worker son los encargados de tomar las tareas de la cola y ejecutar los flujos de trabajo. Puedes ejecutar múltiples workers, incluso en diferentes máquinas, para escalar horizontalmente la capacidad de procesamiento de n8n. Cada worker ejecuta un flujo de trabajo a la vez.

Esta arquitectura modular permite a n8n ser flexible, desde una configuración simple en una sola máquina hasta despliegues escalables y de alta disponibilidad en entornos empresariales.

Flujos de Trabajo (Workflows): Creación, Edición, Gestión

Un flujo de trabajo es la representación visual de tu proceso automatizado. Es una secuencia de nodos conectados que definen las tareas a realizar y el flujo de datos entre ellas.

• Creación: Para crear un nuevo flujo, simplemente haz clic en el botón "Add workflow" en el panel principal de n8n. Esto abrirá un lienzo en blanco donde puedes empezar a añadir nodos.
• Lienzo (Canvas): Es el espacio principal donde diseñas tu flujo. Puedes arrastrar y soltar nodos desde el panel de nodos (a la derecha o buscándolos), conectarlos y configurar sus parámetros.
• Edición:
  • Añadir Nodos: Busca el nodo deseado en el panel de la derecha o haz clic en el botón '+' en el lienzo. Puedes buscar por nombre de servicio (ej. "Google Sheets", "HTTP Request") o por funcionalidad (ej. "Send email", "Filter data").
  • Conectar Nodos: Haz clic en el pequeño círculo (handle) de salida de un nodo y arrastra la línea hasta el handle de entrada del siguiente nodo. La conexión define el orden de ejecución y cómo fluyen los datos.
  • Configurar Nodos: Haz clic en un nodo para abrir su panel de parámetros a la derecha. Aquí configurarás la operación específica que realizará el nodo (ej. en Google Sheets, si quieres leer, añadir o actualizar filas), las credenciales necesarias y otros parámetros específicos de la operación (ej. el ID de la hoja de cálculo, los datos a insertar).
  • Eliminar Nodos/Conexiones: Selecciona el nodo o la conexión y presiona la tecla Supr o Backspace, o usa el menú contextual (clic derecho).
  • Copiar/Pegar Nodos: Puedes copiar y pegar nodos individuales o grupos de nodos, lo cual es útil para reutilizar configuraciones.
• Gestión:
  • Guardar: n8n guarda automáticamente los cambios, pero es buena práctica asegurarse de que el estado indique "Saved". Puedes forzar el guardado con Ctrl+S / Cmd+S.
  • Activar/Desactivar: Un flujo de trabajo debe estar activo (Active toggle en la esquina superior derecha) para que se ejecute automáticamente (ej. con disparadores Cron o Webhook). Los flujos inactivos solo pueden ejecutarse manualmente.
  • Renombrar: Haz clic en el nombre del flujo (por defecto "My workflow") en la esquina superior izquierda para cambiarlo.
  • Duplicar: Puedes duplicar un flujo existente desde la lista principal de flujos de trabajo.
  • Eliminar: Puedes eliminar flujos de trabajo desde la lista principal.
  • Etiquetas (Tags): Puedes añadir etiquetas a tus flujos para organizarlos mejor, especialmente si tienes muchos.

Nodos: Tipos, Configuración Detallada

Los nodos son los bloques de construcción fundamentales de cualquier flujo de trabajo en n8n.

• Tipos de Nodos:
  • Disparadores (Triggers): Siempre son el primer nodo de un flujo (excepto en sub-flujos). Inician la ejecución del flujo basándose en un evento o una condición. Ejemplos: Cron (basado en tiempo), Webhook (llamada HTTP externa), Google Sheets Trigger (cambio en una hoja), Manual Trigger (inicio manual). Solo puede haber un disparador activo por flujo.
  • Acciones (Actions): Realizan una tarea específica dentro del flujo. La mayoría de los nodos de integración (Google Sheets, Slack, OpenAI) son nodos de acción. También incluyen nodos para lógica (IF, Switch), manipulación de datos (Set, Code) y control de flujo (Merge, Wait).
  • Nodos Principales (Core Nodes): Nodos incorporados que proporcionan funcionalidades esenciales no ligadas a un servicio externo específico. Incluyen disparadores como Cron y Webhook, nodos de lógica como IF y Switch, nodos de manipulación de datos como Set y Code, y nodos de comunicación genéricos como HTTP Request.
  • Nodos de Integración: Nodos específicos para interactuar con servicios de terceros (ej. Gmail, HubSpot, MySQL). Requieren configuración de credenciales.
  • Nodos de Comunidad (Community Nodes): Nodos desarrollados por la comunidad de n8n. Extienden la funcionalidad de n8n a servicios o tareas no cubiertos por los nodos incorporados. Deben instalarse explícitamente y usarse con precaución, evaluando su fiabilidad y seguridad.
• Configuración Detallada:
  • Panel de Parámetros: Al seleccionar un nodo, su panel de configuración aparece a la derecha. Este panel varía significativamente entre nodos.
  • Credenciales: Muchos nodos de integración requieren credenciales. Seleccionarás una credencial existente o crearás una nueva desde este panel. La creación de credenciales a menudo implica seguir un proceso de autenticación (ej. OAuth2 para Google, API Key para OpenAI).
  • Recurso/Operación: La mayoría de los nodos de integración agrupan sus funcionalidades por "Recurso" (ej. en Google Sheets: Spreadsheet, Sheet, Row) y luego por "Operación" (ej. para Row: Append, Get, Update, Delete). Debes seleccionar la combinación adecuada para tu tarea.
  • Parámetros Específicos: Cada operación tendrá sus propios parámetros. Por ejemplo, para añadir una fila a Google Sheets, necesitarás especificar el Spreadsheet ID, Sheet Name y los Columns con sus valores. Estos parámetros a menudo se pueden rellenar con datos estáticos, datos de nodos anteriores (usando expresiones) o una combinación.
  • Opciones (Options/Settings): Muchos nodos tienen una sección de "Options" o "Settings" para configuraciones adicionales. Esto puede incluir cómo manejar múltiples elementos (split out, pair up), qué hacer en caso de error (Continue On Fail), cómo renombrar campos de salida, etc. Es crucial revisar estas opciones.
  • Expresiones: Casi cualquier campo de parámetro puede configurarse usando expresiones, lo que permite utilizar dinámicamente los datos de nodos anteriores. Haz clic en el icono </> o fx junto a un campo para abrir el editor de expresiones.

Conexiones y Flujo de Datos (JSON, Expresiones, Mapeo)

Las conexiones entre nodos no solo definen el orden de ejecución, sino también cómo fluyen los datos.

• Flujo de Datos: n8n pasa datos de un nodo al siguiente. Cada nodo recibe los datos de salida del nodo anterior (o nodos anteriores, en el caso de Merge) como su entrada. Los datos se estructuran generalmente como un array de objetos JSON.
• Formato JSON: Cada elemento en el array representa un "ítem". Un ítem típicamente contiene dos claves principales:
  • json: Un objeto que contiene los datos principales del ítem (ej. los valores de una fila de Google Sheets, los detalles de un email).
  • binary: (Opcional) Un objeto que contiene datos binarios asociados al ítem (ej. el contenido de un archivo descargado). n8n maneja la referencia a estos datos binarios.
• Visualización de Datos: Puedes inspeccionar los datos de entrada y salida de cualquier nodo después de ejecutarlo (o ejecutar el paso con Test step). Haz clic en el nodo y mira las pestañas Input y Output en el panel de resultados. Esto es fundamental para el debugging y para entender cómo construir expresiones.
• Expresiones: Son la clave para hacer que los flujos de trabajo sean dinámicos. Permiten acceder y manipular los datos que fluyen entre nodos.
  • Acceso a Datos: Dentro del editor de expresiones, puedes navegar por la estructura de datos de entrada de los nodos anteriores. La forma más común es usar la notación {{ $json.nombre_del_campo }} para acceder a un campo del objeto json del ítem actual, o {{ $node["Nombre del Nodo"].json.nombre_del_campo }} para acceder a datos de un nodo específico anterior.
  • Variables Globales: n8n proporciona variables útiles como $now (fecha y hora actual), $workflow (información sobre el flujo), $execution (información sobre la ejecución actual).
  • Funciones y Métodos: Las expresiones usan JavaScript. Puedes usar métodos de string (.toUpperCase(), .split()), métodos de array (.map(), .filter()), operadores matemáticos, lógica condicional (operador ternario cond ? val1 : val2), etc.
  • Mapeo de Datos: Las expresiones son esenciales para mapear datos de un formato a otro. Por ejemplo, si recibes datos de un webhook con nombres de campo diferentes a los que espera tu base de datos, usarás expresiones en el nodo de la base de datos para asignar los valores correctos.
• Manejo de Múltiples Ítems: Un nodo puede recibir múltiples ítems (un array de objetos JSON). Por defecto, el siguiente nodo se ejecutará una vez por cada ítem recibido. Puedes cambiar este comportamiento en las opciones del nodo (ej. Execute Once). El nodo Merge es crucial para combinar datos de diferentes ramas o para controlar cómo se agrupan los ítems.

Credenciales: Tipos, Creación, Gestión, Seguridad

Las credenciales almacenan de forma segura la información necesaria para que n8n se autentique con servicios de terceros.

• Tipos Comunes:
  • API Key/Token: Una cadena secreta proporcionada por el servicio (ej. OpenAI, Telegram Bot Token).
  • OAuth2: Un estándar de autorización que implica un flujo de redirección al servicio externo para que el usuario conceda permiso a n8n. n8n maneja el intercambio de tokens y su renovación (ej. Google, HubSpot, Slack).
  • Usuario/Contraseña: Credenciales básicas, menos comunes para APIs modernas pero usadas en algunos casos (ej. acceso a bases de datos, SSH).
  • Header Auth: Autenticación basada en cabeceras HTTP personalizadas.
• Creación:
  • Desde un Nodo: La forma más común es crear la credencial directamente desde el panel de parámetros del nodo que la necesita. Haz clic en el desplegable "Credential" y selecciona "Create New".
  • Desde el Panel de Credenciales: Puedes acceder a "Credentials" desde el menú lateral izquierdo para ver, crear y gestionar todas las credenciales.
  • Proceso de Creación: Seguirás las instrucciones específicas para cada tipo de credencial. Para OAuth2, esto generalmente implica ser redirigido al sitio del servicio para iniciar sesión y autorizar el acceso. Para API Keys, simplemente pegarás la clave proporcionada por el servicio.
• Gestión:
  • Listado: El panel de Credenciales muestra todas las credenciales guardadas.
  • Edición: Puedes editar los detalles de una credencial (aunque a menudo es más fácil recrearla si algo cambia fundamentalmente).
  • Eliminación: Puedes eliminar credenciales que ya no necesites.
• Seguridad:
  • Cifrado: n8n cifra todas las credenciales almacenadas en la base de datos utilizando una clave de cifrado única (N8N_ENCRYPTION_KEY). Esta clave se genera automáticamente la primera vez que se inicia n8n (o puede ser definida manualmente a través de variables de entorno). Es absolutamente crucial hacer una copia de seguridad de esta clave. Sin ella, no podrás descifrar las credenciales si necesitas restaurar la base de datos o migrar la instancia.
  • Acceso Restringido: Solo los nodos diseñados específicamente para usar un cierto tipo de credencial pueden acceder a ella.
  • Variables de Entorno (Recomendado para Producción): En lugar de almacenar la N8N_ENCRYPTION_KEY en el archivo de configuración por defecto, es más seguro definirla como una variable de entorno, especialmente en despliegues con Docker o Kubernetes.

Ejecuciones: Monitorización, Debugging, Logs

Una ejecución representa una única instancia de un flujo de trabajo que se ha disparado y ha corrido (o está corriendo).

• Monitorización:
  • Panel de Ejecuciones ("Executions"): Accesible desde el menú lateral izquierdo, muestra una lista de todas las ejecuciones pasadas y actuales. Puedes ver el estado (Success, Error, Running), la hora de inicio, la duración y el flujo de trabajo asociado.
  • Vista de Ejecución: Al hacer clic en una ejecución específica, se abre el lienzo del flujo de trabajo tal como se ejecutó. Los nodos se resaltan en verde (éxito) o rojo (error). Puedes hacer clic en cada nodo para ver sus datos de entrada y salida específicos para esa ejecución.
• Debugging:
  • Test step: Mientras diseñas, puedes ejecutar un nodo individualmente haciendo clic en "Test step". Esto ejecuta solo ese nodo (y los anteriores si es necesario para obtener datos de entrada) y te muestra inmediatamente la salida. Es la forma más rápida de verificar la configuración de un nodo.
  • Ejecución Manual (Test workflow): Ejecuta todo el flujo desde el disparador (si es un disparador manual o uno que se pueda simular). Te permite ver el flujo completo de datos y cómo interactúan los nodos.
  • Inspección de Datos: La capacidad de ver los datos de Input y Output para cada nodo en una ejecución pasada o de prueba es la herramienta de debugging más potente de n8n.
  • Nodo NoOp: El nodo "No Operation, do nothing" puede ser útil para colocar puntos de interrupción visuales o para terminar ramas lógicas sin errores.
• Logs:
  • Logs de Ejecución: La vista de ejecución proporciona información detallada sobre cada paso. Si un nodo falla, el mensaje de error se mostrará claramente.
  • Logs del Servidor: Si estás autoalojando n8n, los logs del propio servidor (visibles a través de Docker logs o en la consola donde se ejecuta n8n) pueden proporcionar información adicional sobre errores de sistema, problemas de conexión a la base de datos, etc.
  • Niveles de Log: Puedes configurar el nivel de detalle de los logs de n8n a través de variables de entorno (ej. N8N_LOG_LEVEL=debug) para obtener más información durante la resolución de problemas.

Comprender estos fundamentos te permitirá no solo construir flujos de trabajo, sino también entender por qué funcionan (o no funcionan) y cómo optimizarlos y escalarlos eficazmente.

Capítulo 2: Instalación y Configuración

Ahora que comprendemos los fundamentos de n8n, el siguiente paso es ponerlo en marcha. Este capítulo cubre las diferentes formas de instalar y configurar n8n, desde la opción más sencilla en la nube hasta el autoalojamiento avanzado, junto con la configuración inicial esencial.

Opciones de Instalación

n8n ofrece flexibilidad en cómo puedes ejecutarlo:

• n8n Cloud:
  • Descripción: La oferta oficial de Software como Servicio (SaaS) de n8n. Es la forma más rápida y sencilla de empezar, ya que n8n gestiona toda la infraestructura (servidores, bases de datos, actualizaciones, seguridad).
  • Ventajas: Configuración instantánea, mantenimiento cero, escalabilidad gestionada, soporte oficial.
  • Desventajas: Menos control sobre el entorno, planes de precios basados en el uso (ejecuciones, flujos de trabajo activos), los datos pasan por los servidores de n8n (aunque las credenciales siguen cifradas).
  • Ideal para: Usuarios que quieren empezar rápidamente, equipos pequeños, aquellos que no quieren gestionar infraestructura.
  • Proceso: Simplemente regístrate en n8n.io, elige un plan y tendrás acceso inmediato a tu instancia de n8n.
• Autoalojamiento (Self-Hosting):
  • Descripción: Ejecutas n8n en tu propia infraestructura (tu ordenador local, un servidor privado virtual (VPS), un servidor dedicado, o en tu propia nube privada).
  • Ventajas: Control total sobre el entorno y los datos, potencialmente más económico a escala (solo pagas por la infraestructura), sin límites artificiales en ejecuciones o flujos (solo los de tu hardware), personalización avanzada.
  • Desventajas: Requiere conocimientos técnicos para la instalación, configuración, mantenimiento, actualizaciones y seguridad. Eres responsable de la escalabilidad y la disponibilidad.
  • Ideal para: Usuarios con requisitos estrictos de soberanía de datos, aquellos con conocimientos técnicos, empresas que necesitan integraciones profundas con sistemas internos, uso intensivo que haría costoso el plan Cloud.

Autoalojamiento: Métodos Detallados

Si eliges autoalojar, tienes varias opciones:

• Docker (Recomendado):
  • Descripción: Docker es una plataforma de contenedorización que empaqueta n8n y sus dependencias en una unidad aislada llamada contenedor. Es el método preferido y más soportado para autoalojar n8n.
  • Ventajas: Instalación y actualizaciones simplificadas, entorno consistente y reproducible, aislamiento de dependencias, fácil de escalar (con Docker Compose o Kubernetes).
  • Requisitos: Tener Docker y Docker Compose instalados en tu máquina/servidor.
  • Proceso Básico (con Docker Compose):
    1. Crear Directorio: Crea un directorio para tus datos de n8n (ej. ~/n8n-data).
    2. Crear docker-compose.yml: Crea un archivo docker-compose.yml en un directorio de tu elección con un contenido similar a este (consulta la documentación oficial para la versión más reciente y opciones avanzadas):
       
       
       

       version: '3.7'
       
       services:
         n8n:
           image: n8nio/n8n
           restart: always
           ports:
             - "5678:5678"
           environment:
             # Variables de entorno esenciales y opcionales (ver sección de configuración)
             - N8N_HOST=${SUBDOMAIN}.${DOMAIN_NAME}
             - N8N_PORT=5678
             - N8N_PROTOCOL=https
             - NODE_ENV=production
             - WEBHOOK_URL=https://${SUBDOMAIN}.${DOMAIN_NAME}/
             - GENERIC_TIMEZONE=${GENERIC_TIMEZONE} # Ej: Europe/Berlin
             # - N8N_ENCRYPTION_KEY=tu_clave_secreta_muy_larga # ¡Importante para producción!
           volumes:
             - ~/.n8n:/home/node/.n8n # Monta el volumen para persistencia
           # Opcional: Red específica si usas proxy inverso
           # networks:
           #   - n8n-network
       
       # Opcional: Definición de red
       # networks:
       #   n8n-network:
       #     external: true
       
       
       
       

    3. Configurar Variables de Entorno: Define las variables de entorno necesarias (como SUBDOMAIN, DOMAIN_NAME, GENERIC_TIMEZONE) ya sea exportándolas en tu terminal, usando un archivo .env en el mismo directorio del docker-compose.yml, o reemplazándolas directamente en el archivo.
    4. Iniciar Contenedor: Ejecuta docker-compose up -d en el directorio donde está tu docker-compose.yml.
    5. Acceso: Accede a n8n a través de http://localhost:5678 (o la URL configurada si usas un proxy inverso).

Ilustración: Concepto general de la instalación de n8n usando Docker.
* Persistencia: El volume - ~/.n8n:/home/node/.n8n es crucial. Mapea el directorio .n8n dentro del contenedor (donde n8n guarda sus datos) a un directorio en tu máquina host (~/.n8n en este ejemplo). Esto asegura que tus flujos de trabajo y credenciales persistan incluso si el contenedor se detiene y se reinicia.
* Actualizaciones: Para actualizar, generalmente ejecutas docker-compose pull n8n y luego docker-compose up -d.
* npm:
* Descripción: Instalar n8n directamente usando el gestor de paquetes de Node.js.
* Ventajas: Puede ser más simple si ya tienes Node.js y npm configurados y no quieres usar Docker.
* Desventajas: Gestionar las dependencias de Node.js puede ser más complejo, menos aislamiento que Docker, las actualizaciones pueden requerir más pasos manuales.
* Requisitos: Tener Node.js (versión LTS recomendada) y npm instalados.
* Proceso:
1. Instalar n8n globalmente: npm install n8n -g
2. Iniciar n8n: Simplemente ejecuta n8n en tu terminal.
3. Persistencia: Por defecto, n8n creará un directorio .n8n en tu directorio home (~/.n8n) para almacenar los datos.
* n8n AI Starter Kit (Docker):
* Descripción: Un paquete preconfigurado por n8n que utiliza Docker Compose para desplegar n8n junto con otras herramientas útiles para casos de uso de IA, como un LLM local (Ollama) y una base de datos vectorial (Qdrant).
* Ventajas: Configuración rápida para experimentar con las capacidades de IA de n8n sin depender completamente de APIs externas.
* Proceso: Clona el repositorio de GitHub (git clone https://github.com/n8n-io/self-hosted-ai-starter-kit.git), sigue las instrucciones del README.md para configurar las variables de entorno (en .env) y ejecuta docker compose up -d.
* Kubernetes (Avanzado):
* Descripción: Para despliegues a gran escala, de alta disponibilidad y con orquestación avanzada, puedes desplegar n8n en un clúster de Kubernetes usando Helm Charts proporcionados por la comunidad o configuraciones personalizadas.
* Ventajas: Máxima escalabilidad, resiliencia, gestión centralizada.
* Desventajas: Requiere experiencia significativa con Kubernetes.

Configuración Inicial Esencial

Independientemente del método de instalación (especialmente para autoalojamiento), hay varias variables de entorno y configuraciones importantes:

• Variables de Entorno Clave (para Docker/npm):
  • N8N_HOST: El nombre de host con el que se accederá a n8n (ej. n8n.midominio.com). Crucial para que los webhooks y redirecciones OAuth funcionen correctamente.
  • N8N_PORT: El puerto en el que n8n escucha (por defecto 5678).
  • N8N_PROTOCOL: El protocolo utilizado para acceder a n8n (http o https - usa https en producción).
  • NODE_ENV: Establecer en production para optimizaciones y seguridad.
  • WEBHOOK_URL: La URL base pública para los webhooks (ej. https://n8n.midominio.com/). Debe coincidir con cómo se accede a n8n desde el exterior.
  • GENERIC_TIMEZONE: La zona horaria en la que operará tu instancia de n8n (ej. America/New_York, Europe/Paris). Importante para la programación de Cron y el manejo de fechas.
  • N8N_ENCRYPTION_KEY (¡MUY IMPORTANTE!):
    • Una cadena aleatoria y secreta utilizada para cifrar las credenciales.
    • Si no se establece, n8n genera una automáticamente y la guarda en el archivo config dentro del volumen .n8n.
    • En producción, DEBES establecer esta variable explícitamente con una clave segura que generes tú mismo y guardarla en un lugar seguro (gestor de contraseñas). Si pierdes esta clave, perderás el acceso a todas tus credenciales.
    • Debe ser una cadena de al menos 32 caracteres.
• Configuración de Base de Datos (Opcional pero Recomendado):
  • Por defecto, n8n usa SQLite. Para producción, configura una base de datos externa (PostgreSQL o MySQL) usando variables de entorno como:
    • DB_TYPE=postgresdb (o mysqldb)
    • DB_POSTGRESDB_HOST=tu_host_db
    • DB_POSTGRESDB_PORT=5432
    • DB_POSTGRESDB_DATABASE=n8n
    • DB_POSTGRESDB_USER=n8n_user
    • DB_POSTGRESDB_PASSWORD=tu_contraseña_db
• Configuración de Cola (Opcional para Escala):
  • Para habilitar la ejecución basada en colas y workers, configura variables como:
    • QUEUE_BULL_ENABLE=true
    • QUEUE_BULL_REDIS_HOST=tu_host_redis
    • QUEUE_BULL_REDIS_PORT=6379
    • QUEUE_BULL_REDIS_PASSWORD=tu_contraseña_redis (si aplica)
  • Luego, necesitarás iniciar procesos worker separados (consulta la documentación de n8n sobre "Scaling n8n").
• Proxy Inverso (Recomendado para Producción):
  • En lugar de exponer n8n directamente a Internet en el puerto 5678, es una práctica estándar usar un proxy inverso (como Nginx, Caddy, Traefik).
  • Beneficios:
    • Terminación SSL/TLS: El proxy maneja el cifrado HTTPS, permitiendo que n8n se ejecute internamente sobre HTTP.
    • Gestión de Dominios/Subdominios: Dirige el tráfico del dominio público a la instancia de n8n.
    • Balanceo de Carga: Si tienes múltiples instancias de n8n (para alta disponibilidad), el proxy puede distribuir la carga.
    • Seguridad Adicional: Puede proporcionar capas adicionales de seguridad (ej. WAF, limitación de tasa).
  • Configuración: Configura tu proxy inverso para redirigir el tráfico de tu dominio/subdominio público (ej. https://n8n.midominio.com) al host y puerto donde se ejecuta n8n (ej. http://localhost:5678). Asegúrate de que las variables N8N_HOST, N8N_PROTOCOL y WEBHOOK_URL en la configuración de n8n reflejen la URL pública.
• Gestión de Usuarios (Opcional):
  • Por defecto, n8n autoalojado no tiene gestión de usuarios habilitada. Cualquiera que pueda acceder a la URL puede usarlo.
  • Puedes habilitar la autenticación de usuarios y la gestión básica de usuarios a través de variables de entorno. Consulta la documentación sobre N8N_BASIC_AUTH_ACTIVE, N8N_BASIC_AUTH_USER, N8N_BASIC_AUTH_PASSWORD y la gestión de usuarios más avanzada.

Verificación Post-Instalación

Una vez instalado y configurado n8n:

1. Accede a la Interfaz: Abre la URL de tu instancia n8n en un navegador.
2. Crea un Flujo Simple: Intenta crear un flujo de trabajo básico, por ejemplo, con un disparador Manual y un nodo Respond to Webhook. Ejecútalo manualmente para asegurarte de que el núcleo funciona.
3. Prueba un Webhook: Crea un flujo con un disparador Webhook. Copia la URL de prueba y envíale una solicitud (usando curl o una herramienta como Postman). Verifica que la ejecución se registre en n8n.
4. Configura y Prueba Credenciales: Intenta configurar una credencial para un servicio que uses (ej. Google Sheets si tienes una cuenta) y ejecuta un nodo simple que la utilice (ej. List Spreadsheets).
5. Verifica la Zona Horaria: Crea un flujo con Cron y un nodo Code que devuelva {{ $now.toISO() }}. Ejecútalo y verifica que la hora refleje la zona horaria que configuraste.

Superar estos pasos confirma que tu instancia de n8n está correctamente instalada, configurada y lista para empezar a automatizar.

Capítulo 3: Explorando la Interfaz de Usuario (UI)

La interfaz de usuario de n8n es donde pasarás la mayor parte del tiempo diseñando, probando y gestionando tus flujos de trabajo. Aunque es intuitiva, conocer a fondo sus componentes y funcionalidades te permitirá trabajar de manera más eficiente.

Vista General del Dashboard

Al iniciar sesión en tu instancia de n8n (Cloud o autoalojada), lo primero que verás es el dashboard principal. Este actúa como tu centro de control.

• Menú Lateral Izquierdo: Proporciona acceso rápido a las secciones principales:
  • Workflows: Lista todos tus flujos de trabajo. Aquí puedes crearlos, abrirlos, activarlos/desactivarlos, etiquetarlos, duplicarlos y eliminarlos.
  • Executions: Muestra el historial de todas las ejecuciones de flujos de trabajo. Puedes filtrar por estado (Success, Error, Running), flujo de trabajo o rango de fechas.
  • Credentials: Gestiona todas tus credenciales guardadas para servicios de terceros.
  • Variables: (Si está habilitado) Permite definir variables globales que pueden ser usadas en tus flujos.
  • Templates: Acceso a plantillas de flujos de trabajo predefinidas por n8n y la comunidad.
  • Settings: Acceso a la configuración de la instancia (usuarios, personalización, etc. - más opciones disponibles para administradores en instancias autoalojadas).
• Área Principal: Generalmente muestra una vista rápida de tus flujos de trabajo recientes o favoritos, y botones para crear nuevos flujos o explorar plantillas.
• Barra Superior: Contiene el logo de n8n (que a menudo te devuelve al dashboard), un campo de búsqueda global (para buscar flujos, nodos, etc.), y opciones de perfil/cuenta.

Ilustración: Vista general del Editor UI de n8n, mostrando el lienzo, paneles y barras principales.

El Editor de Flujos de Trabajo (Canvas)

Esta es el área principal donde construyes tus automatizaciones.

• Lienzo (Canvas):

  
  Ilustración: El lienzo (Canvas) es el área principal para construir el flujo de trabajo.

  El espacio central donde arrastras, conectas y organizas los nodos. Puedes hacer zoom (rueda del ratón o trackpad) y paneo (arrastrar con el botón central del ratón o mantener presionada la barra espaciadora y arrastrar).

• Panel de Nodos:

  
  Ilustración: El panel de nodos, donde puedes buscar y seleccionar nodos para añadir al flujo.

  Situado a la derecha (por defecto, puede minimizarse). Contiene:

  • Barra de Búsqueda: La forma más rápida de encontrar un nodo. Empieza a escribir el nombre del servicio (ej. "Slack") o la función (ej. "HTTP").
  • Categorías: Los nodos están organizados lógicamente (Triggers, Core, por servicio, etc.).
  • Arrastrar y Soltar: Haz clic y arrastra un nodo desde este panel al lienzo para añadirlo.
• Panel de Parámetros: Aparece a la derecha cuando seleccionas un nodo en el lienzo. Aquí configuras todo lo relacionado con ese nodo: credenciales, operación, campos específicos, opciones.
• Panel de Resultados: Aparece en la parte inferior cuando ejecutas un nodo (Test step) o un flujo completo (Test workflow). Muestra los datos de entrada (Input), salida (Output) y errores (Error) del nodo seleccionado. Es esencial para el debugging.
  • Vistas de Datos: Puedes ver los datos en formato de Tabla, JSON o Esquema (Schema). La vista JSON es a menudo la más útil para entender la estructura exacta de los datos para las expresiones.
  • Navegación entre Nodos: Puedes hacer clic en diferentes nodos en el lienzo para ver sus respectivos resultados en este panel.
• Barra de Herramientas del Lienzo: Generalmente en la esquina inferior derecha, ofrece controles para:
  • Zoom: Acercar y alejar.
  • Ajustar a Pantalla: Centra y ajusta el zoom para mostrar todo el flujo.
  • Activar/Desactivar Nodos: Puedes desactivar temporalmente un nodo sin eliminarlo (útil para pruebas).
  • Añadir Nota Adhesiva (Sticky Note): Permite añadir comentarios o explicaciones directamente en el lienzo.

• Barra Superior del Editor:

  
  Ilustración: Detalle de la barra superior del editor.

  • Nombre del Flujo: Haz clic para editar.
  • Estado de Guardado: Indica si hay cambios sin guardar (aunque el autoguardado suele ser rápido).
  • Botones Test workflow / Execute workflow: Inicia una ejecución manual del flujo completo.
  • Interruptor Active / Inactive: Controla si el flujo se ejecutará automáticamente según su disparador.
  • Menú de Opciones (...): Acceso a acciones como guardar manualmente, descargar el flujo (como JSON), ver ejecuciones pasadas, duplicar, eliminar.

Gestión de Nodos en el Lienzo

• Selección: Haz clic en un nodo para seleccionarlo.
  Mantén Shift y haz clic para seleccionar múltiples nodos.
  Arrastra un cuadro de selección alrededor de varios nodos.
• Movimiento: Haz clic y arrastra un nodo seleccionado (o un grupo de nodos) para moverlo.
• Conexión: Haz clic en el punto de salida (derecha) de un nodo y arrastra hasta el punto de entrada (izquierda) de otro.
• Desconexión: Haz clic en una conexión para seleccionarla y presiona Supr/Backspace, o haz clic derecho y elige "Delete".
• Configuración Rápida: Pasa el ratón sobre un nodo para ver botones rápidos para probar (Test step), desactivar/activar o eliminar.
• Menú Contextual: Haz clic derecho sobre un nodo o el lienzo para acceder a opciones como copiar, pegar, duplicar, eliminar, desactivar, añadir nota.

Ilustración: Detalle del panel lateral izquierdo, mostrando acceso a Flujos, Credenciales, Ejecuciones, Plantillas y Configuración.

Panel de Credenciales

Accesible desde el menú lateral izquierdo.

• Listado: Muestra todas las credenciales que has configurado, agrupadas por tipo de servicio.
• Crear Nueva: Botón para añadir una nueva credencial. Te pedirá seleccionar el tipo de servicio y luego te guiará por el proceso de configuración específico (API Key, OAuth2, etc.).
• Filtrar/Buscar: Puedes buscar credenciales por nombre o tipo.
• Acciones por Credencial: Cada credencial listada tiene opciones para editar (limitado) o eliminar.

Panel de Ejecuciones

Accesible desde el menú lateral izquierdo.

• Listado: Muestra las ejecuciones recientes. Columnas clave: Status, Workflow, Started, Duration.
• Filtrado: Puedes filtrar la lista por:
  • Estado: All, Success, Error, Running.
  • Flujo de Trabajo: Selecciona un flujo específico.
  • Rango de Fechas: Define un período de tiempo.
• Abrir Ejecución: Haz clic en una fila para abrir la vista detallada de esa ejecución en el editor de flujos, mostrando el estado de cada nodo y sus datos de entrada/salida para esa ejecución específica.
• Acciones: Puedes seleccionar ejecuciones y eliminarlas (útil para limpiar el historial, pero úsalo con cuidado).

Panel de Plantillas (Templates)

Accesible desde el menú lateral izquierdo.

• Exploración: Muestra una gran colección de flujos de trabajo predefinidos creados por n8n y la comunidad.
• Búsqueda y Filtrado: Puedes buscar plantillas por palabra clave, aplicación integrada o categoría (ej. AI, Marketing, Sales).
• Usar Plantilla: Al seleccionar una plantilla, puedes ver su descripción, los nodos que utiliza y un botón para "Use this workflow". Al hacer clic, se creará una copia de la plantilla como un nuevo flujo de trabajo en tu instancia, listo para que lo configures con tus propias credenciales y lo adaptes a tus necesidades.
• Contribución: Enlaces para aprender a compartir tus propios flujos de trabajo como plantillas para la comunidad.

Panel de Configuración (Settings)

Accesible desde el menú lateral izquierdo. Las opciones disponibles pueden variar dependiendo de si usas n8n Cloud o una instancia autoalojada, y si eres administrador.

• Perfil/Cuenta: Gestiona tu información de usuario.
• Usuarios: (Admin en autoalojado/planes Cloud específicos) Gestiona los usuarios que pueden acceder a la instancia.
• Personalización (Appearance): Cambia el tema (claro/oscuro), y en algunos planes/autoalojado, personaliza el logo y los colores.
• Variables: Define variables globales.
• Información de la Instancia (Instance Info): (Admin) Muestra detalles sobre la versión de n8n, ID de la instancia y configuración.
• Gestión de Etiquetas (Tags): Crea y gestiona las etiquetas que puedes asignar a los flujos de trabajo.

Dominar la navegación y el uso eficiente de estos paneles y herramientas en la interfaz de usuario es clave para construir y mantener tus automatizaciones en n8n de forma productiva.

Capítulo 4: Categorías Principales de Nodos (según Interfaz)

Cuando comienzas a construir flujos de trabajo en n8n, notarás que al añadir un nuevo nodo, la interfaz te presenta varias categorías principales para ayudarte a encontrar lo que necesitas. Estas categorías agrupan los nodos según su función general. Comprender estas categorías te facilitará la navegación y la selección de las herramientas adecuadas para tus automatizaciones. Basándonos en la interfaz común y la documentación, exploremos estas categorías principales (anteriormente Capítulo 3, renumerado para coherencia):

1. Disparadores (Triggers / Add another trigger)

• Propósito: Los nodos disparadores son el punto de partida de cualquier flujo de trabajo. Inician la ejecución del workflow en respuesta a un evento específico, una programación o una llamada manual.
• Descripción: Un flujo de trabajo debe tener al menos un disparador para poder activarse automáticamente. Puedes tener múltiples disparadores en un mismo flujo; el que reciba el evento o cumpla la condición de tiempo será el que inicie esa ejecución particular.
• Tipos Comunes:
  • Basados en Eventos: Reaccionan a eventos en aplicaciones externas (ej. Webhook, Google Sheets Trigger, Slack Trigger, GitHub Trigger, Notion Trigger). Estos nodos suelen requerir configuración en la aplicación externa para enviar notificaciones (webhooks) a n8n.
  • Programados: Se ejecutan en intervalos de tiempo definidos (ej. Cron para ejecuciones diarias, horarias, etc.).
  • Manuales/Otros: Se inician por una acción directa (ej. Execute Workflow Trigger para llamar a un sub-flujo, Form Trigger para formularios embebidos, Webhook para llamadas API directas).
• Consideraciones: La elección del disparador depende de cómo quieres que se inicie tu automatización. Los webhooks son eficientes para respuestas en tiempo real, mientras que Cron es ideal para tareas periódicas.

2. Acción en una App (Action in an app / Integrations)

• Propósito: Esta es la categoría más extensa y representa el núcleo de las integraciones de n8n. Contiene nodos que interactúan con servicios y aplicaciones externas específicas para realizar acciones concretas.
• Descripción: Cada nodo en esta categoría está diseñado para comunicarse con la API de un servicio particular (como Google Sheets, Telegram, Notion, Slack, HubSpot, bases de datos SQL, etc.). Permiten leer, escribir, actualizar o eliminar datos, enviar mensajes, gestionar archivos y mucho más, dependiendo de las capacidades de la API del servicio.
• Ejemplos: Google Sheets (leer/escribir filas), Slack (enviar mensaje), Postgres (ejecutar consulta SQL), HTTP Request (interactuar con cualquier API REST), OpenAI (generar texto/imagen), HubSpot (gestionar contactos).
• Organización: Dentro de n8n, esta categoría suele estar subdividida por el nombre del servicio (ej. Google, Slack, AWS) o por funcionalidad (ej. CRM, Bases de Datos, Comunicación).
• Credenciales: Casi todos estos nodos requieren configurar credenciales (API Keys, OAuth2) para autenticarse con el servicio externo.

3. Flujo (Flow)

• Propósito: Estos nodos controlan la lógica y la dirección de la ejecución dentro de tu flujo de trabajo. Permiten tomar decisiones, combinar datos de diferentes ramas, ejecutar bucles o llamar a otros flujos.
• Descripción: Son nodos fundamentales para crear automatizaciones que no sean simplemente lineales. Permiten manejar diferentes escenarios y estructurar procesos complejos.
• Nodos Clave:
  • IF: Divide el flujo en dos ramas (true/false) basándose en una condición.
  • Switch: Divide el flujo en múltiples ramas basándose en el valor de una expresión (similar a un if/else if/else).
  • Merge: Combina ítems de diferentes ramas de entrada en una sola salida. Tiene varios modos (Append, Combine, Wait, Pass-through) para diferentes escenarios de fusión.
  • Execute Workflow: Llama a otro flujo de trabajo (sub-flujo), pasando datos y recibiendo resultados. Útil para modularizar y reutilizar lógica.
  • Loop Over Items (anteriormente implícito o con SplitInBatches + Merge): Aunque la iteración es a menudo implícita, nodos específicos o combinaciones permiten controlar bucles de forma más explícita o procesar ítems uno por uno si es necesario.
  • Wait: Pausa la ejecución del flujo durante un tiempo determinado o hasta una hora específica.
• Caso de Uso: Enviar una notificación diferente si un cliente es VIP (IF), procesar pedidos de diferentes regiones por separado (Switch), recopilar resultados de búsquedas paralelas (Merge), ejecutar una rutina de limpieza reutilizable (Execute Workflow).

4. Transformación de Datos (Data transformation)

• Propósito: Estos nodos se centran en manipular, filtrar, convertir y reestructurar los datos a medida que pasan por el flujo de trabajo.
• Descripción: A menudo, los datos que recibes de un nodo no están en el formato exacto que necesita el siguiente. Los nodos de transformación te permiten ajustar la estructura y el contenido de los datos.
• Nodos Clave:
  • Set: Añade, modifica o elimina campos en los ítems de datos. Permite usar expresiones para calcular nuevos valores.
  • Edit Fields: Una interfaz más visual para renombrar, eliminar, convertir tipos de datos o establecer valores fijos para los campos.
  • Item Lists: Realiza operaciones sobre listas de ítems, como sumar valores, dividir, ordenar, filtrar, agrupar.
  • Code: Permite escribir código JavaScript o Python personalizado para realizar transformaciones complejas que no son fáciles con otros nodos.
  • Spreadsheet File: Lee o escribe datos desde/hacia archivos de hoja de cálculo (Excel, ODS) locales.
  • Filter: Permite pasar solo los ítems que cumplen ciertas condiciones, descartando los demás.
  • Remove Duplicates: Elimina ítems duplicados basándose en campos específicos.
• Caso de Uso: Formatear una fecha, calcular un total sumando precios, extraer solo la dirección de correo electrónico de un texto, convertir un número a cadena, combinar nombre y apellido en un solo campo.

5. Núcleo (Core)

• Propósito: Esta categoría agrupa nodos fundamentales que proporcionan funcionalidades básicas o interactúan con el propio sistema n8n, y que no encajan estrictamente en las otras categorías.
• Descripción: Son herramientas esenciales para construir flujos de trabajo, manejar la ejecución o interactuar con APIs genéricas.
• Nodos Clave:
  • HTTP Request: Uno de los nodos más versátiles. Permite realizar llamadas a cualquier API REST (GET, POST, PUT, DELETE, etc.), incluso si no existe un nodo de integración específico.
  • Webhook: Actúa como un disparador esperando llamadas HTTP entrantes, pero también puede usarse como un nodo de acción para enviar datos a otra URL (aunque HTTP Request es más común para esto).
  • Code: (También listado en Transformación) Permite ejecutar código JS/Python.
  • Execute Command: Ejecuta comandos de shell en el servidor donde corre n8n (si está permitido).
  • Start: El nodo inicial por defecto en cualquier flujo nuevo, aunque generalmente se reemplaza por un disparador específico.
  • Static Data: Almacena datos estáticos (JSON) que pueden ser referenciados en otras partes del flujo, útil para configuraciones.
  • No Operation, do nothing: Un nodo vacío que no hace nada, útil como placeholder o para terminar ramas de IF/Switch.
  • n8n Trigger: Dispara un flujo cuando la instancia de n8n se inicia/reinicia o un flujo se activa/actualiza.
• Caso de Uso: Conectar a una API interna, ejecutar un script local, probar un flujo, iniciar un flujo al arrancar n8n.

6. IA Avanzada (Advanced AI)

• Propósito: Esta categoría se enfoca en nodos y funcionalidades relacionadas con la Inteligencia Artificial, especialmente modelos de lenguaje grandes (LLMs) y agentes.
• Descripción: Permite construir flujos de trabajo que pueden entender y generar lenguaje natural, resumir texto, buscar información semánticamente, e incluso tomar decisiones y realizar acciones de forma autónoma (agentes).
• Nodos Clave / Conceptos:
  • Integraciones LLM: Nodos para interactuar con APIs de IA como OpenAI, Anthropic, Google Gemini, Hugging Face Inference.
  • Bases de Datos Vectoriales: Nodos para Pinecone, Qdrant, Weaviate, etc., usados para almacenar y buscar embeddings (representaciones numéricas de texto/datos) para búsqueda semántica o RAG (Retrieval-Augmented Generation).
  • Nodos de Procesamiento de Lenguaje: Nodos para tareas como Summarization, Text Classification, Embeddings Generation.
  • Agentes (Agents): Nodos como Langchain Agent o el AI Agent nativo de n8n. Estos nodos permiten a un LLM usar otras herramientas (otros nodos de n8n, como HTTP Request, Google Search, etc.) para realizar tareas complejas. El agente recibe un objetivo, planifica los pasos, utiliza las herramientas disponibles y genera una respuesta final.
  • Cluster Nodes: Algunos nodos de IA funcionan como "clusters", donde un nodo raíz (ej. AI Agent) se conecta a sub-nodos que definen el LLM, las herramientas, la memoria, etc.
• Caso de Uso: Crear un chatbot que responda preguntas basadas en documentos internos (RAG), resumir automáticamente artículos largos, clasificar correos electrónicos entrantes, construir un agente que pueda reservar reuniones buscando disponibilidad en un calendario.

7. Humano en el Bucle (Human in the loop / HITL)

• Propósito: Introduce puntos de pausa en un flujo de trabajo donde se requiere intervención o aprobación humana antes de continuar.
• Descripción: No todas las automatizaciones pueden o deben ser 100% automáticas. A veces, se necesita una revisión, una decisión o una entrada de datos por parte de una persona.
• Nodos Clave:
  • Wait for Webhook (usado en patrones HITL): Puede esperar una llamada externa que indique la aprobación o el rechazo.
  • Nodos Específicos de HITL (si disponibles): Algunas versiones o implementaciones pueden tener nodos dedicados que envían una notificación (ej. email, Slack) con opciones de aprobación/rechazo y pausan el flujo hasta recibir la respuesta.
  • Patrones Comunes: Enviar un mensaje (Slack, Email) con enlaces especiales (webhooks) que, al ser clickeados, reanudan el flujo por una rama de aprobación o rechazo.
• Caso de Uso: Solicitar aprobación antes de enviar un correo masivo, permitir a un usuario revisar un resumen generado por IA antes de publicarlo, pedir confirmación antes de eliminar datos importantes.

Comprender estas categorías te da una visión estructurada de las capacidades de n8n y te ayuda a pensar en cómo combinar diferentes tipos de nodos para construir las automatizaciones que necesitas.

Capítulo 5: Nodos Principales (Core Nodes) en Detalle

Los Nodos Principales (Core Nodes) son la columna vertebral de la mayoría de los flujos de trabajo en n8n. A diferencia de los nodos de integración, no se conectan a un servicio externo específico (con la excepción notable del HTTP Request), sino que proporcionan funcionalidades esenciales para iniciar flujos, controlar la lógica, manipular datos y gestionar el flujo de ejecución. Dominar estos nodos es crucial para construir automatizaciones robustas y flexibles.

Disparadores (Triggers)

Los disparadores inician la ejecución de un flujo de trabajo.

• Manual / Start:
  • Propósito: Es el disparador por defecto al crear un nuevo flujo. No inicia ejecuciones automáticamente; solo sirve como punto de partida para ejecuciones manuales (Test workflow / Execute workflow).
  • Configuración: No tiene parámetros configurables.
  • Caso de Uso: Ideal para flujos que solo se ejecutan bajo demanda desde la interfaz de n8n, o como punto de partida mientras se desarrolla y prueba un flujo antes de añadir un disparador automático.
• Cron:
  • Propósito: Inicia el flujo de trabajo en intervalos de tiempo programados (ej. cada hora, todos los lunes a las 9 AM, el primer día de cada mes).
  • Configuración:
    • Mode:
      • Every Minute/Hour/Day/Week/Month/Year: Modos predefinidos fáciles de configurar.
      • Custom: Permite definir una expresión CRON estándar para programaciones complejas (ej. 0 9 * * 1-5 para ejecutar de lunes a viernes a las 9:00 AM).
    • Timezone: Selecciona la zona horaria correcta para asegurar que el CRON se ejecute en el momento esperado.
  • Salida: No produce datos de salida significativos, solo información sobre la ejecución.
  • Caso de Uso: Tareas periódicas como generar informes diarios, sincronizar datos cada hora, enviar recordatorios semanales.
• Webhook:
  • Propósito: Inicia el flujo de trabajo cuando n8n recibe una solicitud HTTP (GET, POST, PUT, etc.) en una URL específica.
  • Configuración:
    • Authentication: None, Header Auth, Basic Auth (para proteger el webhook).
    • HTTP Method: GET, POST, PUT, DELETE, PATCH.
    • Path: La ruta única para este webhook (ej. my-custom-webhook). La URL completa será https://tu-n8n-url/webhook/tu-path (para producción) o https://tu-n8n-url/webhook-test/tu-path (para pruebas).
    • Response Mode:
      • On Received: Responde inmediatamente a la solicitud HTTP (útil para webhooks que no esperan una respuesta compleja).
      • Using 'Respond to Webhook' node: Permite construir una respuesta personalizada más adelante en el flujo usando el nodo Respond to Webhook.
    • Options: Configuración para manejo de datos binarios, respuesta en caso de error, etc.
  • Salida: Los datos de la solicitud HTTP recibida:
    • $json.headers: Cabeceras de la solicitud.
    • $json.params: Parámetros de la ruta (si se definen en el path, ej. /webhook/:id).
    • $json.query: Parámetros de la URL (query string).
    • $json.body: Cuerpo de la solicitud (para POST, PUT, PATCH).
  • Caso de Uso: Integración con servicios de terceros que soportan webhooks (ej. Stripe, GitHub, Typeform), creación de APIs personalizadas simples, activación de flujos desde otras aplicaciones o scripts.
  • Importante: Al activar un flujo con un disparador Webhook, asegúrate de usar la URL de producción, no la de prueba.
• Error Trigger:
  • Propósito: Inicia este flujo de trabajo cuando otro flujo de trabajo en la misma instancia de n8n falla.
  • Configuración: Puedes seleccionar flujos específicos para monitorizar o monitorizar todos.
  • Salida: Información sobre la ejecución fallida ($json.execution) y el error ($json.error).
  • Caso de Uso: Centralizar la notificación de errores, intentar acciones de recuperación automáticas.

Lógica y Control de Flujo

Estos nodos dirigen el camino que toman los datos a través del flujo.

• IF:
  • Propósito: Divide el flujo en dos ramas (Verdadero/Falso) basándose en una o más condiciones.
  • Configuración:
    • Conditions: Define las condiciones a evaluar. Puedes comparar valores de nodos anteriores ({{ $json.status }}) con valores estáticos u otros valores dinámicos usando varios operadores (Equal, Not Equal, Contains, Greater Than, Regex, etc.).
    • Combine: ALL (todas las condiciones deben ser verdaderas) o ANY (al menos una condición debe ser verdadera).
  • Salida: Los ítems que cumplen la condición van a la salida true, los que no, a la salida false.
  • Caso de Uso: Tomar diferentes acciones basadas en el estado de los datos (ej. si un email es de un cliente VIP, enviar a Slack; si no, crear un ticket), filtrar ítems.

Ilustración: Funcionamiento conceptual del nodo IF, dividiendo el flujo basado en una condición Verdadera o Falsa.
* Switch:
* Propósito: Divide el flujo en múltiples ramas basándose en el valor de un campo específico.
* Configuración:
* Field to Route By: La expresión que define el valor a evaluar (ej. {{ $json.priority }}).
* Routing Rules: Define reglas donde cada regla especifica un valor y una salida correspondiente. Si el campo coincide con el valor de una regla, el ítem se dirige a esa salida.
* Fallback Output: Una salida para los ítems que no coinciden con ninguna regla.
* Salida: Múltiples puntos de salida (0, 1, 2,... y Fallback).
* Caso de Uso: Manejar diferentes tipos de eventos o estados con acciones específicas para cada uno (ej. dirigir un ticket a diferentes equipos según su categoría), más eficiente que múltiples nodos IF anidados para el mismo campo.
* Merge:
* Propósito: Combina datos de diferentes ramas del flujo o controla cómo se agrupan los ítems.
* Configuración:
* Mode:
* Append: Simplemente concatena los ítems de todas las entradas en un solo array de salida.
* Pass-through: Espera a que lleguen datos de todas las entradas conectadas, pero solo pasa los datos de una entrada específica (definida por Source Input).
* Combine: Intenta emparejar ítems de diferentes entradas basándose en una clave (Key) y combina sus datos. Modos de combinación: Merge By Key (combina objetos JSON), Keep Key Matches (solo pasa ítems cuya clave existe en todas las entradas), Remove Key Matches (solo pasa ítems cuya clave NO existe en otras entradas).
* Wait for: All inputs (espera a que todas las ramas conectadas terminen) o Any input (procesa tan pronto como llega un ítem).
* Caso de Uso: Reunir resultados después de un IF o Switch, combinar datos enriquecidos desde diferentes fuentes, sincronizar ramas paralelas.

Ilustración: Funcionamiento conceptual del nodo Merge, combinando múltiples entradas en una salida única.
* Wait:
* Propósito: Pausa la ejecución del flujo durante un tiempo determinado o hasta una hora específica.
* Configuración: Define la duración (segundos, minutos, horas) o la hora exacta y la zona horaria.
* Caso de Uso: Esperar a que un sistema externo procese algo, introducir retrasos deliberados, esperar hasta un momento específico para continuar (ej. enviar un informe solo después de las 8 AM).
* No Operation, do nothing (NoOp):
* Propósito: Un nodo que no realiza ninguna acción. Es sorprendentemente útil.
* Configuración: Ninguna.
* Caso de Uso: Como marcador de posición, para terminar explícitamente una rama de un IF donde no se necesita acción, para organizar visualmente el flujo, como punto de entrada para un Merge.
* Execute Workflow:
* Propósito: Llama y ejecuta otro flujo de trabajo (sub-flujo) dentro del flujo actual.
* Configuración: Selecciona el flujo de trabajo a ejecutar. Los datos del nodo actual se pasan como entrada al disparador Start del sub-flujo.
* Salida: Los datos producidos por el nodo final del sub-flujo.
* Caso de Uso: Reutilizar lógica común en múltiples flujos, dividir flujos muy grandes en partes más manejables.

Ilustración: Funcionamiento conceptual del nodo Execute Workflow, mostrando un flujo principal que llama a un sub-flujo.
* Execute Command:
* Propósito: Ejecuta un comando de shell en el servidor donde se ejecuta n8n.
* Configuración: El comando a ejecutar.
* Salida: La salida estándar (stdout) y el error estándar (stderr) del comando.
* Caso de Uso: Interactuar con scripts locales, ejecutar herramientas de línea de comandos. ¡Usar con extrema precaución! Permite ejecutar cualquier comando, lo que puede ser un riesgo de seguridad significativo si el flujo puede ser disparado o influenciado por entradas externas.

Manipulación de Datos

Estos nodos permiten modificar, crear o reestructurar los datos que fluyen.

• Set:
  • Propósito: Añade nuevos campos a los ítems o modifica los existentes.
  • Configuración:
    • Mode: Append (añadir/sobrescribir campos) o Define (reemplazar completamente el objeto json del ítem).
    • Set Values: Define los campos y sus valores usando expresiones.
    • Keep Only Set: Si está activado, solo los campos definidos en este nodo se mantienen; todos los demás se descartan.
  • Caso de Uso: Añadir valores calculados, renombrar campos, establecer valores predeterminados, limpiar datos no deseados.
• Code (anteriormente Function y Function Item):
  • Propósito: Ejecuta código JavaScript (o Python, en beta) personalizado para realizar manipulaciones de datos complejas o lógica que no se puede lograr fácilmente con otros nodos.
  • Configuración:
    • Language: JavaScript o Python (beta).
    • Code: Escribe tu código. En JS, tienes acceso a los ítems de entrada a través de la variable items. Debes devolver un array de objetos con la estructura esperada por n8n (ej. [{ json: { nuevoCampo: item.json.campoExistente.toUpperCase() } }]).
    • Require Modules: Puedes importar librerías npm permitidas (configurables por el administrador de la instancia).
  • Caso de Uso: Transformaciones de datos muy específicas, lógica de negocio compleja, interactuar con librerías externas, implementar algoritmos personalizados.
• Edit Fields:
  • Propósito: Una forma más visual y sencilla que Set para realizar operaciones comunes en los campos de los ítems.
  • Configuración:
    • Mode: Rename Fields, Set Field Values, Keep Fields, Delete Fields, Duplicate Fields, Change Field Type.
    • Fields: Selecciona los campos y configura la operación específica.
  • Caso de Uso: Renombrar rápidamente múltiples campos, seleccionar solo los campos necesarios, eliminar campos sensibles, convertir tipos de datos (ej. string a número).
• Spreadsheet File:
  • Propósito: Lee datos de archivos de hoja de cálculo (Excel .xlsx, .xls, .ods, .csv) o escribe datos en ellos.
  • Configuración:
    • Operation: Read from file o Write to file.
    • Binary Property: El nombre de la propiedad binaria que contiene el archivo (generalmente data si viene de un nodo como HTTP Request o Read Binary File).
    • Options: Especificar hoja, rango, si la primera fila es cabecera, formato de salida (JSON/CSV), etc.
  • Caso de Uso: Procesar archivos Excel/CSV subidos o descargados, generar archivos Excel/CSV.

Comunicación Genérica

• HTTP Request:
  • Propósito: Realiza solicitudes HTTP a cualquier API o URL. Es uno de los nodos más versátiles y potentes.
  • Configuración:
    • Authentication: None, Header Auth, Basic Auth, OAuth1, OAuth2, Digest Auth (o usa credenciales predefinidas).
    • Request Method: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS.
    • URL: La URL del endpoint a llamar (puede usar expresiones).
    • Send: Query Parameters, Headers, Body (JSON, Form-Data, Raw, Binary).
    • Options: Timeout, redirecciones, manejo de SSL, dividir/no dividir salida, manejo de errores (reintentos, continuar en fallo), etc.
  • Salida: El cuerpo de la respuesta (en json o binary), las cabeceras de respuesta (headers), y el código de estado (statusCode).
  • Caso de Uso: Interactuar con cualquier API REST que no tenga un nodo de integración dedicado, obtener datos de páginas web (si devuelven JSON o datos estructurados), enviar datos a endpoints personalizados.

Utilidades Binarias

Estos nodos trabajan con datos binarios (archivos).

• Read Binary File:
  • Propósito: Lee un archivo del sistema de archivos local (donde se ejecuta n8n) y lo carga en la propiedad binaria de un ítem.
  • Configuración: La ruta del archivo en el servidor.
  • Salida: Un ítem con una propiedad binaria (por defecto data) que contiene el contenido del archivo.
  • Caso de Uso: Adjuntar archivos locales a emails, procesar archivos existentes en el servidor.
• Write Binary File:
  • Propósito: Toma datos binarios de un ítem y los guarda en un archivo en el sistema de archivos local.
  • Configuración: La ruta del archivo donde guardar y la propiedad binaria de entrada.
  • Caso de Uso: Guardar archivos descargados, almacenar resultados binarios generados.
• Move Binary Data:
  • Propósito: Renombra o mueve datos entre las propiedades json y binary de un ítem.
  • Configuración: Define las propiedades de origen y destino.
  • Caso de Uso: Preparar datos para nodos que esperan información binaria en una propiedad específica, extraer metadatos de json antes de guardar un archivo binario.

Dominar los Nodos Principales te proporciona las herramientas fundamentales para estructurar tus flujos, controlar su lógica, manipular datos de diversas formas e interactuar con el mundo exterior a través de HTTP. Son la base sobre la cual se construyen las integraciones más específicas.

Capítulo 6: Nodos de Integración Populares

n8n brilla por su vasta biblioteca de integraciones con cientos de servicios y aplicaciones. Si bien los Nodos Principales proporcionan la estructura y la lógica, los Nodos de Integración son los que conectan tus flujos de trabajo con las herramientas que usas a diario. Este capítulo explora algunos de los nodos de integración más populares y versátiles, mostrando cómo configurarlos y utilizarlos en escenarios comunes.

Recuerda que casi todos los nodos de integración requerirán Credenciales. El proceso de creación de credenciales se cubrió en el Capítulo 1, pero cada servicio tendrá sus particularidades (API Keys, OAuth2, etc.).

Hojas de Cálculo (Spreadsheets)

• Google Sheets:
  • Propósito: Interactuar con Google Sheets para leer, escribir, actualizar y eliminar datos.
  • Credenciales: OAuth2 (requiere configurar un proyecto en Google Cloud Console con la API de Google Sheets habilitada).
  • Recursos Comunes: Spreadsheet, Sheet, Row.
  • Operaciones Populares:
    • Row -> Append: Añadir una o más filas al final de una hoja. Necesitas especificar el ID de la hoja de cálculo, el nombre de la hoja y los datos de las columnas (generalmente como un objeto JSON donde las claves son los nombres de las cabeceras).
    • Row -> Get: Leer filas de una hoja. Puedes especificar un rango, obtener todas las filas, o filtrar basándote en valores de columnas.
    • Row -> Update: Modificar filas existentes. Necesitas una forma de identificar la fila a actualizar (ej. número de fila o un valor de clave única) y los nuevos datos.
    • Row -> Delete: Eliminar filas basándose en su número de fila o contenido.
    • Sheet -> Get All: Obtener información sobre todas las hojas dentro de una hoja de cálculo.
  • Configuración Clave:
    • Spreadsheet ID: El ID largo en la URL de tu Google Sheet.
    • Sheet Name: El nombre exacto de la hoja (pestaña).
    • Range: (Opcional) Especifica un rango como A1:C10.
    • Options -> Raw: Devuelve los valores sin formato (útil para fechas/números).
    • Options -> Value Render Mode: Cómo se deben interpretar los valores (Formateado, Sin formato, Fórmula).
  • Caso de Uso: Guardar datos de formularios web, crear dashboards simples, leer configuraciones, sincronizar datos con otras aplicaciones.
• Airtable:
  • Propósito: Interactuar con bases de Airtable.
  • Credenciales: Airtable Personal Access Token (recomendado) o API Key (legacy).
  • Recursos: Record, Table.
  • Operaciones Populares: Record -> Create, Record -> Get Many, Record -> Update, Record -> Delete.
  • Configuración Clave: Base ID, Table ID/Name, mapeo de campos.
  • Caso de Uso: Usar Airtable como una base de datos flexible para tus automatizaciones, gestionar CRM, seguimiento de proyectos.

Comunicación y Notificaciones

• Slack:
  • Propósito: Enviar mensajes, subir archivos e interactuar con Slack.
  • Credenciales: Slack API Credential (OAuth2 - requiere crear una App de Slack).
  • Recursos: Message, File, User, Channel.
  • Operaciones Populares:
    • Message -> Post: Enviar un mensaje a un canal, usuario o grupo. Puedes usar formato de bloque (Block Kit) para mensajes enriquecidos.
    • File -> Upload: Subir un archivo a un canal.
    • User -> Get By Email: Encontrar un usuario de Slack por su email para enviarle mensajes directos.
  • Configuración Clave: Channel/User ID or Name, Text (contenido del mensaje), Blocks (para Block Kit JSON).
  • Caso de Uso: Notificaciones de errores, alertas de negocio, enviar informes, crear bots de Slack simples.
• Email (Send) / SMTP:
  • Propósito: Enviar correos electrónicos.
  • Credenciales: Credenciales SMTP (Host, Puerto, Usuario, Contraseña). Puedes usar servicios como Gmail (requiere contraseña de aplicación si tienes 2FA), SendGrid, Mailgun, AWS SES, etc.
  • Operaciones: Send Email.
  • Configuración Clave: From, To, Subject, Body (HTML o Texto), Attachments (usando la propiedad binaria de ítems anteriores).
  • Caso de Uso: Enviar confirmaciones, notificaciones personalizadas, informes por correo electrónico.
• Email (Read) / IMAP:
  • Propósito: Leer correos electrónicos de una cuenta.
  • Credenciales: Credenciales IMAP (Host, Puerto, Usuario, Contraseña - de nuevo, contraseña de aplicación para Gmail con 2FA).
  • Operaciones: Get Messages.
  • Configuración Clave: Folder (ej. INBOX), Criteria (para filtrar correos por remitente, asunto, no leídos, etc.), Fetch (qué partes del correo obtener: cuerpo, adjuntos).
  • Salida: Ítems que representan los correos electrónicos, con detalles en json y adjuntos en binary.
  • Caso de Uso: Procesar correos entrantes, extraer datos de emails, automatizar respuestas basadas en contenido de correo.
• Telegram:
  • Propósito: Enviar mensajes, fotos, documentos a través de un Bot de Telegram.
  • Credenciales: Telegram API (Token del Bot obtenido de BotFather).
  • Recursos: Message, Document, Photo, etc.
  • Operaciones Populares: Message -> Send Text, Document -> Send, Photo -> Send.
  • Configuración Clave: Chat ID (del usuario o grupo al que enviar), Text o referencia a datos binarios.
  • Caso de Uso: Notificaciones personales o de grupo, bots interactivos simples.

Bases de Datos SQL

n8n soporta las bases de datos SQL más comunes.

• Nodos: Postgres, MySQL, Microsoft SQL Server, SQLite.
• Propósito: Ejecutar consultas SQL para leer, insertar, actualizar o eliminar datos.
• Credenciales: Credenciales específicas de la base de datos (Host, Puerto, Nombre de DB, Usuario, Contraseña).
• Operaciones:
  • Execute Query: Permite escribir y ejecutar cualquier consulta SQL.
  • Otras operaciones más estructuradas como Insert, Select, Update, Delete (varían ligeramente entre tipos de DB).
• Configuración Clave:
  • Query: La consulta SQL a ejecutar. ¡Importante! Usa placeholders ($1, $2 en Postgres; ? en MySQL/MSSQL) y la sección Parameters para pasar valores dinámicos de forma segura y evitar inyecciones SQL. No insertes valores directamente en la cadena de la consulta usando expresiones {{ }}.
    • Ejemplo (Postgres): INSERT INTO users (name, email) VALUES ($1, $2) con Parámetros {{ $json.userName }}, {{ $json.userEmail }}.
  • Operation (para modos estructurados): Table, Columns, Filters.
• Caso de Uso: Almacenar datos de forma persistente, leer datos para enriquecer flujos, sincronizar datos entre la base de datos y otras aplicaciones.

Inteligencia Artificial (AI)

n8n tiene integraciones potentes con modelos y plataformas de IA.

• OpenAI:
  • Propósito: Interactuar con los modelos de OpenAI (GPT-4, GPT-3.5, DALL-E, etc.).
  • Credenciales: OpenAI API Key.
  • Recursos: Chat, Completions (legacy), Images, Embeddings.
  • Operaciones Populares:
    • Chat -> Create: Enviar un prompt (y opcionalmente historial de conversación) a modelos como GPT-4/3.5 para obtener respuestas generativas.
    • Images -> Create: Generar imágenes con DALL-E a partir de una descripción textual.
    • Embeddings -> Create: Generar representaciones vectoriales (embeddings) de texto para búsqueda semántica o RAG.
  • Configuración Clave: Model, Messages (para Chat, incluyendo roles system, user, assistant), Prompt (para Completions/Images), Options (temperatura, max tokens, etc.).
  • Caso de Uso: Resumir textos, traducir, responder preguntas, generar contenido, clasificar datos, búsqueda semántica.
• Hugging Face Inference:
  • Propósito: Ejecutar modelos de Machine Learning alojados en Hugging Face Hub (tanto los gratuitos en la API de Inferencia como endpoints dedicados).
  • Credenciales: Hugging Face API Token.
  • Operaciones: Text Generation, Summarization, Translation, Image Classification, Sentence Similarity, etc. (depende del modelo elegido).
  • Configuración Clave: Model ID (del repositorio de Hugging Face), Inputs (el texto o datos a procesar).
  • Caso de Uso: Acceder a una amplia variedad de modelos de IA especializados para tareas específicas sin necesidad de entrenarlos tú mismo.
• Langchain Agent:
  • Propósito: Crear agentes de IA más complejos utilizando el framework Langchain. Permite a un LLM interactuar con otras herramientas (nodos de n8n) para realizar tareas.
  • Credenciales: Credenciales para el LLM (ej. OpenAI) y para las herramientas que el agente pueda usar.
  • Configuración Clave: LLM Node (referencia a un nodo LLM configurado, ej. OpenAI), Tools (referencia a otros nodos de n8n que el agente puede usar, ej. HTTP Request, Google Search), Prompt (instrucciones para el agente).
  • Caso de Uso: Crear asistentes que puedan buscar información en la web, interactuar con APIs, y realizar acciones basadas en lenguaje natural.
• Bases de Datos Vectoriales (Qdrant, Pinecone, Weaviate):
  • Propósito: Almacenar y buscar embeddings vectoriales, principalmente para casos de uso de Retrieval-Augmented Generation (RAG).
  • Credenciales: API Keys o URLs específicas del servicio.
  • Operaciones: Upsert (insertar/actualizar vectores), Search (buscar vectores similares a un vector de consulta).
  • Configuración Clave: Collection Name, Vectors (los embeddings a insertar), Query Vector (el embedding a buscar), Limit (cuántos resultados devolver).
  • Caso de Uso: Implementar RAG para que los LLMs puedan responder preguntas basadas en documentos o conocimientos específicos, búsqueda semántica de imágenes o texto.

CRM y Marketing

• HubSpot:
  • Propósito: Interactuar con la plataforma HubSpot (CRM, Marketing, Sales, Service).
  • Credenciales: HubSpot Private App o API Key (legacy).
  • Recursos: Contact, Company, Deal, Ticket, Engagement, etc.
  • Operaciones Populares: Contact -> Create or Update, Contact -> Get All, Deal -> Create, Engagement -> Create (registrar emails, llamadas).
  • Configuración Clave: Mapeo de propiedades de HubSpot.
  • Caso de Uso: Sincronizar contactos desde otras fuentes, automatizar la creación de deals, registrar interacciones, enviar datos a HubSpot.
• Salesforce:
  • Propósito: Interactuar con Salesforce Sales Cloud.
  • Credenciales: Salesforce OAuth2 (requiere crear una Connected App en Salesforce).
  • Recursos: Account, Contact, Lead, Opportunity, Campaign, Custom Object, etc.
  • Operaciones Populares: Create Record, Get Records, Update Record, Delete Record, Search Records (SOQL).
  • Configuración Clave: Object Type, mapeo de campos, SOQL Query (para búsquedas avanzadas).
  • Caso de Uso: Similar a HubSpot, gestionar leads, oportunidades, contactos, sincronizar datos.

Otros Nodos Útiles

• Google Drive:
  • Propósito: Gestionar archivos y carpetas en Google Drive.
  • Credenciales: Google OAuth2 (requiere API de Google Drive habilitada).
  • Operaciones: Download File, Upload File, List Files/Folders, Create Folder, Move File/Folder.
  • Caso de Uso: Guardar archivos generados, leer archivos de configuración, organizar documentos.
• Trello:
  • Propósito: Interactuar con tableros, listas y tarjetas de Trello.
  • Credenciales: Trello API Key y Token.
  • Operaciones: Create Card, Get Cards, Update Card, Move Card, Add Comment.
  • Caso de Uso: Crear tareas automáticamente, mover tarjetas entre listas basado en eventos, sincronizar Trello con otras herramientas.
• GitHub:
  • Propósito: Interactuar con repositorios de GitHub.
  • Credenciales: GitHub OAuth2 o Personal Access Token.
  • Operaciones: Create Issue, Get Repository Events, List Commits, Create Pull Request Comment.
  • Caso de Uso: Automatizar flujos de trabajo de desarrollo, crear issues desde otras fuentes, notificar sobre eventos del repositorio.

Esta es solo una pequeña muestra de las cientos de integraciones disponibles. La clave es buscar el servicio que necesitas en el panel de nodos, explorar sus recursos y operaciones, configurar las credenciales y luego usar los Nodos Principales (como IF, Set, Code) para adaptar los datos y la lógica a tus necesidades específicas.

Capítulo 7: Casos de Uso y Ejemplos Prácticos

La teoría y el conocimiento de los nodos individuales son importantes, pero la verdadera comprensión de n8n proviene de ver cómo se combinan para resolver problemas del mundo real. Este capítulo presenta varios casos de uso prácticos, guiándote paso a paso a través de la construcción de los flujos de trabajo correspondientes. Estos ejemplos están diseñados para ilustrar diferentes conceptos y combinaciones de nodos.

Nota: Para seguir estos ejemplos, necesitarás tener acceso a una instancia de n8n (Cloud o autoalojada) y, para algunos ejemplos, credenciales para los servicios específicos involucrados (ej. Google Sheets, Slack, OpenAI).

Ejemplo 1: Guardar Envíos de Formularios Web en Google Sheets y Notificar en Slack

Objetivo: Capturar datos enviados desde un formulario web simple, guardar cada envío como una nueva fila en una hoja de Google Sheets y enviar una notificación a un canal de Slack.

Conceptos Clave: Webhook Trigger, Google Sheets (Append Row), Slack (Post Message), Mapeo de Datos.

Pasos:

1. Preparar Google Sheet:
   • Crea una nueva hoja de Google Sheets.
   • Define las cabeceras en la primera fila que coincidan con los campos de tu formulario (ej. Timestamp, Nombre, Email, Mensaje).
2. Crear el Flujo en n8n:
   • Crea un nuevo flujo de trabajo.
   • Nodo 1: Webhook (Trigger):
     • Deja la autenticación en None por ahora (para producción, considera añadir seguridad).
     • Deja el método HTTP en POST.
     • Copia la URL del Webhook de Prueba. La necesitarás para enviar datos de ejemplo.
     • En Options, establece Response Mode a On Received (enviaremos una respuesta simple).
   • Enviar Datos de Prueba: Usa una herramienta como curl o Postman para enviar una solicitud POST a la URL de prueba del webhook. El cuerpo debe ser JSON con los datos del formulario:
     
     

     curl -X POST -H "Content-Type: application/json" \
     -d '{"nombre": "Juan Perez", "email": "juan.perez@example.com", "mensaje": "Consulta sobre el producto X"}' \
     TU_URL_WEBHOOK_PRUEBA
     
     
     

     • Verifica que el nodo Webhook reciba los datos correctamente en el panel de resultados (Output -> Body).
   • Nodo 2: Set (Opcional pero recomendado):
     • Propósito: Añadir una marca de tiempo al envío.
     • Conecta el Webhook al Set.
     • Mode: Append.
     • Set Values: Añade un valor:
       • Name: timestamp
       • Value: (Usa el editor de expresiones) {{ $now.toISO() }}
     • Ejecuta Test step para verificar que el campo timestamp se añade.
   • Nodo 3: Google Sheets:
     • Conecta el Set al Google Sheets.
     • Credentials: Selecciona o crea tus credenciales de Google OAuth2.
     • Resource: Row.
     • Operation: Append.
     • Spreadsheet ID: Pega el ID de tu hoja de Google Sheets (de la URL).
     • Sheet Name: Introduce el nombre exacto de tu hoja.
     • Columns -> Mode: Map Automatically (si los nombres en el JSON coinciden exactamente con las cabeceras) o Map Manually.
     • Columns -> Add Mapping: (Si usas mapeo manual) Para cada columna de tu hoja, añade un mapeo:
       • Header: Timestamp, Value: {{ $json.timestamp }}
       • Header: Nombre, Value: {{ $json.nombre }}
       • Header: Email, Value: {{ $json.email }}
       • Header: Mensaje, Value: {{ $json.mensaje }}
     • Ejecuta Test step. Verifica que una nueva fila se añada a tu Google Sheet.
   • Nodo 4: Slack:
     • Conecta el Google Sheets al Slack.
     • Credentials: Selecciona o crea tus credenciales de Slack API.
     • Resource: Message.
     • Operation: Post.
     • Channel: Selecciona el canal (o introduce el ID/nombre) donde quieres enviar la notificación.
     • Text: Crea un mensaje usando expresiones para incluir datos del formulario:
       
       
       

       Nuevo envío de formulario:
       *Nombre:* {{ $json.nombre }}
       *Email:* {{ $json.email }}
       *Mensaje:* {{ $json.mensaje }}
       
       
       
       

     • Ejecuta Test step. Verifica que el mensaje aparezca en Slack.
3. Activar el Flujo:
   • Haz clic en el interruptor Inactive para ponerlo en Active.
   • Importante: Reemplaza la URL de prueba del webhook en tu formulario web o aplicación con la URL de Producción que ahora se muestra en el nodo Webhook.

Resultado: Cada vez que se envíe el formulario web, los datos se guardarán en Google Sheets y recibirás una notificación en Slack.

Ilustración: Un ejemplo visual de un flujo de trabajo construido en n8n, mostrando la conexión entre diferentes nodos.

Ejemplo 1: Resumen Diario de Noticias RSS Enviado por Email

Objetivo: Leer las últimas entradas de varios feeds RSS, combinarlas, obtener un resumen de IA para cada una, y enviar un único correo electrónico diario con todos los resúmenes.

Conceptos Clave: Cron Trigger, RSS Read, Merge, OpenAI (Chat), Loop (implícito), Set, Email.

Pasos:

1. Crear el Flujo en n8n:
   • Nodo 1: Cron (Trigger):
     • Mode: Every Day.
     • Hour: Elige la hora a la que quieres recibir el resumen (ej. 7).
     • Timezone: Configura tu zona horaria.
   • Nodo 2, 3, ...: RSS Feed Read (uno por cada feed):
     • Conecta el Cron a cada nodo RSS Feed Read.
     • URL: Pega la URL del feed RSS.
     • Options -> Limit: Establece un límite razonable (ej. 5) para obtener solo las últimas entradas.
     • Ejecuta Test step para cada uno para verificar que obtienes las entradas.
   • Nodo N+1: Merge:
     • Conecta todos los nodos RSS Feed Read a este nodo Merge.
     • Mode: Append.
     • Wait for: All inputs.
     • Ejecuta Test step (puede requerir ejecutar los nodos RSS primero). Deberías ver una lista combinada de todas las entradas de los feeds.
   • Nodo N+2: OpenAI:
     • Conecta el Merge al OpenAI.
     • Credentials: Selecciona tus credenciales de OpenAI.
     • Resource: Chat.
     • Operation: Create.
     • Model: Elige un modelo (ej. gpt-3.5-turbo).
     • Messages -> Add Message Item:
       • Role: User
       • Content: (Usa expresiones) Escribe un prompt para resumir. Asegúrate de incluir el contenido relevante del feed RSS. n8n ejecutará este nodo una vez por cada ítem (entrada RSS) recibido del nodo Merge.
         
         
         
         

         Por favor, resume el siguiente artículo en 1-2 frases:
         Título: {{ $json.title }}
         Contenido: {{ $json.contentSnippet || $json.description || $json.content || "No content available" }}
         
         
         
         
         

         
         
         
         
         (Nota: Usamos || para intentar obtener el contenido de diferentes campos comunes en feeds RSS).
     • Ejecuta Test step. Verifica que obtienes un resumen en la salida ($json.choices[0].message.content).
   • Nodo N+3: Set (para formatear):
     • Conecta el OpenAI al Set.
     • Propósito: Crear un bloque de texto formateado para cada resumen.
     • Mode: Append.
     • Set Values -> Add Value:
       • Name: formattedSummary
       • Value: (Usa expresiones)
         
         
         
         

         ## {{ $node["RSS Feed Read"].json.title }} 
         {{ $json.choices[0].message.content }}
         [Link]({{ $node["RSS Feed Read"].json.link }})
         ---
         
         
         
         
         

         
         
         
         
         (Nota: Accedemos al título original desde el nodo RSS correspondiente usando $node["Nombre del Nodo RSS"].json.title. Ajusta el nombre del nodo si es diferente. También accedemos al resumen de OpenAI con $json.choices[0].message.content).
     • Ejecuta Test step.
   • Nodo N+4: Merge (para agregar):
     • Conecta el Set a este Merge.
     • Propósito: Combinar todos los resúmenes formateados en un solo bloque de texto.
     • Mode: Combine.
     • Combine: Merge By Index (o Append si solo necesitas la lista).
     • Source Input: Input 1.
     • Property to Aggregate: formattedSummary.
     • Separator: (nueva línea).
     • Keep: Specified Properties.
     • Properties: aggregatedData (o el nombre que le dé por defecto).
     • Alternativa más simple si Set produce un solo ítem por ejecución (ajustando opciones en OpenAI/Set): Podrías usar un nodo Code después del Set para iterar sobre items y construir el cuerpo del email.
   • Nodo N+5: Email (Send):
     • Conecta el Merge (o el nodo Code alternativo) al Email.
     • Credentials: Configura tus credenciales SMTP.
     • To: Tu dirección de correo electrónico.
     • Subject: Resumen de Noticias Diario - {{ $now.toFormat('yyyy-MM-dd') }}
     • Body: (Usa expresiones) Referencia la salida agregada del nodo Merge (ej. {{ $json.aggregatedData }}). Asegúrate de marcar la opción HTML si tu texto formateado usa Markdown que quieres renderizar (puede requerir un paso adicional para convertir Markdown a HTML si tu cliente de correo no lo hace).
     • Ejecuta Test step.
2. Activar el Flujo:
   • Activa el flujo para que el Cron trigger funcione.

Resultado: Recibirás un correo electrónico diario con los resúmenes de las últimas noticias de tus feeds RSS seleccionados.

Ejemplo 3: Procesamiento Básico de Pedidos (Webhook -> Base de Datos -> Slack)

Objetivo: Recibir detalles de un nuevo pedido a través de un webhook (simulando una tienda online), guardar el pedido en una base de datos PostgreSQL y notificar al equipo de ventas en Slack.

Conceptos Clave: Webhook, PostgreSQL (Execute Query), Placeholders SQL, IF, Slack.

Pasos:

1. Preparar Base de Datos PostgreSQL:
   • Asegúrate de tener una base de datos PostgreSQL accesible.
   • Crea una tabla para los pedidos, por ejemplo:
     
     

     CREATE TABLE orders (
         order_id VARCHAR(255) PRIMARY KEY,
         customer_email VARCHAR(255),
         product_name VARCHAR(255),
         quantity INT,
         total_amount NUMERIC(10, 2),
         order_timestamp TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
     );
     
     
     

2. Crear el Flujo en n8n:
   • Nodo 1: Webhook (Trigger):
     • Configura como en el Ejemplo 1 (Método POST).
     • Envía datos de prueba simulando un pedido:
       
       
       

       curl -X POST -H "Content-Type: application/json" \
       -d '{"orderId": "ORD12345", "customerEmail": "cliente@example.com", "product": "Widget Pro", "qty": 2, "total": 99.98}' \
       TU_URL_WEBHOOK_PRUEBA
       
       
       
       

   • Nodo 2: Postgres:
     • Conecta el Webhook al Postgres.
     • Credentials: Configura tus credenciales de PostgreSQL.
     • Operation: Execute Query.
     • Query: Escribe la consulta INSERT usando placeholders:
       
       
       

       INSERT INTO orders (order_id, customer_email, product_name, quantity, total_amount)
       VALUES ($1, $2, $3, $4, $5)
       ON CONFLICT (order_id) DO NOTHING; -- Opcional: Evita errores si el ID ya existe
       
       
       
       

     • Parameters -> Add Parameter: Añade 5 parámetros, usando expresiones para obtener los datos del webhook:
       1. {{ $json.body.orderId }}
       2. {{ $json.body.customerEmail }}
       3. {{ $json.body.product }}
       4. {{ $json.body.qty }}
       5. {{ $json.body.total }}
     • Options -> Continue On Fail: Activa esta opción. Queremos manejar el caso en que la inserción falle (ej. ID duplicado si no usamos ON CONFLICT).
     • Ejecuta Test step. Verifica que los datos se inserten en la tabla orders.
   • Nodo 3: IF (Manejo de Error DB):
     • Conecta el Postgres al IF.
     • Propósito: Comprobar si el nodo Postgres falló.
     • Conditions -> Add Condition -> Add Condition Entry:
       • Value 1: (Usa el editor de expresiones) {{ $node["Postgres"].error === undefined }}
       • Operation: Boolean -> Is True
     • La salida true significa que la base de datos funcionó, la salida false significa que falló.
   • Nodo 4: Slack (Notificación de Éxito):
     • Conecta la salida true del IF a este nodo Slack.
     • Configura para enviar un mensaje al equipo de ventas:
       
       
       

       Nuevo pedido recibido y guardado:
       ID: {{ $node["Webhook"].json.body.orderId }}
       Cliente: {{ $node["Webhook"].json.body.customerEmail }}
       Producto: {{ $node["Webhook"].json.body.product }} ({{ $node["Webhook"].json.body.qty }})
       Total: ${{ $node["Webhook"].json.body.total }}
       
       
       
       

     • Ejecuta Test step (asegúrate de que el IF evalúe a true).
   • Nodo 5: Slack (Notificación de Error DB):
     • Conecta la salida false del IF a este nodo Slack.
     • Configura para enviar un mensaje de error a un canal de administradores:
       
       
       

       ¡ERROR al guardar pedido en DB!
       ID Pedido: {{ $node["Webhook"].json.body.orderId }}
       Error: {{ $node["Postgres"].error.message || "Error desconocido" }}
       
       
       
       

     • Para probar esta rama, puedes intentar enviar datos de prueba con un orderId que ya exista (si no usaste ON CONFLICT) o detener temporalmente tu base de datos.
3. Activar el Flujo:
   • Activa el flujo y usa la URL de producción del webhook en tu sistema de pedidos.

Resultado: Los nuevos pedidos se registran en la base de datos y se envía una notificación a Slack, con un manejo básico de errores si falla la inserción en la base de datos.

Estos ejemplos muestran cómo combinar diferentes nodos para crear automatizaciones útiles. La clave es descomponer el problema, elegir los nodos adecuados para cada paso, configurar sus parámetros usando expresiones para pasar datos dinámicamente y manejar posibles errores.

Capítulo 8: Técnicas Avanzadas y Mejores Prácticas

Una vez que dominas los fundamentos y has construido algunos flujos de trabajo, puedes empezar a explorar técnicas más avanzadas para crear automatizaciones más potentes, robustas y eficientes. Este capítulo cubre estrategias para manejar escenarios complejos, optimizar el rendimiento y seguir las mejores prácticas para mantener tus flujos de trabajo.

Looping e Iteración

A veces necesitas repetir un conjunto de acciones para cada ítem en una lista o hasta que se cumpla una condición. n8n no tiene un nodo de "Loop" explícito como algunas otras herramientas, pero la iteración se maneja de forma inherente o se puede construir.

• Iteración Implícita (Comportamiento por Defecto):
  • Cómo funciona: La mayoría de los nodos en n8n (excepto los disparadores y algunos nodos específicos como Merge en ciertos modos) se ejecutan una vez por cada ítem que reciben como entrada. Si un nodo recibe un array de 10 ítems, el siguiente nodo se ejecutará 10 veces, una para cada ítem.
  • Caso de Uso: Es la forma más común de procesar listas. Por ejemplo, si lees 10 filas de Google Sheets, puedes usar un nodo OpenAI para resumir el contenido de cada fila; el nodo OpenAI se ejecutará 10 veces automáticamente.
  • Consideraciones: Ten cuidado con los límites de API. Si un nodo que llama a una API externa se ejecuta 1000 veces, podría exceder los límites de tasa o incurrir en costos significativos.
• Simulación de Bucles Do-While o Until (con IF y Merge):
  • Propósito: Repetir un bloque de nodos hasta que se cumpla una condición (ej. obtener todas las páginas de resultados de una API paginada).
  • Cómo funciona:
    1. Obtener Datos Iniciales: Un nodo obtiene el primer lote de datos (ej. HTTP Request para la página 1).
    2. Procesar Datos: Nodos que procesan los datos obtenidos.
    3. Nodo IF (Condición de Salida): Comprueba si hay más datos por obtener (ej. si la respuesta de la API indica que hay una página siguiente, o si el número de resultados obtenidos es menor que el total esperado).
    4. Rama True (Continuar Bucle):
       • Nodos para preparar la siguiente iteración (ej. Set para incrementar el número de página o usar la URL de la página siguiente proporcionada por la API).
       • Nodo Merge (Modo Wait for Any Input): Conecta la salida de la rama True del IF de vuelta a la entrada del nodo que obtiene los datos (Paso 1). Esto crea el ciclo.
    5. Rama False (Salir del Bucle): Conecta a los nodos que deben ejecutarse después de que el bucle haya terminado.
       
       
       ** Precaución: ¡Es fácil crear bucles infinitos! Asegúrate de que tu condición de salida (IF) eventualmente se vuelva falsa. Considera añadir un contador de iteraciones y una condición adicional en el IF para salir después de un número máximo de iteraciones como medida de seguridad.

Ilustración: Diagrama conceptual de un bucle Do-While simulado con nodos IF y Merge.d.
* Nodo Split In Batches:
* Propósito: Divide una gran cantidad de ítems de entrada en lotes más pequeños. Aunque no es un bucle en sí mismo, es crucial para manejar la iteración implícita cuando se trabaja con APIs que tienen límites de tasa o de tamaño de payload.
* Configuración: Batch Size (cuántos ítems por lote).
* Salida: Se ejecuta una vez por cada lote, y cada ejecución produce un ítem que contiene un array (items) con los ítems de ese lote.
* Caso de Uso: Si necesitas insertar 1000 filas en una base de datos pero la API o el nodo de DB es más eficiente con lotes de 100, usa Split In Batches con tamaño 100. El nodo de la base de datos se ejecutará 10 veces, cada vez procesando un lote de 100 ítems (puede requerir un nodo Code o configuración específica en el nodo de DB para manejar el array items).

Manejo Avanzado de Errores

Más allá de Continue On Fail, puedes implementar patrones más sofisticados.

• Reintentos con Retraso Exponencial:
  • Propósito: Reintentar automáticamente una operación fallida (ej. llamada API) varias veces, esperando un tiempo creciente entre intentos.
  • Implementación: Similar al bucle Do-While:
    1. Nodo Set (Inicializar contador de reintentos, ej. retryCount = 0).
    2. Nodo Merge (Punto de entrada/reintento).
    3. Nodo de Operación (ej. HTTP Request). Activa Continue On Fail.
    4. Nodo IF (Comprobar éxito): Verifica si el nodo de operación falló ($node["HTTP Request"].error !== undefined).
    5. Rama False (Éxito): Continuar con el flujo normal.
    6. Rama True (Fallo):
       • Nodo IF (Comprobar límite de reintentos): Verifica si retryCount es menor que el máximo (ej. {{ $json.retryCount < 3 }}).
       • Rama True (Reintentar):
         • Nodo Wait: Espera un tiempo (ej. {{ Math.pow(2, $json.retryCount) * 1000 }} ms para retraso exponencial).
         • Nodo Set: Incrementa retryCount ({{ $json.retryCount + 1 }}).
         • Conectar de vuelta al Merge (Paso 2).
       • Rama False (Límite alcanzado): Manejar el error final (ej. notificar, terminar).
• Circuit Breaker (Manual):
  • Propósito: Si un servicio externo falla repetidamente, dejar de intentar llamarlo por un período para evitar sobrecargarlo y fallar rápidamente.
  • Implementación: Requiere almacenar el estado externamente (ej. en una variable de n8n, una base de datos simple o Redis). Antes de llamar al servicio, verifica el estado. Si está "abierto" (fallando), salta la llamada. Si la llamada falla, incrementa un contador de fallos. Si supera un umbral, marca el estado como "abierto" y establece un temporizador. Si la llamada tiene éxito, resetea el contador. Después de que expire el temporizador, cambia el estado a "semi-abierto" para permitir un intento.

Ilustración: Diagrama conceptual del patrón de reintentos con retraso exponencial.
* Transacciones (Simuladas):
* Propósito: Asegurar que una serie de operaciones (ej. actualizar DB y luego llamar a una API) se completen todas o ninguna.
* Implementación: n8n no tiene soporte transaccional incorporado que abarque múltiples nodos. La implementación depende de las capacidades de los sistemas involucrados.
* Compensación: Si un paso falla después de que otros tuvieron éxito, ejecuta acciones de "compensación" para deshacer los pasos anteriores (ej. si la llamada API falla después de actualizar la DB, ejecuta una consulta SQL para revertir la actualización). Esto puede ser complejo.
* Idempotencia: Diseña tus operaciones para que puedan ejecutarse múltiples veces sin efectos secundarios negativos. Si un flujo falla a la mitad y se reintenta, las operaciones idempotentes aseguran que el resultado final sea correcto.

Ilustración: Diagrama conceptual del uso de un Error Trigger para manejar fallos en otros flujos de trabajo.

Trabajo con Datos Binarios

• Múltiples Archivos Binarios: Un solo ítem en n8n puede contener múltiples propiedades binarias (ej. data, thumbnail, attachment1). Los nodos Read Binary File, HTTP Request, Move Binary Data te permiten gestionar esto.
• Streaming (Limitado): n8n no está diseñado principalmente para streaming de grandes archivos. Generalmente carga el contenido binario en memoria o lo almacena temporalmente en disco. Para archivos muy grandes, considera herramientas externas o procesarlos en fragmentos si la API lo permite.
• Metadatos: Los datos binarios a menudo vienen con metadatos (nombre de archivo, tipo MIME) en el objeto binary (ej. $binary.data.fileName, $binary.data.mimeType). Usa expresiones para acceder a ellos.

Uso Efectivo del Nodo Code

El nodo Code es tu navaja suiza para lógica compleja.

• Cuándo Usarlo:
  • Transformaciones de datos que son difíciles o engorrosas con Set o Edit Fields.
  • Lógica condicional compleja que requeriría muchos nodos IF.
  • Iteraciones personalizadas o agregaciones sobre los items de entrada.
  • Llamadas a librerías externas (vía require).
  • Implementación de algoritmos específicos.
• Buenas Prácticas (JavaScript):
  • Acceso a Datos: items es un array de objetos de ítem de n8n. Accede a los datos JSON con items[i].json.nombreCampo o itera con for (const item of items) { ... item.json ... }.
  • Devolver Datos: Tu código debe devolver un array de objetos de ítem de n8n. La estructura más simple es [{ json: { tus_nuevos_datos } }]. Si quieres pasar datos binarios, asegúrate de incluirlos: [{ json: {...}, binary: item.binary }].
  • Manejo de Errores: Usa try...catch dentro de tu código para manejar errores potenciales y devolver información útil.
  • Librerías Externas: Usa require con precaución. Asegúrate de que las librerías estén permitidas por el administrador (NODE_FUNCTION_ALLOW_EXTERNAL) y considera el impacto en el rendimiento.
  • Legibilidad: Comenta tu código. Para lógica muy compleja, considera si podría dividirse en múltiples nodos Code o si un nodo personalizado sería más apropiado.
• Python (Beta):
  • El entorno es más limitado actualmente.
  • Accedes a los datos de manera similar y necesitas devolver una estructura compatible.
  • Puede ser útil si estás más familiarizado con Python o necesitas librerías específicas de Python (si están permitidas).

Optimización del Rendimiento

Flujos lentos pueden ser frustrantes y costosos.

• Identificar Cuellos de Botella:
  • Revisa los tiempos de ejecución de cada nodo en el panel Executions. Nodos que tardan mucho son los candidatos principales.
  • Nodos comunes que pueden ser lentos: HTTP Request (esperando respuestas de API), Code (código ineficiente), nodos que procesan grandes cantidades de datos, Wait.
• Estrategias de Optimización:
  • Reducir Llamadas API:
    • ¿Puedes obtener más datos en una sola llamada en lugar de muchas?
    • ¿Puedes usar webhooks en lugar de polling (consultar repetidamente)?
    • Implementa caché (manualmente, quizás usando Static Data o una DB externa) si solicitas los mismos datos repetidamente.
  • Procesamiento en Paralelo (Limitado): n8n ejecuta nodos secuencialmente por defecto. Puedes lograr cierto paralelismo dividiendo el flujo y usando Merge (modo Append o Wait Any), pero ten cuidado con la gestión de datos y los límites de recursos.
  • Optimizar Nodo Code: Revisa tu código JS/Python en busca de bucles ineficientes, operaciones costosas o uso excesivo de memoria.
  • Usar Split In Batches: Para nodos que procesan muchos ítems y llaman a APIs, procesar en lotes puede ser más rápido (menos sobrecarga por llamada) y evita límites de tasa.
  • Filtrar Datos Temprano: Usa nodos IF o Filter para descartar ítems innecesarios lo antes posible en el flujo, para que los nodos posteriores no pierdan tiempo procesándolos.
  • Seleccionar Solo Campos Necesarios: En nodos que leen datos (DB, API), si es posible, configura para obtener solo los campos que realmente necesitas.
  • Escalar n8n (Autoalojado): Si el hardware es el cuello de botella, considera aumentar los recursos (CPU, RAM) o configurar múltiples workers si usas colas (Redis).

Mejores Prácticas Generales

• Nombrar Nodos Claramente: Cambia los nombres por defecto (ej. "HTTP Request1") por nombres descriptivos (ej. "Get Customer Details from API"). Facilita enormemente la comprensión del flujo.
• Usar Notas Adhesivas (Sticky Notes): Añade notas en el lienzo para explicar lógica compleja, decisiones de diseño o URLs importantes.
• Mantener Flujos Pequeños y Enfocados: Si un flujo se vuelve muy grande y complejo, considera dividirlo en sub-flujos más pequeños y reutilizables usando Execute Workflow.
• Manejo de Credenciales Seguro: Usa variables de entorno para la N8N_ENCRYPTION_KEY en producción. Revisa periódicamente y rota las credenciales de API cuando sea necesario.
• Versionado (Manual): n8n no tiene un sistema de control de versiones incorporado. Guarda regularmente versiones importantes de tus flujos descargándolos como JSON (Workflow Menu -> Download). Puedes almacenar estos JSON en un repositorio Git para llevar un historial de cambios.
• Pruebas:
  • Usa Test step extensivamente durante el desarrollo.
  • Prueba el flujo completo (Test workflow) con diferentes escenarios de datos (incluyendo casos límite y erróneos).
  • Considera tener entornos separados (Desarrollo/Prueba, Producción) si es posible.
• Monitorización: Revisa regularmente el panel Executions en busca de errores. Configura flujos de Error Trigger para notificaciones proactivas.
• Variables: Usa el nodo Static Data o la función de Variables globales (si está disponible) para almacenar valores de configuración (ej. IDs, URLs base) que se usan en múltiples lugares, en lugar de codificarlos directamente en cada nodo.
• Idempotencia: Siempre que sea posible, diseña tus flujos (o al menos las partes críticas) para que sean idempotentes.

Adoptar estas técnicas y prácticas te ayudará a pasar de crear automatizaciones simples a construir sistemas de flujo de trabajo sofisticados, mantenibles y fiables con n8n.

Capítulo 9: Desarrollo de Nodos Personalizados

Si bien n8n ofrece cientos de integraciones, puede haber ocasiones en las que necesites conectarte a un servicio interno, una API específica no soportada, o implementar una lógica muy particular que no se ajusta bien a los nodos existentes. Aquí es donde entra en juego el desarrollo de nodos personalizados. Crear tus propios nodos te permite extender n8n para que se ajuste perfectamente a tus necesidades.

Este capítulo proporciona una introducción al desarrollo de nodos personalizados, cubriendo los conceptos básicos, la estructura y el proceso general. Ten en cuenta que el desarrollo de nodos requiere conocimientos de programación, específicamente TypeScript (que es un superconjunto de JavaScript), Node.js y npm.

¿Por Qué Desarrollar un Nodo Personalizado?

• Integración con APIs No Soportadas: Conectar n8n a APIs internas o servicios de nicho que no tienen un nodo oficial o comunitario.
• Lógica de Negocio Compleja: Encapsular lógica reutilizable y compleja que sería difícil o engorrosa de implementar usando solo el nodo Code o una combinación de nodos existentes.
• Rendimiento Optimizado: Para tareas muy específicas, un nodo nativo puede ser más eficiente que un flujo de trabajo complejo o un nodo Code.
• Mejora de la Experiencia de Usuario: Proporcionar una interfaz de usuario dedicada y fácil de usar para una tarea específica, en lugar de requerir que los usuarios configuren nodos genéricos como HTTP Request.
• Compartir con la Comunidad: Contribuir con una nueva integración al ecosistema de n8n.

Prerrequisitos

• Node.js y npm: Necesitarás una versión reciente de Node.js (consulta la documentación de n8n para la versión mínima requerida, actualmente >=18.17.0) y su gestor de paquetes, npm.
• Git: Para clonar el repositorio de inicio y gestionar tu código.
• TypeScript: El desarrollo de nodos de n8n se realiza principalmente en TypeScript.
• Instancia Local de n8n: Necesitarás una instancia de n8n ejecutándose localmente para probar tu nodo. Puedes instalarla globalmente con npm install n8n -g.
• Editor de Código: Se recomienda VS Code con extensiones como ESLint, Prettier y EditorConfig para seguir las convenciones de codificación de n8n.
• Familiaridad con n8n: Comprensión de la estructura de datos de n8n (ítems, JSON, binarios) y cómo funcionan los flujos de trabajo.

Configuración del Entorno de Desarrollo

La forma recomendada de empezar es usando el paquete de inicio oficial:

1. Clonar el Repositorio:
   

   git clone https://github.com/n8n-io/n8n-node-starter.git tu-nombre-de-nodo
   cd tu-nombre-de-nodo
   
   

2. Instalar Dependencias:
   

   npm install
   
   

3. Construcción Inicial:
   

   npm run build
   
   

4. Enlazar para Pruebas Locales: Para que tu instancia local de n8n reconozca tu nodo en desarrollo, necesitas enlazarlo:
   

   npm link
   # En el directorio donde está instalado n8n globalmente (o en tu proyecto n8n si no es global):
   npm link n8n-nodes-tu-nombre-de-nodo # Usa el nombre definido en tu package.json
   
   

5. Iniciar n8n: Ejecuta n8n en tu terminal. Ahora deberías poder encontrar tu nodo de ejemplo en el panel de nodos dentro de n8n.

Estructura de un Nodo

El repositorio de inicio (n8n-node-starter) proporciona una estructura básica. Los archivos clave son:

• package.json: Define las dependencias, scripts (build, dev, lint) y, crucialmente, la sección n8n. Esta sección le dice a n8n dónde encontrar los archivos de nodo y credenciales.
  

  {
    "name": "n8n-nodes-tu-nombre-de-nodo",
    "version": "0.1.0",
    // ... otras propiedades ...
    "n8n": {
      "n8nNodesApiVersion": 1,
      "credentials": [
        "dist/credentials/MyCredential.credentials.js"
      ],
      "nodes": [
        "dist/nodes/MyNode/MyNode.node.js"
      ]
    },
    // ... dependencias y scripts ...
  }
  
  

• nodes/ Directorio: Contiene el código fuente de tus nodos.
  • MyNode/MyNode.node.ts: El archivo principal que define la lógica y la interfaz de tu nodo (el nombre MyNode debe ser reemplazado por el tuyo).
  • MyNode/MyNode.node.json: (Opcional, para estilo declarativo) Define la estructura y llamadas API de forma declarativa.
  • MyNode/description.ts: (Opcional, para estilo programático) Define las propiedades y la descripción del nodo.
• credentials/ Directorio: Contiene la definición de los tipos de credenciales que tu nodo podría necesitar.
  • MyCredential.credentials.ts: Define los campos y la lógica de autenticación para un tipo de credencial (ej. API Key, OAuth2).
• tsconfig.json: Configuración del compilador TypeScript.
• .eslintrc.js, .prettierrc.js: Configuraciones para el linter y formateador de código.

Ilustración: Diagrama simplificado de la estructura de archivos y directorios para un nodo personalizado.

Estilos de Construcción de Nodos

n8n ofrece dos enfoques principales:

1. Estilo Declarativo:
   • Ideal para: Interactuar con APIs REST estándar (OpenAPI/Swagger).
   • Cómo funciona: Definis la estructura de la API (endpoints, parámetros, autenticación) principalmente en un archivo .node.json. n8n genera gran parte del código de interacción con la API automáticamente.
   • Ventajas: Más rápido de desarrollar para APIs compatibles, menos código que escribir, sigue patrones consistentes.
   • Desventajas: Menos flexible si la API tiene peculiaridades o si necesitas lógica compleja antes/después de la llamada API.
2. Estilo Programático:
   • Ideal para: APIs no estándar, lógica compleja, manipulación de datos avanzada, interacciones que no son simples llamadas API.
   • Cómo funciona: Escribes la lógica completa del nodo en el archivo .node.ts, incluyendo las llamadas API (usando this.helpers.httpRequest), manipulación de datos y definición de la interfaz de usuario.
   • Ventajas: Máxima flexibilidad y control.
   • Desventajas: Requiere escribir más código TypeScript, mayor curva de aprendizaje.

La documentación de n8n proporciona tutoriales detallados para ambos estilos.

Conceptos Clave en el Código del Nodo (Estilo Programático)

El archivo .node.ts es el corazón de un nodo programático.

import { IExecuteFunctions } from 'n8n-core';
import {
    INodeExecutionData,
    INodeType,
    INodeTypeDescription,
    NodeOperationError,
} from 'n8n-workflow';

export class MyNode implements INodeType {
    description: INodeTypeDescription = {
        displayName: 'My Custom Node',
        name: 'myNode', // Nombre interno, debe ser único
        icon: 'file:myNode.svg', // Icono SVG en el mismo directorio
        group: ['transform'], // Categoría en el panel de nodos
        version: 1,
        description: 'Descripción breve de lo que hace el nodo',
        defaults: {
            name: 'My Node', // Nombre por defecto en el lienzo
        },
        inputs: ['main'], // Espera una entrada
        outputs: ['main'], // Produce una salida
        credentials: [
            // Referencia a la clase de credencial si es necesaria
            // { name: 'myCredentialApi', required: true }
        ],
        properties: [
            // Aquí se definen los campos de la UI del nodo
            {
                displayName: 'Operation',
                name: 'operation',
                type: 'options',
                noDataExpression: true,
                options: [
                    {
                        name: 'Say Hello',
                        value: 'sayHello',
                        action: 'Say hello action',
                    },
                ],
                default: 'sayHello',
            },
            // Ejemplo de campo de texto
            {
                displayName: 'Name',
                name: 'name',
                type: 'string',
                default: '',
                placeholder: 'Enter a name',
                description: 'The name to say hello to',
                displayOptions: {
                    show: {
                        operation: ['sayHello'], // Mostrar solo si la operación es 'sayHello'
                    },
                },
            },
        ],
    };

    // Método principal que ejecuta la lógica del nodo
    async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
        const items = this.getInputData(); // Obtener datos de entrada
        let item: INodeExecutionData;
        const returnData: INodeExecutionData[] = [];

        const operation = this.getNodeParameter('operation', 0, '') as string;

        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
            try {
                item = items[itemIndex];

                if (operation === 'sayHello') {
                    const name = this.getNodeParameter('name', itemIndex, '') as string;

                    // Lógica del nodo: hacer algo con 'name' y los datos de 'item.json'
                    // Ejemplo: Llamar a una API
                    /*
                    const options: OptionsWithUri = {
                        method: 'GET',
                        uri: `https://api.example.com/greet?name=${name}`,
                        json: true,
                    };
                    const responseData = await this.helpers.httpRequest(options);
                    */

                    const responseData = { message: `Hello, ${name || 'World'}!` };

                    // Añadir resultado a los datos de retorno
                    returnData.push({ json: responseData, pairedItem: itemIndex });
                }

            } catch (error) {
                // Manejo de errores
                if (this.continueOnFail()) {
                    returnData.push({ json: { error: error.message }, pairedItem: itemIndex });
                }
                 else {
                    if (error.context) error.context.itemIndex = itemIndex;
                    throw error;
                }
            }
        }

        return [this.helpers.returnJsonArray(returnData)];
    }
}

• description: Define metadatos y la interfaz de usuario.
  • displayName, name, icon, group, version, description: Metadatos básicos.
  • inputs, outputs: Define cuántas conexiones de entrada/salida tiene el nodo.
  • credentials: Especifica qué tipos de credenciales puede usar el nodo.
  • properties: Un array que define cada campo visible en el panel de parámetros del nodo (tipo, nombre, opciones, condiciones de visualización, etc.).
• execute(): La función principal que se ejecuta.
  • this.getInputData(): Obtiene los ítems de entrada.
  • this.getNodeParameter('nombreParametro', indiceItem, valorPorDefecto): Obtiene el valor de un parámetro configurado en la UI para el ítem actual.
  • this.getCredentials('nombreCredencial'): Obtiene las credenciales configuradas.
  • this.helpers.httpRequest(): Realiza llamadas HTTP (muy versátil).
  • this.helpers.returnJsonArray(): Formatea los datos de salida correctamente.
  • Bucle for: Itera sobre los ítems de entrada (manejo de la iteración implícita).
  • try...catch: Esencial para manejar errores durante la ejecución de un ítem.
  • this.continueOnFail(): Comprueba si el usuario activó la opción "Continue on Fail" para decidir si lanzar el error o devolverlo como parte de los datos.

Definición de Credenciales (.credentials.ts)

import { ICredentialType, INodeProperties } from 'n8n-workflow';

export class MyCredential implements ICredentialType {
    name = 'myCredentialApi'; // Nombre interno, debe coincidir con el usado en el nodo
    displayName = 'My Service API';
    documentationUrl = 'https://docs.example.com/api'; // Enlace a la documentación de la API
    properties: INodeProperties[] = [
        {
            displayName: 'API Key',
            name: 'apiKey',
            type: 'string',
            typeOptions: { password: true }, // Oculta el valor en la UI
            default: '',
        },
        {
            displayName: 'API Endpoint',
            name: 'endpoint',
            type: 'string',
            default: 'https://api.example.com',
        },
    ];
    // Opcional: Lógica de prueba de credencial
    /*
    async test(this: ICredentialTestFunctions): Promise<boolean> {
        try {
            await this.helpers.httpRequest({
                method: 'GET',
                url: this.credentials.endpoint + '/ping',
                headers: { 'X-Api-Key': this.credentials.apiKey as string },
            });
            return true;
        } catch (error) {
            throw new NodeApiError(this.getNode(), error);
        }
    }
    */
}

• Define los campos necesarios para la autenticación (properties).
• El método test (opcional) permite a los usuarios verificar si las credenciales son válidas desde la UI de n8n.

Pruebas y Depuración

1. Construir: Después de hacer cambios en el código (.ts), ejecuta npm run build para compilar a JavaScript (.js) en el directorio dist/.
2. Desarrollo Automático: Ejecuta npm run dev. Esto vigilará los cambios en tus archivos .ts, los compilará automáticamente y reiniciará n8n si es necesario, acelerando el ciclo de desarrollo.
3. Probar en n8n:
   • Abre tu instancia local de n8n.
   • Añade tu nodo personalizado a un flujo.
   • Configura sus parámetros.
   • Usa Test step para ejecutarlo y verifica la salida en el panel de resultados.
   • Usa console.log() en tu código .node.ts; la salida aparecerá en la terminal donde estás ejecutando n8n.

Linting y Formateo

El starter kit viene configurado con ESLint y Prettier.

• npm run lint: Verifica si hay problemas de estilo o errores potenciales.
• npm run format: Formatea automáticamente el código según las reglas de Prettier.

Es importante ejecutar estos comandos antes de considerar compartir tu nodo.

Compartir tu Nodo

• NPM: La forma estándar de compartir es publicar tu paquete de nodo en npm (npm publish). Otros usuarios pueden instalarlo en sus instancias de n8n (si la configuración lo permite).
• Pull Request a n8n-community-nodes: Si crees que tu nodo es útil para la comunidad, puedes seguir el proceso para incluirlo en el repositorio oficial de nodos comunitarios, haciéndolo más visible y fácil de instalar.
• Uso Privado: Puedes instalar tu nodo manualmente en tus propias instancias autoalojadas copiando el directorio compilado (dist/) o usando npm link o instalándolo desde una ruta local/git.

El desarrollo de nodos personalizados abre un mundo de posibilidades para adaptar n8n a cualquier flujo de trabajo imaginable. Aunque requiere esfuerzo de desarrollo, la capacidad de crear integraciones a medida es una de las características más potentes de n8n.

Capítulo 10: Lista Completa de Integraciones (Proveedores)

n8n se destaca por su amplia capacidad de integración con una vasta gama de aplicaciones y servicios. En el momento de la elaboración de este manual, la plataforma cuenta con más de 1000 integraciones oficiales y comunitarias, permitiendo conectar flujos de trabajo con prácticamente cualquier herramienta que utilices.

Ilustración: Visualización del vasto ecosistema de integraciones de n8n conectando diversas aplicaciones y servicios.

Dada la constante expansión y actualización de estas integraciones, mantener una lista exhaustiva y detallada dentro de este manual resulta impráctico. Sin embargo, podemos destacar las principales categorías bajo las cuales se agrupan estas integraciones en la documentación oficial:

• AI: Herramientas y servicios relacionados con Inteligencia Artificial (Modelos de lenguaje, reconocimiento de imágenes, etc.).
• Analytics: Plataformas de análisis de datos y seguimiento (Google Analytics, Mixpanel, etc.).
• Communication: Servicios de mensajería, email y colaboración (Slack, Discord, Gmail, Telegram, Twilio, etc.).
• Cybersecurity: Herramientas para la seguridad informática y análisis de amenazas.
• Data & Storage: Bases de datos, almacenamiento en la nube y hojas de cálculo (PostgreSQL, MySQL, Google Sheets, Airtable, AWS S3, MongoDB, etc.).
• Developer Tools: Herramientas para desarrolladores (GitHub, GitLab, Docker, Kubernetes, etc.).
• Development: Nodos para lógica personalizada y desarrollo (Ejecutar código, peticiones HTTP, Webhooks, etc. - Nota: Solapa con la categoría "Core").
• Evaluation: Herramientas para evaluar modelos o procesos.
• Finance & Accounting: Software de contabilidad y finanzas (Xero, QuickBooks, Stripe, etc.).
• HITL (Human in the loop): Nodos que requieren intervención humana (Aprobaciones, entradas manuales).
• Langchain: Integraciones específicas para el framework Langchain.
• Marketing: Plataformas de automatización de marketing y CRM (HubSpot, Mailchimp, ActiveCampaign, Mautic, etc.).
• Miscellaneous: Integraciones diversas que no encajan en otras categorías.
• Productivity: Herramientas para mejorar la productividad personal y de equipo (Notion, Trello, Asana, Google Calendar, Todoist, etc.).
• Sales: Herramientas enfocadas en ventas y CRM (Pipedrive, Salesforce, etc.).
• Utility: Nodos de utilidad general para manipulación de datos, control de flujo, etc. (Nota: Solapa con las categorías "Data transformation" y "Flow").

Explora la Lista Completa:

Para explorar la lista completa, actualizada y searchable de todas las integraciones disponibles en n8n, te recomendamos visitar directamente la página oficial de integraciones:

https://n8n.io/integrations/

Allí podrás buscar por nombre, categoría o palabra clave para encontrar exactamente las herramientas que necesitas conectar.

(Fin del Manual)