Introduzione alle Espressioni in n8n: Personalizzare i Nodi in Modo Dinamico

Le espressioni n8n sono il “trucco” che trasforma un workflow da statico a intelligente. Per un marketer, questa è la differenza tra un’automazione che invia lo stesso messaggio a tutti e una pipeline capace di personalizzare contenuti, orari, e canali in base ai dati reali di ogni contatto. In questo articolo scoprirai come usare le espressioni per impostare valori dinamici nei parametri dei nodi, come leggere e trasformare dati con le variabili $json e i riferimenti ad altri nodi, e come sfruttare librerie integrate come JMESPath per dati JSON in n8n e Luxon per formattare date in n8n. Vedrai anche come scrivere piccoli template JavaScript in n8n, quando ricorrere a IIFE nelle espressioni n8n per logiche multi-step, e come fare debugging delle espressioni n8n con fallback sicuri quando i dati sono undefined.

📚 Nuovo a n8n? Parti dalla guida completa: cos’è n8n e come funziona.

Ti guiderò in modo pratico: dalla sintassi base a esempi end-to-end, passando per best practice operative e suggerimenti per marketer che vogliono migliorare la produttività senza scrivere un’intera app. Se vuoi capire davvero come usare le espressioni in n8n per orchestrare micro-personalizzazioni ad alto impatto, questo è il punto di partenza.

Perché usare le espressioni: ruolo, casi d’uso e quando preferirle a valori statici

Le espressioni in n8n permettono di trasformare qualsiasi campo di configurazione in un valore dinamico, valutato a runtime. Questo significa impostare oggetti, stringhe, URL, header, body e opzioni in base ai dati in arrivo e al contesto del workflow. Per marketer, traduce in:

Personalizzazione di messaggi (subject, copy, CTA) con campi del profilo.
Routing condizionale su comportamenti (aperture, acquisti, lead score).
Pianificazione “smart” con date/ore calcolate.
Naming coerente per asset (slug, UTM, file name) generati al volo.

Quando preferirle a valori statici:

Quando il valore dipende da dati variabili (profilo utente, evento, risposta API).
Quando vuoi riusare lo stesso workflow su dataset diversi.
Quando serve coerenza temporale o formattazione (es. orario locale, ISO, UTM).

Esempio tipico: un Set node con espressioni dinamiche che costruisce un “fullName” da firstName/lastName, una “segment” in base al lead score e un “sendAt” calcolato con $now. Il vantaggio è ridurre i nodi “di servizio” (IF/Code) a favore di una pipeline più leggibile.

Pro tip unico: crea “micro-contratti” di dati subito dopo l’ingresso nel workflow (Webhook/Trigger + Set) usando espressioni. Normalizzi i campi chiave una volta sola e alimenti il resto del flusso con una struttura prevedibile.

Sintassi base: $json, riferimenti ad altri nodi e valutazione runtime

Formato: le espressioni si scrivono tra doppie graffe: {{ … }}. Sono valutate al runtime, cioè durante l’esecuzione reale del workflow.
Dati correnti: usa la variabile speciale $json per accedere al JSON dell’item in arrivo nel nodo corrente.
Top-level: {{ $json.email }}
Nidificato: {{ $json.body.city }}
Notazione alternativa: {{ $json[‘body’][‘city’] }}
Riferire altri nodi: quando serve un output precedente specifico, usa $node[“NomeNodo”].json
Esempio: {{ $node[“HTTP Request”].json.data.id }}

JMESPath per dati JSON in n8n:

n8n supporta JMESPath per interrogare JSON. La sintassi puntata come body.city e la forma con indici/bracket sono valide per accedere a proprietà nidificate.
Caso d’uso: estrarre un campo annidato da un webhook senza Code node: {{ $json.body.profile.firstName }}

Valutazione runtime e placeholder:

Le espressioni possono concatenare stringhe, leggere date e usare metodi JS (stringhe/array/numeri). Esempio: {{ ($json.firstName || “Amico”).toUpperCase() }}
Le espressioni funzionano ovunque nei parametri dei nodi: URL, Body, Headers, campi testuali e opzioni.

L’Editor delle Espressioni: attivazione, anteprima e flusso di lavoro

Modalità di attivazione dell’editor espressioni:

