Guide complet pour maitriser les expressions n8n

Je conçois et maintiens les nombreux workflows n8n de mes clients. Les expressions n8n sont mon accélérateur principal : elles me permettent de paramétrer finement les nœuds, de nettoyer la donnée « à la voléeé, d’éviter des nœuds “Code” quand ce n’est pas nécessaire, et de rendre un workflow lisible. Mon objectif ici est double : vous donner un savoir opératoire (quoi écrire, où, pourquoi) et une méthode (comment rester lisible, testable et stable).

Objectif clair de Franck le formateur n8n : à la fin, vous saurez quoi écrire entre {{ ... }}, où l’écrire, comment accéder à vos données, comment formater proprement, comment gérer les dates avec Luxon, comment requêter du JSON avec $jmespath(), comment déboguer et comment rester lisible. Le tout avec des exemples complets et reproductibles.

Qu’est-ce que les expressions n8n ? (guide, aide)

Définition simple. Une expression n8n est un petit morceau de JavaScript écrit entre {{ et }}. n8n évalue ce code et remplace l’expression par sa valeur. Vous pouvez :

• lire les données de l’item courant avec $json,
• lire des fichiers ou méta avec $binary,
• accéder à la sortie d’un autre nœud avec $("NomDuNœud"),
• manipuler dates/temps avec Luxon via $now et $today,
• interroger du JSON avec JMESPath via $jmespath(obj, requête).

Où peut-on écrire une expression ? Dans la majorité des champs des nœuds (Set, HTTP Request, If, etc.). Dans l’UI, cliquez sur l’icône “Expression” à droite du champ pour passer en mode expression.

Exemple minimal.
Entrée (item courant) :

{ "email": "alice@example.com", "id": 42 }

Découvrez égalementComment automatiser la gestion de votre boîte Gmail avec n8n ?

Expression dans un champ :

{{$json.email}}

Sortie dans ce champ :

alice@example.com

Où écrire des expressions n8n et comment s’assurer que ça marche ? (tuto)

1. Ouvrez un nœud (ex. Set).
2. Dans un champ, cliquez sur l’icône “Expression”.
3. Tapez {{$json}} pour visualiser l’objet courant.
4. Remplacez ensuite par la propriété voulue : {{$json.email}}.
5. Vérifiez l’aperçu (n8n montre la valeur résolue sous le champ).
6. Exécutez le nœud pour confirmer le résultat.

Astuce : “Pin data” sur les nœuds amont pour geler un jeu de test et stabiliser vos essais.

Quelles variables et méthodes existent en expressions n8n ? (support, aide)

Mini-exercice. Dans un nœud Set :

• user_id = {{$("Fetch User").first().json.id}}
• full_name = {{[$json.first,$json.last].filter(Boolean).join(" ")}}
• created_iso = {{$now.toISO()}}

Comment accéder aux données d’autres nœuds avec les expressions n8n ? (guide)

Règle pratique :

• $("Nom").first() quand le nœud renvoie un seul item logique.
• $("Nom").last() quand le nœud s’exécute plusieurs fois et vous voulez la dernière exécution.
• $("Nom").all() pour récupérer tous les items et les transformer (map/flatMap).

Découvrez égalementGuide n8n IA pour maitriser les paramètres des LLM

Exemple. Deux requêtes paginées “Page1” et “Page2” produisent :

// Page1: items
[{ "id": 1 }, { "id": 2 }]
// Page2: items
[{ "id": 3 }]

Expression pour agréger tous les id :

{{ $("Page1").all().concat($("Page2").all()).flatMap(i => i.json || i.json?.items || [i.json]).map(x => x.id) }}

Sortie :

[1,2,3]

Astuce : renommez vos nœuds avec des noms stables et explicites. Vérifiez la correspondance d’item dans le panneau de mapping.

Comment écrire des expressions n8n sûres et robustes ? (aide)

Trois réflexes :

1. Existence : utilisez l’optional chaining ?. {{$json?.user?.email}}
2. Valeur par défaut : utilisez ?? si 0 ou "" sont des valeurs acceptables {{$json.count ?? 0}}
3. Normalisation des tableaux/chaînes {{ (Array.isArray($json.tags) ? $json.tags : [$json.tags]).filter(Boolean) }}

Découvrez également30 tactiques n8n pro indispensables en 2026

Anti-patrons fréquents : indexer [0] sans tester la longueur, confondre || et ??, mélanger Date natif et Luxon.

Comment manipuler des chaînes avec les expressions n8n ? (tuto, comment)

Slug robuste (accents, espaces, ponctuation) :

