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.

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:
1) Avvia con un workflow minimo (Manual Trigger → Set) per verificare la struttura del JSON.
2) Inserisci un’espressione semplice come {{ $json.body.city }} e osserva l’anteprima.
3) 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:
1) Webhook (trigger) — riceve { firstName, lastName, email, leadScore, city }
2) Set — normalizza e arricchisce
3) 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!