In qualsiasi campo di un nodo, clicca l’icona accanto al parametro e seleziona “Add Expression” per aprire l’Edit Expression modal.
L’editor evidenzia la sintassi e mostra un’anteprima del valore risolto quando disponibili dati di esecuzione.

Passi consigliati:

Avvia con un workflow minimo (Manual Trigger → Set) per verificare la struttura del JSON.
Inserisci un’espressione semplice come {{ $json.body.city }} e osserva l’anteprima.
Aggiungi complessità gradualmente (concatenazioni, fallback, formattazione date).

[IMG: Apertura dell’Edit Expression modal e anteprima del valore risolto]

Consigli pratici:

Test incrementali: esegui il workflow fino al nodo di riferimento per popolare l’anteprima.
Tipi corretti: evita di “stringare” numeri/boolean; lascia i tipi nativi per non rompere API a valle.
Riuso: copia/incolla espressioni tra parametri per mantenere coerenza.

Esempi pratici: Set node con espressioni dinamiche

Il Set node è perfetto per modellare e arricchire i dati in ingresso.

Obiettivo: costruire campi pronti per messaggistica multicanale.

Configurazione (UI):

Aggiungi un Set node dopo il tuo trigger (es. Webhook).
“Keep Only Set” = disabilitato per mantenere anche i campi esistenti.
Aggiungi campi:
fullName = {{ ${$json.firstName ?? ""} ${$json.lastName ?? ""}.trim() || “Senza Nome” }}
segment = {{ $json.leadScore >= 80 ? “hot” : ($json.leadScore >= 50 ? “warm” : “cold”) }}
city = {{ $json.body?.city ?? “NA” }}
emailDomain = {{ ($json.email?.split(“@”)[1] ?? “”).toLowerCase() }}

JSON di esempio del Set node:

