Introducción

El nodo Set es tu herramienta principal para remodelar datos a medida que fluyen por los workflows de n8n. A diferencia de los nodos que obtienen datos externos, Set se centra por completo en transformar lo que ya tienes: añadir nuevos campos, sobrescribir los existentes o eliminar los que no necesitas. Esto lo hace esencial para preparar payloads antes de enviarlos a APIs, bases de datos u otros servicios.

Cada elemento en n8n es un objeto JSON. El nodo Set te permite definir exactamente qué campos debe contener cada elemento y qué valores deben tener. Puedes codificar valores de forma fija, copiar datos de otros campos o usar expresiones para calcular nuevos valores a partir de datos anteriores.

Operaciones básicas de campos

El nodo Set opera en uno de dos modos: Keep Only Set (reemplaza el elemento completo con solo los campos que definas) o Add/Overwrite (fusiona tus nuevos campos en el elemento existente). Para la mayoría de las tareas de transformación, Add/Overwrite te ofrece más flexibilidad.

Para añadir un campo, haz clic en Add Field y elige el tipo adecuado: String, Number, Boolean u otros. Cada campo requiere un nombre y un valor. El nombre se convierte en la clave JSON y el valor puede ser texto estático, un número o una expresión.

// Example: Transforming API response items
// Input item from HTTP Request node:
{
  "user_id": 42,
  "full_name": "Alice Smith",
  "created_at": "2024-01-15T10:30:00Z"
}

// Set node configuration (Add/Overwrite mode):
// Field 1: id (Number) = {{$json.user_id}}
// Field 2: name (String) = {{$json.full_name}}
// Field 3: isActive (Boolean) = true

// Output item:
{
  "user_id": 42,
  "full_name": "Alice Smith",
  "created_at": "2024-01-15T10:30:00Z",
  "id": 42,
  "name": "Alice Smith",
  "isActive": true
}

Observa que los campos originales se mantienen. Si cambias al modo Keep Only Set, la salida contendría solo id, name e isActive.

Referencia a datos anteriores mediante expresiones

Las expresiones son la forma de acceder a datos de nodos anteriores. El patrón más común es {{$json.fieldName}}, que lee un campo del elemento actual. También puedes usar JavaScript dentro de las expresiones para transformar valores sobre la marcha.

// Input item:
{
  "email": "alice@example.com",
  "score": 85
}

// Set node fields using expressions:
// Field 1: username (String) = {{$json.email.split('@')[0]}}
// Field 2: domain (String) = {{$json.email.split('@')[1]}}
// Field 3: passed (Boolean) = {{$json.score >= 70}}
// Field 4: grade (String) = {{$json.score >= 90 ? 'A' : $json.score >= 70 ? 'B' : 'C'}}

// Output item:
{
  "email": "alice@example.com",
  "score": 85,
  "username": "alice",
  "domain": "example.com",
  "passed": true,
  "grade": "B"
}

Puedes referenciar campos de otros nodos usando {{$node.NodeName.json.fieldName}}. Esto es útil cuando necesitas combinar datos de múltiples fuentes o comparar valores entre pasos del workflow.

// Example: Combining data from two nodes
// Webhook node output: {"orderId": "ORD-123"}
// HTTP Request node output: {"status": "shipped", "trackingCode": "TRK-456"}

// Set node fields:
// Field 1: order (String) = {{$node.Webhook.json.orderId}}
// Field 2: status (String) = {{$json.status}}
// Field 3: tracking (String) = {{$json.trackingCode}}

// Output:
{
  "order": "ORD-123",
  "status": "shipped",
  "tracking": "TRK-456"
}

Eliminación de campos no deseados

A veces necesitas eliminar campos sensibles o innecesarios antes de enviar datos aguas abajo. En el modo Keep Only Set, simplemente defines los campos que quieres conservar y todo lo demás desaparece. En el modo Add/Overwrite, eliminar campos requiere usar el interruptor Remove Other Fields o establecer manualmente los campos como null.

// Input item with sensitive data:
{
  "userId": 42,
  "email": "alice@example.com",
  "password_hash": "$2b$10$abcd...",
  "internal_notes": "VIP customer",
  "created_at": "2024-01-15T10:30:00Z"
}

// Set node in Keep Only Set mode:
// Field 1: userId (Number) = {{$json.userId}}
// Field 2: email (String) = {{$json.email}}

// Output (password and notes removed):
{
  "userId": 42,
  "email": "alice@example.com"
}

Este enfoque es más seguro que intentar eliminar campos individualmente, especialmente cuando se trata de estructuras de datos dinámicas donde podrías no conocer todos los nombres de los campos de antemano.

Patrones comunes y problemas frecuentes

Cuando construyas transformaciones complejas, trabaja de forma incremental. Añade uno o dos campos, ejecuta el nodo y verifica la salida antes de añadir más. Esto facilita mucho la depuración en comparación con configurar diez campos a la vez y luego solucionar errores.

Los errores de expresión son comunes. Si una expresión falla al evaluarse, n8n generalmente deja el campo vacío o muestra un indicador de error. Verifica tu sintaxis: las expresiones deben estar envueltas en dobles llaves, y el código JavaScript dentro debe ser válido. Usa el panel Expression Editor para probar expresiones antes de confirmarlas.

Los desajustes de tipo pueden causar problemas posteriores. Si un campo espera un número pero recibe una cadena, conviértelo explícitamente usando Number o parseInt dentro de tu expresión. De forma similar, usa String para convertir números a texto cuando sea necesario.

// Type conversion examples:
// Field 1: age (Number) = {{Number($json.age_string)}}
// Field 2: id (String) = {{String($json.numeric_id)}}
// Field 3: price (Number) = {{parseFloat($json.price_with_currency.replace('$', ''))}}

El nodo Set procesa cada elemento de forma independiente. Si tienes 50 elementos entrando al nodo, cada uno se transforma según las definiciones de tus campos. Esto significa que expresiones como {{$json.fieldName}} siempre se refieren al elemento actual que se está procesando, no al array completo.

Resumen

El nodo Set es tu bisturí para la transformación de datos en n8n. Usa el modo Add/Overwrite cuando quieras aumentar los datos existentes, y Keep Only Set cuando necesites crear una base limpia con solo campos específicos. Las expresiones te permiten referenciar datos desde cualquier parte de tu workflow y aplicar transformaciones de JavaScript en línea. Domina el nodo Set y dedicarás menos tiempo a luchar con formatos de datos y más tiempo a construir workflows funcionales.