n8n Expressions are the secret sauce for creating truly dynamic and adaptable automations within the n8n platform. Essentially, they are special placeholders, wrapped in double curly braces like {{ expression }}, that you can insert into almost any node parameter field. Instead of using static, fixed values, expressions allow you to dynamically pull in data from previous nodes, access workflow information like execution IDs, use built-in helper variables (like the current date/time), and even run simple JavaScript snippets to manipulate data on the fly. Mastering expressions is key to moving beyond basic workflows and building sophisticated automations that react intelligently to changing inputs and conditions.
What Exactly Are n8n Expressions?
Alright, let’s dive in. Think of n8n expressions like a super-powered version of mail merge or maybe even those fun Mad Libs games. You have a template (your node’s settings), and you need to fill in the blanks with specific information that might change every time the workflow runs.
Instead of manually typing “Hello John,” every time, you could use an expression like Hello {{ $json.customerName }}. When the workflow runs, n8n looks at the data coming into the node (often represented by the $json variable), finds the value associated with customerName, and poof – it dynamically inserts the correct name. So, one time it might output “Hello John,” and the next time, using the exact same node configuration, it could output “Hello Sarah,” all based on the incoming data.
This dynamic capability is what makes expressions so fundamental. They allow your workflows to be flexible, reusable, and much, much smarter.
Why Should You Care About Expressions?
Good question! Why add this layer of complexity? Well, the benefits are pretty huge:
- Flexibility: Your workflows can adapt to different inputs without needing constant manual changes. Got data from a form submission? Use expressions to route it, personalize a response, and save it—all based on the actual submitted data.
- Reduced Hardcoding: Avoid scattering fixed values (like email addresses, API keys, or specific IDs) throughout your workflow. Expressions let you centralize or dynamically fetch this information.
- Personalization: Easily tailor emails, messages, or reports using data specific to the recipient or context (like using a customer’s name or order details).
- Complex Logic (Simplified): Perform calculations, format dates, or conditionally set parameters directly within a node’s field, often saving you from adding extra
Codenodes for simple tasks.
Honestly, once you get the hang of them, you’ll wonder how you ever built workflows without them.
Getting Started: Writing Your First Expressions
Ready to try it out? It’s easier than you might think.
The Magic Braces: {{ }}
The absolute core syntax is the double curly braces: {{ }}. Anything you put inside these braces is treated as an expression by n8n. If you just type text into a field, it’s static. Wrap it in {{ }}, and it becomes dynamic.
The Expression Editor: Your Best Friend
While you can type expressions directly into fields, n8n offers a fantastic Expression Editor. You access it by clicking the little ‘f=’ or ‘fx’ icon next to a parameter field (or toggling from ‘Fixed’ to ‘Expression’).
Why use it?
- Variable Selector: It shows you all the data available from previous nodes, neatly organized. You can click on a data point, and n8n automatically inserts the correct expression syntax to access it. This is a massive time-saver and helps prevent typos!
- Syntax Highlighting: Makes reading and writing JavaScript within expressions easier.
- Preview: Often, it shows you a preview of what the expression will output based on the current test data. (Super helpful for debugging!)
Trust me on this, get comfortable with the Expression Editor. It significantly speeds up development and reduces errors.
Accessing Data: The Basics
The most common thing you’ll do is access data from previous nodes. Here’s the lowdown:
$json: This special variable usually refers to the JSON data of the current item being processed by the node. If your trigger node received{ "name": "Bob", "city": "London" }, then in the next node,{{ $json.name }}would likely evaluate to “Bob”.$node["Node Name"].json: To get data from a specific previous node, you use this structure. Replace"Node Name"with the exact name of the node you want data from (case-sensitive!). For example, if you have a node named “Get User Data” that outputs{ "userId": 123 }, you could access that ID in a later node with{{ $node["Get User Data"].json.userId }}.- Handling Multiple Items: n8n processes data in items (like rows in a spreadsheet). If a node outputs multiple items, expressions typically run once for each item, using that item’s
$jsondata. Things can get more complex with merging and looping, but$jsonis your starting point for the current item’s data.
Let’s look at a simple example: A Webhook node named “Lead Capture” receives {"name": "Alice", "email": "alice@example.com"}. In a subsequent Send Email node, you could set the recipient address using the expression {{ $node["Lead Capture"].json.email }} and personalize the body with Hello {{ $node["Lead Capture"].json.name }}, thanks for signing up!.
Real-World Magic: Expressions in Action
Okay, theory is great, but let’s see a practical use case. Imagine you manage marketing campaigns and store email templates in a Google Sheet or even a simple text file in GitHub. You don’t want to hardcode these templates directly into your n8n workflow because they might change frequently.
Here’s how expressions save the day:
-
Fetch Template: Use an HTTP Request node (or GitHub node) to fetch the raw text of your template file. Let’s say the template is:
Hi {{ customer_name }}, thanks for your order {{ order_id }}! Your total is {{ order_total }}. -
Get Customer Data: Use a database node (like Postgres or MySQL) or CRM node (like HubSpot) to retrieve customer and order details based on some trigger (e.g., a new order webhook). This node might output data like:
{ "name": "Bob Smith", "orderNum": "ORD-987", "total": "$49.99" }. Let’s call this node “Get Order Details”. -
Use Expressions to Populate: Now, in a ‘Set’ node (or directly in a Send Email node), you can construct the final email body. You’d likely use the output from the template fetch node and the customer data node. It gets a bit trickier here because you’re essentially applying expressions within fetched text, which often requires a Code node for proper templating.
However, a simpler related scenario is setting node parameters dynamically. Imagine needing to set the ‘Subject’ of an email dynamically. In your Send Email node’s Subject field, you could write:
Order Confirmation for {{ $node["Get Order Details"].json.name }} - Order #{{ $node["Get Order Details"].json.orderNum }}
This expression pulls the customer’s name and order number directly from the “Get Order Details” node’s output and inserts them into the subject line. No hardcoding needed! Every email sent will have a personalized subject based on the specific order data processed.
Beyond the Basics: Tips and Tricks
Expressions can do more than just fetch data.
Simple JavaScript Inside Expressions
You can embed single-line JavaScript operations within expressions. This is powerful for quick data transformations.
- Calculations:
{{ $json.price * $json.quantity }} - String Manipulation:
{{ $json.firstName.toUpperCase() + ' ' + $json.lastName.toUpperCase() }} - Date Formatting (using built-in Luxon library):
{{ DateTime.now().toFormat('yyyy-MM-dd') }}(Gets today’s date) - Conditional Logic (Ternary Operator):
{{ $json.priority === 'High' ? 'URGENT:' : '' }} Subject Text(Adds “URGENT:” if priority is high).
Important Limitation: Expressions are designed for single return values. You can’t declare variables (let x = 5;) or perform multiple distinct operations within a single expression block like you would in a full script.
Handling Complex Logic (When Expressions Aren’t Enough)
What if you need to do something more involved? Like looping through some data, making multiple calculations, or complex conditional checks before setting a value? That’s where the Code node shines.
Think of it this way:
- Expressions: Great for simple data retrieval, basic transformations, and conditional output based on single-line logic. Use them directly in node parameters.
- Code Node: Your go-to for multi-step logic, variable assignments, loops, more complex data restructuring, or interacting with the full n8n node API within your code. The Code node outputs data that you can then access via expressions in subsequent nodes.
They work beautifully together! Use expressions for the simple stuff, and pull out the Code node when things get hairy.
Leveraging Built-in Variables and Functions
n8n provides handy built-in variables beyond $json and $node:
$now: A Luxon DateTime object representing the current date and time. ({{ $now.toISO() }})$today: Similar to$nowbut set to the start of the current day.$workflow.id,$workflow.name: Access metadata about the workflow itself.$execution.id: Get the unique ID for the current workflow run.- JMESPath: n8n also supports JMESPath for querying JSON structures, which can be very powerful for filtering and reshaping data within an expression.
{{ $json.users[?age >30].name }}(Gets names of users older than 30).
There are many more! Explore the ‘Variables’ tab in the Expression Editor to see what’s available.
Common Gotchas and How to Avoid Them
Even seasoned pros hit snags with expressions sometimes. Here are common culprits:
- Typos: Node names and property names (
$json.emialinstead of$json.email) are case-sensitive! Double-check spelling. Use the Expression Editor’s variable selector! - Incorrect Data Path: Trying to access data that doesn’t exist or is nested differently than you expect (e.g.,
{{ $json.data.name }}when the structure is actually{{ $json.name }}). Always check the output of the previous node in the UI to confirm the exact structure. - Undefined/Null Values: Accessing a property that might not always be present can cause errors. You might need conditional logic or default values:
{{ $json.optionalField || 'Default Value' }}. - JSON vs. Array: Misunderstanding whether
$jsonrefers to a single object{}or an item within an array[]. This affects how you access data, especially when dealing with multiple items.
The Fix? Test frequently! Run individual nodes, inspect their output data in the n8n editor, and use the Expression Editor’s preview. Debugging becomes much easier when you isolate the problem.
Expressions are a cornerstone of effective n8n automation. They bridge the gap between static instructions and dynamic, data-driven actions. By mastering how to access data, use the editor, sprinkle in some JavaScript, and understand their limitations (and when to use a Code node instead), you’ll unlock a whole new level of power and flexibility in your workflows. So go ahead, experiment, and make your automations truly dynamic!
