Creación de nodos programáticos con execute en n8n

Crear nodos personalizados en n8n puede ser rápido y claro si eliges bien el enfoque. Aquí verás cómo pasar del estilo declarativo al programático con JavaScript y la función execute, gestionar credenciales, construir la petición HTTP y preparar un output consistente. Ideal para quienes quieren control total sobre la lógica y el formato de datos.

¿Qué diferencia hay entre el estilo declarativo y el programático en n8n?

El enfoque declarativo es como completar un formulario: defines entradas, salidas y comportamiento sin código. Es perfecto para conectar con una API o transformaciones simples. En cambio, el enfoque programático te da control total: escribes JavaScript, manejas condicionales, errores y formatos particulares. En pocas palabras: si buscas rapidez y estructura, usa declarativo; si necesitas flexibilidad y lógica avanzada, toca picar código con execute.

• Declarativo: ideal para conexiones directas y transformación simple de datos.
• Programático: control total con execute, bucles, manejo de errores y formatos complejos.
• Consejo clave: elimina de la parte declarativa lo que ya resuelves en execute.

¿Cómo se implementa un nodo programático con execute y credenciales?

Se parte de un nodo existente y se migra su lógica a la función execute. La guía oficial menciona build your node y el tutorial build a programmatic style node, donde se copian cabeceras necesarias y se prepara el esqueleto.

¿Cómo preparar la cabecera y dependencias del nodo?

• Copia la cabecera sugerida por la documentación y sustituye la primera línea del archivo. Incluye lo necesario para addExecuteFunctions.
• Quita imports o utilidades que ya están en el core y no se usan.
• Elimina opciones como routing y qs de la parte declarativa: ahora eso vive en execute.
• Añade la librería requerida para nodos programáticos: node connection type. Tras incluirla, desaparecen errores en rojo.

¿Cómo estructurar la función execute para procesar items?

Dentro de execute, obtén los items del nodo anterior, recorre cada elemento, lee parámetros, usa credenciales y acumula el resultado en un array para devolver un output consistente.

async execute() {
  const items = this.getInputData();
  const returnData: Array<{ json: Record<string, any> }> = [];

  for (let i = 0; i < items.length; i++) {
    const email = this.getNodeParameter('email', i) as string;

    const credentials = await this.getCredentials('ApiKeyCamel');
    const apiKey = credentials?.API_key;

    const response = await this.helpers.httprequest({
      method: 'GET',
      url: 'https://TU_ENDPOINT_AQUI',
      qs: { email, ApiKey: apiKey },
      headers: { accept: 'application/json' },
      JSON: true,
    });

    const results = Array.isArray(response) ? response : [response];

    for (const result of results) {
      returnData.push({
        json: {
          email: result.email,
          // ejemplo de campo booleano u otros datos del servicio
          // sePuedeEntregar: result.state === 'deliverable',
          score: result.score,
        },
      });
    }
  }

  return this.prepareOutputData(returnData);
}

Claves prácticas: - Usa this.getInputData para leer el input del nodo anterior. - Usa this.getNodeParameter para extraer parámetros como email. - Usa this.getCredentials y accede a API_key con seguridad opcional. - Asegura un output uniforme: si la respuesta no es array, encapsúlala. - Evita retornar dentro del bucle: el return va al final de execute.

¿Cómo construir la petición HTTP y manejar la respuesta JSON?

La llamada HTTP replica lo que harías con routing, pero ahora en código. Define método, url, query parameters, headers y marca JSON: true para que se gestione el content type automáticamente.

const response = await this.helpers.httprequest({
  method: 'GET',
  url: 'https://TU_ENDPOINT_AQUI',
  qs: {
    email,
    ApiKey: apiKey,
  },
  headers: {
    accept: 'application/json',
  },
  JSON: true,
});

const results = Array.isArray(response) ? response : [response];

for (const result of results) {
  returnData.push({
    json: {
      email: result.email,
      // sePuedeEntregar: ...
      score: result.score,
    },
  });
}

Errores típicos a evitar: - Nombres que no coinciden: credencial usada en el nodo y declarada, p. ej., ApiKeyCamel y API_key. - Dejar rastro declarativo que duplique la call a la API: borra routing y cualquier referencia a la API en la descripción. - Falta de la librería node connection type en nodos programáticos.

¿Cómo probar el nodo en n8n y validar el output?

Tras ajustar el código, compila y enlaza la librería para probar en el editor.

• Ejecuta el build: pmpm run y build.
• Enlaza tu paquete: pmpm link y conecta la librería.
• Lanza n8n en la línea de comandos y abre localhost:5678.
• Inicia sesión y añade un manual trigger y el nodo verificar email.
• Configura la API key desde tu plataforma y pégala en el workflow.
• Prueba con un email real como promptandplay@gmail.com y verifica que el output muestre: email, si se puede entregar y score.
• Cambia el código para quitar o añadir atributos, vuelve a hacer build, reinicia el servidor y comprueba que el output refleja el cambio.

¿Ya lo tienes funcionando? Comparte qué campos añadiste y pega tu captura en los comentarios.