{

“name”: “Set Fields”,

“type”: “n8n-nodes-base.set”,

“typeVersion”: 1,

“parameters”: {

“keepOnlySet”: false,

“values”: {

“fullName”: “{{ (${$json.firstName ?? \"\"} ${$json.lastName ?? \"\"}).trim() || \”Senza Nome\” }}”,

“segment”: “{{ $json.leadScore >= 80 ? \”hot\” : ($json.leadScore >= 50 ? \”warm\” : \”cold\”) }}”,

“city”: “{{ $json.body?.city ?? \”NA\” }}”,

“emailDomain”: “{{ ($json.email?.split(\”@\”)[1] ?? \”\”).toLowerCase() }}”

}

[IMG: Configurazione del Set node con 4 campi dinamici]

Insight operativo:

Usa Set all’inizio per “normalizzare” i dati e rendere più semplice il routing successivo (IF, Switch) e l’invio a Slack/Email. Questo pattern migliora la leggibilità e riduce gli errori.

Date e orari con Luxon: $now e $today, formattazioni e timezone

n8n usa Luxon per lavorare con date e tempo. Variabili comode:

$now: oggetto DateTime corrente (Luxon).
$today: oggetto DateTime a mezzanotte (oggi).

Esempi pratici:

Timestamp ISO: {{ $now.toISO() }}
Formattazione leggibile: {{ $now.toFormat(“yyyy-LL-dd HH:mm”) }}
Programmazione invio fra 3 giorni: {{ $now.plus({ days: 3 }).toISODate() }}
Solo data (oggi): {{ $today.toFormat(“dd/LL/yyyy”) }}

Avvertenza importante:

Non mescolare Date native JS e Luxon senza conversione. Resta in Luxon per coerenza.

Caso marketing:

Pianifica follow-up per contatti “warm” a 48 ore: {{ $now.plus({ hours: 48 }).toISO() }}
Aggiungi fuso orario nella formattazione: {{ $now.setZone(“Europe/Rome”).toFormat(“dd LLL yyyy, HH:mm ZZZZ”) }}

[IMG: Esempi di espressioni con $now e $today nella finestra Edit Expression]

Template JavaScript e IIFE nelle espressioni: quando servono logiche multi-step

Oltre a semplici accessi ai dati, puoi eseguire JavaScript dentro un’espressione. Per logiche multi-step, usa una IIFE (Immediately Invoked Function Expression):

Esempi:

Classificazione punteggio:

{{ (() => { const s = $json.leadScore ?? 0; if (s >= 90) return “A+”; if (s >= 75) return “A”; if (s >= 60) return “B”; return “C”; })() }}

Slug SEO sicuro:

{{ (() => { const t = $json.title ?? “”; return t.toLowerCase().normalize(“NFD”).replace(/[^\w\s-]/g,””).replace(/\s+/g,”-“).replace(/-+/g,”-“).trim(); })() }}

Quando usarle:

Quando nel parametro serve una mini-logica con 2+ passaggi ma non vuoi introdurre un Code node.
Per calcoli/normalizzazioni inline che restano leggibili.

Suggerimento:

Mantieni la IIFE breve e commenta il senso combinando Set node + nome campo chiaro.

[IMG: Esempio di IIFE nel campo “Subject” di un nodo Email]

JMESPath: accesso pulito ai dati JSON annidati

Le espressioni in n8n supportano JMESPath per interrogare dati JSON in modo chiaro:

Accesso semplice: {{ $json.body.city }}
Forma alternativa: {{ $json[“body”][“city”] }}
Array e proprietà: {{ $json.payload.items[0].name }} se la struttura contiene un array.

Best practice:

Mantieni le query semplici e trasparenti per chi legge dopo di te.
Se devi fare filtri avanzati su array, considera un Code node o pre-elaborazioni a monte.

Use case marketing:

Attribuire un canale da payload tracciato: {{ $json.tracking?.utm_source ?? “direct” }}

Debugging delle espressioni e gestione errori (undefined e fallback)

Errori comuni e come risolverli:

“Referenced node is unexecuted”
Significa che un’espressione richiama un nodo che non è ancora stato eseguito.
Soluzione: esegui il workflow fino a quel nodo o ricollega il flusso in modo che il nodo venga eseguito prima di essere referenziato.
“The ‘JSON Output’ in item 0 does not contain a valid JSON object”
Accade quando usi una modalità JSON ma il contenuto non è un JSON valido (virgolette, virgole, tipi).
Soluzione: valida il JSON e assicurati che numeri/boolean non siano tra virgolette quando non serve.

Gestione errori undefined e fallback:

Optional chaining: {{ $json.user?.name }}
Nullish coalescing: {{ $json.user?.name ?? “Sconosciuto” }}
Fallback multipli: {{ $json.company?.name ?? $json.org?.title ?? “N/A” }}

Consigli di debug:

Parti da espressioni minime e verifica l’anteprima nell’Editor delle espressioni.
Esegui il workflow passo-passo per avere dati reali in anteprima.
Mantieni tipi corretti: non forzare numeri come stringhe.

[IMG: Esempio di errore “Referenced node is unexecuted” e percorso di fix]

Pattern e best practice operative per marketer

Preferisci espressioni per trasformazioni semplici: concatenazioni, formattazioni, pick di campi.
Usa Set come “livello di normalizzazione” subito dopo il trigger; standardizza nomi e tipi una volta sola.
Sposta logiche complesse in Code node solo quando serve; evita di appesantire i parametri con IIFE molto lunghe.
Mantieni le espressioni leggibili: usa nomi campo autoesplicativi e commenta dove possibile.
Performance: se devi lavorare su molteplici item, evita di accumulare logiche pesanti in un solo punto; usa batching (SplitInBatches) e trasformazioni semplici con espressioni.
Sicurezza: lascia credenziali e segreti nei loro nodi/credential store, non hardcodarli in espressioni.

Mini caso d’uso per marketer: personalizza un annuncio Slack in base al profilo

Scenario: inviare un messaggio Slack personalizzato quando arriva un nuovo lead.

Workflow:

Webhook (trigger) — riceve { firstName, lastName, email, leadScore, city }
Set — normalizza e arricchisce
Slack — invia messaggio nel canale vendite

Step-by-step:

Webhook
Metodo: POST
Path: /new-lead

[IMG: Configurazione Webhook con anteprima payload]

Set (Keep Only Set = off)
fullName: {{ (${$json.firstName ?? ""} ${$json.lastName ?? ""}).trim() || “Senza Nome” }}
segment: {{ $json.leadScore >= 80 ? “hot” : ($json.leadScore >= 50 ? “warm” : “cold”) }}
city: {{ $json.city ?? “NA” }}
emailDomain: {{ ($json.email?.split(“@”)[1] ?? “”).toLowerCase() }}
followUpAt: {{ $now.plus({ hours: 24 }).toFormat(“yyyy-LL-dd HH:mm”) }}

[IMG: Set node con cinque campi dinamici valorizzati da espressioni]

Slack (Send Message)
Channel: #sales
Text:

Nuovo lead {{ $json.fullName }} ({{ $json.emailDomain }})

Segmento: {{ $json.segment }} | Città: {{ $json.city }}

Follow-up entro: {{ $json.followUpAt }}

Priorità: {{ $json.segment === “hot” ? “ALTA” : “NORMALE” }}

[IMG: Slack node con messaggio dinamico e anteprima]

Risultato:

Messaggi chiari e coerenti per il team vendite, con campi calcolati da espressioni e tempi di follow-up standardizzati con Luxon.

Quick Takeaways

Le espressioni n8n rendono dinamici i parametri dei nodi, trasformando dati in tempo reale.
Usa $json per il dato corrente e $node[“Nome”] per referenziare output precedenti.
JMESPath e notazione puntata semplificano l’accesso a JSON annidati.
Luxon ($now, $today) offre date/ore accurate e formattazioni facili.
IIFE nelle espressioni risolvono micro-logiche senza introdurre un Code node.
Per errori: controlla nodi non eseguiti e JSON non valido; usa fallback (?. e ??).
Normalizza presto con un Set node e mantieni le espressioni concise e leggibili.

Conclusione

Le espressioni n8n sono uno strumento potente per chi fa marketing automation: riducono nodi superflui, abilitano personalizzazioni profonde e tengono la logica dove serve, nel contesto dei dati. Con $json e i riferimenti ad altri nodi puoi leggere qualunque informazione in arrivo, mentre JMESPath ti aiuta a navigare JSON complessi senza sforzo. Luxon ti permette di pianificare e formattare date con precisione, e con piccole IIFE porti la giusta dose di logica nei parametri senza cadere nel “Code node a tutti i costi”. Le best practice proposte — normalizzare i campi subito, preferire espressioni per trasformazioni semplici, usare fallback sicuri — ti faranno risparmiare tempo e ridurranno errori in produzione.

Se il tuo obiettivo è aumentare la produttività e la personalizzazione delle campagne, inizia a sostituire valori statici con espressioni mirate e standardizza i tuoi “contratti di dati” con un Set node strategico. In poche iterazioni, il tuo workflow diventerà più robusto, leggibile e facile da scalare su nuove iniziative e canali.

FAQ

Cosa sono le espressioni in n8n e perché sono utili?

Le espressioni in n8n sono frammenti dinamici ({{ … }}) che leggono e trasformano dati nei parametri dei nodi. Sono utili per personalizzare contenuti, calcolare date con Luxon e collegare valori tra nodi senza codice verboso.

Come uso variabili $json e riferimenti ad altri nodi?

Per il dato corrente usa {{ $json.campo }}. Per leggere l’output di un nodo specifico: {{ $node[“NomeNodo”].json.campo }}. È il modo più semplice di impostare valori dinamici nei parametri dei nodi.

Posso usare jmespath per dati JSON in n8n?

Sì, l’accesso a proprietà annidate segue una sintassi compatibile (es. {{ $json.body.city }} o {{ $json[“body”][“city”] }}). Per filtri complessi valuta un Code node.

Come funziona luxon per formattare date in n8n?

$now e $today sono oggetti Luxon. Puoi usare metodi come toFormat, toISO e plus: {{ $now.plus({ days: 2 }).toFormat(“yyyy-LL-dd”) }}. Evita di mescolare Date native senza conversione.

Come gestisco debugging delle espressioni n8n e fallback?

Usa l’Edit Expression modal per anteprima e testa il workflow fino ai nodi referenziati. Per la gestione errori undefined e fallback adopera optional chaining e nullish coalescing: {{ $json.user?.name ?? “Sconosciuto” }}.

Hai trovato utile questa guida sulle espressioni n8n? Dicci quale personalizzazione userai per prima nel tuo workflow e condividi l’articolo con i colleghi marketer che vogliono automatizzare in modo più intelligente!