Expresiones en n8n: sintaxis y ejemplos 2026
En pocas palabras: Las expresiones en n8n son fragmentos de JavaScript que escribís entre llaves dobles { } dentro de cualquier campo de un nodo para transformar datos sin usar el nodo Code. Las tres variables clave son $json (item actual), $(‘Nodo’) (otros nodos) y $now (fecha).
Las expresiones en n8n son fragmentos de código JavaScript que escribís entre llaves dobles ({ }) dentro de cualquier campo de un nodo para referenciar y transformar datos al vuelo. Con ellas accedés al item actual con { $json }, traés valores de nodos anteriores con { $('NombreNodo').first() } y armás fechas con { $now }, todo sin agregar un solo nodo de código.
En 30 segundos
- Qué son: mini scripts de JavaScript entre
{ }que transforman datos dentro de los parámetros de un nodo, sin nodo Code aparte. - Las tres variables clave:
$json(item actual),$('Nodo')o$node(otros nodos) y$now(fecha y hora). - Datos anidados: notación de punto para objetos (
$json.usuario.email) y corchetes para campos con espacios ($json['Gross Price']). - Múltiples items:
.first(),.last()y.all()para elegir qué salida de otro nodo agarrás. - El error más común: olvidar las llaves dobles o escribir mal el nombre del nodo (n8n distingue mayúsculas y espacios).
Si alguna vez armaste un flujo en n8n y te quedaste mirando ese campito de texto sin saber cómo meterle el email que venía del nodo anterior, esta guía es para vos. Las expresiones son la diferencia entre un flujo rígido y uno que se adapta a cada dato que le entra. Vamos con lo concreto, con ejemplos que podés copiar y probar hoy.
¿Qué son las expresiones en n8n y para qué sirven?
Una expresión en n8n es una porción de código JavaScript que se evalúa en tiempo de ejecución y devuelve un valor dinámico dentro de un campo de parámetro. Sirve para transformar datos sin agregar nodos extra: en vez de conectar un nodo Set o un nodo Code solo para armar un texto, escribís la lógica ahí mismo, en el campo que la necesita. Viven adentro de las llaves dobles { }.
Ponele que tenés un nodo que recibe un pedido con un nombre y un total, y querés mandar un mensaje que diga “Hola Juan, tu pedido de $1500 está listo”. En vez de hardcodear nada, en el campo del mensaje escribís algo como Hola { $json.nombre }, tu pedido de ${ $json.total } está listo. n8n reemplaza cada expresión por el valor real del item que esté procesando. Es el mismo campo de texto, pero ahora respira. Lo explicamos a fondo en integrar Airtable con expresiones dinámicas.
La referencia oficial de expresiones de n8n las define como pequeñas piezas de código que referencian y transforman datos de forma dinámica dentro de tus flujos. En criollo: son el pegamento entre lo que sale de un nodo y lo que entra al siguiente.
¿Cuál es la sintaxis básica: $json, $node y $now?
Hay tres variables que vas a usar el 90% del tiempo: $json para el item actual, $node (o la sintaxis $('Nodo')) para traer datos de otros nodos, y $now para la fecha y hora. Con estas tres resolvés la mayoría de los casos antes de necesitar nada más raro.
$json: los datos del item actual
$json te da el payload completo del item que el nodo está procesando en ese momento. Para un campo específico, usá notación de punto: { $json.email }. Si el campo tiene espacios o acentos, ahí sí necesitás corchetes: { $json['Gross Price'] }. Y si querés el objeto entero (útil para debug), { $json } a secas.
$node y $(‘Nodo’): datos de nodos anteriores
Cuando el dato que necesitás no está en el item actual sino en un nodo de más atrás, tenés dos sintaxis equivalentes. La moderna: { $('NombreNodo').first().json.valor }. La clásica con corchetes: { $node['HTTP Request'].json.data }. Usá la segunda cuando el nombre del nodo tiene caracteres especiales o cuando preferís la notación de corchetes. Las dos apuntan al mismo lado.
$now: fecha y hora del momento
$now te devuelve la fecha y hora actuales como objeto Luxon, listo para formatear. Para un timestamp ISO estándar: { $now.toISO() }. ¿Querés solo la fecha en formato lindo? { $now.toFormat('dd/MM/yyyy') }. Es la forma limpia de estampar “cuándo pasó esto” sin pelearte con la fecha nativa de JavaScript (que, seamos honestos, siempre fue un dolor de cabeza). Te puede servir nuestra cobertura de construir peticiones HTTP personalizadas.
¿Cómo accedo a datos anidados y valores de otros nodos?
Para datos anidados usás notación de punto encadenada, y para múltiples items de otro nodo elegís con .first(), .last() o .all(). Un JSON real casi nunca es plano: viene con objetos adentro de objetos y arrays por todos lados. La gracia está en bajar por esa estructura sin trabarte.
- Objetos anidados: encadenás puntos.
{ $json.usuario.direccion.ciudad }baja tres niveles hasta la ciudad. - Campos con espacios: corchetes y comillas.
{ $json['Nombre Completo'] }, porque con punto rompería. - Elementos de un array: índice entre corchetes, arrancando en cero.
{ $json.items.nombre }te da el nombre del primer ítem. - Primer resultado de otro nodo:
{ $('Buscar Cliente').first().json.id }. - Último resultado:
{ $('Buscar Cliente').last().json.id }. - Todos los resultados:
{ $('Buscar Cliente').all() }cuando necesitás trabajar con la salida completa.
Ejemplos prácticos para transformar datos en tus flujos
Acá está lo bueno: las expresiones aceptan métodos de JavaScript, así que limpiás, cortás y formateás sin salir del campo. Estos seis casos cubren lo que aparece todo el tiempo en flujos reales de automatización.
- Concatenar strings:
{ $json.nombre + ' ' + $json.apellido }junta nombre y apellido en un solo campo. - Limpiar espacios:
{ $json.email.trim() }saca los espacios que se cuelan al principio y al final (el clásico copy-paste sucio). - Pasar a minúsculas:
{ $json.email.toLowerCase() }para normalizar mails antes de compararlos o guardarlos. - Extraer el dominio de un email:
{ $json.email.split('@') }te devuelve lo que va después de la arroba. - Formatear una fecha que viene en ISO:
{ $json.fecha.toDateTime().toFormat('dd/MM/yyyy') }. - Condicional simple inline:
{ $json.total > 1000 ? 'VIP' : 'Estándar' }etiqueta el pedido según el monto.
¿Cómo uso expresiones en condicionales para decidir dinámicamente?
En los nodos If y Switch, las expresiones evalúan una condición y devuelven verdadero o falso para rutear el flujo por una rama u otra. Ahí no armás un texto, armás una decisión. Los operadores son los de JavaScript de siempre.
- Igualdad estricta:
{ $json.estado === 'pendiente' }. Usá tres iguales, no dos, para evitar sorpresas de tipos. - Distinto:
{ $json.estado !== 'cerrado' }. - Mayor o menor:
{ $json.monto > 1000 }o{ $json.stock < 5 }. - Y lógico:
{ $json.monto > 1000 && $json.pais === 'AR' }exige que se cumplan las dos. - O lógico:
{ $json.plan === 'pro' || $json.plan === 'enterprise' }con que se cumpla una alcanza.
¿La ventaja frente a tirar un nodo Code para cada decisión? Que la lógica queda a la vista, pegada al nodo que la usa, y cualquiera que abra el flujo entiende qué está pasando sin abrir un editor de código. Para más detalles técnicos, mirá personalizar mensajes para Slack.
Errores comunes con las expresiones (y cómo evitarlos)
Estos son los tropiezos que le pasan a todo el que arranca con expresiones en n8n. Ninguno es grave, pero te comen media hora si no sabés dónde mirar.
- Olvidar las llaves dobles. Si escribís
$json.emailpelado, n8n lo trata como texto literal. Tiene que ir{ $json.email }. Un campo pasa a modo expresión recién cuando ve las llaves (o cuando tocás el ícono de engranaje y elegís "expresión"). - Errar el nombre del nodo. n8n distingue mayúsculas, minúsculas y espacios. Si tu nodo se llama "HTTP Request" y ponés
$('http request'), no lo encuentra. Copialo tal cual aparece. - No elegir el item con .first() o .last(). Cuando referenciás otro nodo que devolvió varios items y no aclarás cuál querés, la expresión se confunde. Poné
{ $('Nodo').first().json.campo }para ser explícito. - Confundir $json con $node.
$jsones el item que estás procesando ahora;$nodeo$('Nodo')es para traer datos de otro nodo. Si mezclás, terminás leyendo el dato equivocado y ni te das cuenta. - No usar corchetes en campos con espacios.
{ $json.Gross Price }revienta;{ $json['Gross Price'] }funciona. Lo mismo con acentos y caracteres especiales.
Cheat sheet de las Expresiones en n8n más usadas
| Expresión | Qué hace | Cuándo usarla |
|---|---|---|
{ $json } | Todo el payload del item actual | Debug o pasar el objeto completo |
{ $json.campo } | Un campo del item actual | Traer un valor puntual |
{ $json['con espacio'] } | Campo con espacios o acentos | Nombres de campo raros |
{ $json.items } | Primer elemento de un array | Acceder a listas por índice |
{ $('Nodo').first() } | Primer item de otro nodo | Solo el primer resultado previo |
{ $('Nodo').last() } | Último item de otro nodo | Solo el último resultado previo |
{ $('Nodo').all() } | Todos los items de otro nodo | Trabajar con la salida completa |
{ $node['Nodo'].json.x } | Sintaxis alternativa por corchetes | Nombres con caracteres especiales |
{ $now.toISO() } | Fecha y hora actual en ISO | Timestamps estándar |
{ $now.toFormat('dd/MM/yyyy') } | Fecha con formato propio | Mostrar fechas legibles |
{ $json.x.trim() } | Saca espacios sobrantes | Limpiar datos de entrada |
{ $json.x.toLowerCase() } | Pasa a minúsculas | Normalizar emails o textos |
{ $json.x.split('@') } | Corta el string por un separador | Extraer partes (dominio, etc.) |
{ $json.a + ' ' + $json.b } | Concatena strings | Armar nombres o mensajes |
{ $json.x > 1000 } | Compara valores | Condiciones en If / Switch |
{ cond ? 'A' : 'B' } | Condicional ternario inline | Etiquetar según una regla |
Un apunte de infraestructura: si corrés tu propia instancia de n8n (self-hosted), estas expresiones se ejecutan en tu servidor, así que la latencia y la estabilidad del flujo dependen del hosting. Para alojar n8n en un VPS confiable con soporte en español, donweb.com tiene planes de cloud que aguantan bien cargas de automatización sin que tengas que pelearte con la configuración.
Preguntas Frecuentes
¿Qué son las expresiones en n8n?
Son fragmentos de código JavaScript que escribís entre llaves dobles ({ }) dentro de los campos de un nodo para referenciar y transformar datos de forma dinámica. Te permiten armar textos, hacer cálculos o tomar valores de nodos anteriores sin agregar un nodo Code aparte.
¿Cómo accedo a datos de nodos anteriores en n8n?
Usás { $('NombreNodo').first().json.campo } para el primer item o .last() para el último. La sintaxis alternativa es { $node['NombreNodo'].json.campo }. El nombre del nodo tiene que coincidir exactamente, incluyendo mayúsculas y espacios.
¿Cuál es la diferencia entre $json y $node en n8n?
$json apunta a los datos del item que el nodo está procesando en ese momento. $node (o $('Nodo')) trae datos de otro nodo del flujo, uno anterior. Si necesitás un valor del paso previo, usás $node; si es del dato actual, $json. Esto se conecta con lo que analizamos en instalar n8n en tu entorno.
¿Cuál es la sintaxis correcta para acceder a datos anidados?
Para objetos anidados encadenás puntos: { $json.usuario.direccion.ciudad }. Para campos con espacios o acentos usás corchetes con comillas: { $json['Nombre Completo'] }. Para elementos de un array, corchetes con el índice: { $json.items.nombre }.
¿Cómo personalizo mensajes dinámicos con expresiones?
Mezclás texto fijo con expresiones en el mismo campo: Hola { $json.nombre }, tu pedido de ${ $json.total } está en camino. n8n reemplaza cada { } por el valor real de cada item, así que un solo mensaje se personaliza para cada registro que pase por el flujo.
Conclusión
Las expresiones son lo que separa un flujo de n8n armado a los ponchazos de uno que se banca datos reales, variables y desprolijos. Con dominar $json, $('Nodo') y $now, más los métodos básicos de JavaScript como .trim(), .split() y el ternario, ya cubrís la enorme mayoría de los casos sin tocar un nodo Code.
Mi consejo: guardate la cheat sheet de arriba, y cuando algo no funcione, revisá primero las llaves dobles y el nombre exacto del nodo. Son el 80% de los errores. Abrí un flujo de prueba, tirá cuatro o cinco de estos ejemplos, y en media hora las vas a estar usando sin pensarlas.