{{$json.title
  .normalize('NFD').replace(/[\u0300-\u036f]/g,'')
  .toLowerCase()
  .replace(/[^a-z0-9\s-]/g,'')
  .trim()
  .replace(/\s+/g,'-')
}}

Domaine d’email :

{{$json.email?.split("@")?.[1] ?? ""}}

Nettoyage HTML → texte :

{{$json.html.replace(/<[^>]*>/g,' ').replace(/\s+/g,' ').trim()}}

Troncature propre 140 caractères :

{{ ($json.text||"").replace(/\s+/g," ").trim().slice(0,140) + 
   (($json.text||"").length>140 ? "…" : "") }}

Comment travailler tableaux et objets en expressions n8n ? (guide)

Pensez pipeline : map → filter → reduce → sort → join.
Liste de noms :

{{$json.users.map(u => [u.first,u.last].filter(Boolean).join(" ")).join(", ")}}

Valeurs uniques :

{{[...new Set($json.tags || [])].join(",")}}

Somme sécurisée :

{{$json.items.reduce((s,x) => s + (Number(x.price) || 0), 0)}}

Rendu “clé: valeur” d’un objet :

{{Object.entries($json.config).map(([k,v]) => `${k}: ${v}`).join('\n')}}

Comment gérer les dates avec les expressions n8n et Luxon ? (tuto détaillé, comment)

Pourquoi Luxon ici ?

Dans les expressions, n8n expose Luxon via deux objets prêts à l’emploi :

• $now : date/heure du moment (Luxon DateTime)
• $today : minuit du jour (Luxon DateTime)

Bonnes pratiques :

• Rester full-Luxon dans une même expression.
• Définir la zone tôt (ex. “Europe/Paris”) avec setZone().
• Calculer en DateTime, formater seulement à la fin avec toISO() ou toFormat().

Recettes Luxon prêtes à l’emploi

ISO immédiat :

{{$now.toISO()}}

Demain 18:00 Europe/Paris :

{{$today.setZone("Europe/Paris").plus({days:1}).set({hour:18}).toISO()}}

Fin du mois (date ISO) :

{{$now.endOf("month").toISODate()}}

J+7 à 09:00 Europe/Paris :

{{$now.setZone("Europe/Paris").plus({days:7}).set({hour:9,minute:0}).toFormat("yyyy-LL-dd HH:mm")}}

Fenêtre semaine locale (lundi → dimanche) :

{{(() => {
  const zone = "Europe/Paris";
  const start = $today.setZone(zone).startOf("week").plus({days:1}); // lundi
  const end   = start.plus({days:6}).endOf("day");
  return { start: start.toISO(), end: end.toISO() };
})()}}

Test “timestamp appartient à la semaine courante” :

{{(() => {
  const zone = "Europe/Paris";
  const ts = $json.timestamp; // ISO
  if (!ts) return false;
  const nowZ  = $now.setZone(zone);
  const w0    = nowZ.startOf("week").plus({days:1}); // lundi
  const w1    = w0.plus({days:6}).endOf("day");
  const x     = DateTime.fromISO(ts).setZone(zone);
  return x >= w0 && x <= w1;
})()}}

Pièges fréquents, solutions claires

• Mélange Date natif et Luxon : restez sur Luxon dans l’expression.
• Faux fuseau : appliquez setZone() tôt, gardez-le jusqu’au formatage.
• Chaîne ambiguë : parsez explicitement (via DateTime.fromISO(...)) dans une IIFE si nécessaire.

Exercices (dates)

1. deadline_iso = demain 18:00 “Europe/Paris”.
2. Objet {start,end} pour le mois courant au format ISO local.
3. IIFE : parse YYYY-MM-DD depuis $json.date_simple, sortir ISO local à 09:00.

Comment requêter un JSON avec $jmespath() dans les expressions n8n ? (guide détaillé)

Pourquoi $jmespath() ?

JMESPath est un mini-langage déclaratif pour interroger un JSON. En une ligne, vous filtrez et projetez des structures profondes que JS natif exigerait d’écrire en plusieurs étapes.

Syntaxe utile (mémo)

• Propriété : a.b
• Projection tableau : items[].id
• Filtre : items[?status=='paid']
• Filtre + projection : items[?active==\true`].name`
• Projection d’objets : items[].{id:id,total:total}
• Chaînage avec pipes : possible, améliore la lisibilité
• Booléens littéraux : backticks `true`, `false`

Recettes JMESPath directement utilisables

IDs des commandes payées :

{{$jmespath($json,"orders[?status=='paid'].id")}}

Nom + score projetés, puis formatés côté JS :

{{$jmespath($json,"results[].{n:name,s:score}")
  .map(x => `${x.n}: ${x.s}`)
  .join("\n")
}}

Aplatir tous les tags sur l’ensemble des items entrants :

{{[...new Set($jmespath($input.all(),"[].json.tags[]"))]}}

Filtre multi-critères :

{{$jmespath($json,"results[?active==`true` && score>=`70`].name")}}

Sélection d’objets avec renommage de clés :

{{$jmespath($json,"users[?role=='admin'].{id:id,mail:email}")}}

Quand choisir JMESPath et quand rester en JS natif ?

• Choisissez JMESPath pour filtrer/projeter lisiblement des structures profondes.
• Revenez en JS natif pour des calculs/tri personnalisés ou des agrégations complexes après la projection.

Exercices (JMESPath)

1. users[?active==true].email puis tri alphabétique côté JS.
2. À partir de {name, metrics:{score}}, projetez [{n:name,s:metrics.score}], puis moyenne côté JS.
3. Gardez name des results où status=="ok" et score>=70, puis joignez par ", ".

Comment paramétrer des APIs avec les expressions n8n ? (tuto, support)

Travailler en objets JS et sérialiser à la fin rend tout plus stable.

Endpoint dynamique :

{{ `${$("CONFIG").first().json.baseUrl}/users/${$json.id}?q=${encodeURIComponent($json.q||"")}` }}

En-têtes optionnels (filtrer les champs vides) :

{{ Object.fromEntries(
     Object.entries($("CONFIG").first().json.headers)
           .filter(([k,v]) => v != null)
   )
}}

Payload JSON propre :

{{ JSON.stringify({
     id: $json.id,
     when: $now.toISO(),
     tags: ($json.tags || []).filter(Boolean)
   })
}}

Exercice. Reprenez un body écrit “en dur”, construisez l’objet en expression, supprimez les champs null/undefined avec Object.entries(...).filter(...), puis JSON.stringify(...).

Snippets réutilisables d’expressions n8n (support rapide)

• Nom complet :

{{[$json.first,$json.last].filter(Boolean).join(" ")}}

• Valeurs uniques :

{{[...new Set($json.tags || [])].join(",")}}

• Somme sécurisée :

{{$json.items.reduce((s,x) => s + (Number(x.price) || 0), 0)}}

• Top 1 par prix :

{{$json.products.sort((a,b)=>b.price-a.price)[0]}}

• CSV rapide :

{{(() => {
  const rows = $json.rows || [];
  const cols = ["id","name","email","created"];
  const header = cols.join(",");
  const body = rows.map(r => cols.map(c => {
    const v = r[c] ?? "";
    return `"${String(v).replace(/"/g,'""')}"`;
  }).join(",")).join("\n");
  return header + "\n" + body;
})()}}

Comment déboguer ses expressions n8n ? (aide)

Méthode simple :

1. Pin data sur le nœud source.
2. Remplacez l’expression par {{$json}} et regardez la réalité des champs.
3. Construisez l’expression étape par étape (ajoutez split, puis map, etc.).
4. Testez $jmespath() seul avant de le combiner.
5. Vérifiez l’orthographe exacte des nœuds dans $("NomExact") et les “linked items” dans le panneau de mapping.

Exercices pratiques sur les expressions n8n (tuto appliqué)

1. Extraire le domaine d’un email (split("@")[1]) avec fallback "".
2. Transformer un title bruité en title_slug robuste.
3. Construire full_name avec filter(Boolean).join(" ").
4. Calculer la somme de price en forçant Number() et défaut 0.
5. Générer un nom de fichier daté via $now.toFormat("yyyyLLdd_HHmm").
6. Produire deadline_iso demain 18:00 Europe/Paris.
7. Obtenir users[?active==true].email via $jmespath() puis trier .sort().
8. Comparer a ?? b et a || b avec a=0 et a="".
9. Écrire un body JSON propre avec Object.entries(...).filter(...) + JSON.stringify.
10. Écrire une “progress bar” 0–10 avec une IIFE courte.
11. Construire une URL avec plusieurs paramètres encodés et page par défaut.
12. Remplacer une expression à 4 conditions par une IIFE de 8–12 lignes commentées.
13. Projeter results[].{n:name,s:score} (JMESPath), puis mise en forme JS.
14. Aplatir tous les tags des items entrants et obtenir des uniques.
15. Générer une table “clé: valeur” depuis un objet config.
16. Fenêtre hebdo {start,end} en ISO local avec startOf/endOf.
17. Vérifier les “linked items” d’un Merge (panneau de mapping).
18. Uniformiser toutes les dates sortantes en ISO avant envoi API.
19. Remplacer une regex longue par 2–3 opérations simples si possible.
20. Créer un nœud Set | CONFIG et éliminer toutes les constantes magiques.

FAQ — expressions n8n