Passing data along is not the same as deciding what to do with it

By now you can write {{ $json.amount }} and push a value from one node into the next. That is passing something along untouched. Almost every automation anyone actually runs has a fork in it: notify the manager only when the amount is over 1,000; email the thank-you note only to VIP customers; store the form only if the consent box was ticked; make critical alerts ring a phone while info only writes a log line.

Read the data, then pick a path. Programmers write that as if / else or switch / case. In n8n you write no code: you drop in an IF node or a Switch node and draw the downstream connections by hand. Data comes in, the node decides, and the item leaves through the top or the bottom (IF) or through a numbered output (Switch).

Splitting is only half of it. The other half arrives once you have built a few workflows: you split with IF and cannot work out how to join the paths back; you feed 500 items to an API that allows 5 a second and collect 429 Too Many Requests from the sixth onward; an API returns { total: 5, items: [...] }, which counts as 1 item, so the Slack node downstream sends once instead of five times; two APIs each return half a record and you need them stitched on the same customer_id. Those are the jobs of Merge, Loop Over Items, Split Out and Aggregate.

Two paths, or several

Both nodes decide, then route. Picking the wrong one breaks nothing, but the right one keeps the canvas readable.

flowchart LR
  subgraph SW["Switch · one field, several values"]
    direction LR
    S0["An item arrives"] --> S1{"read tier"}
    S1 -->|"gold"| S2["output 0"]
    S1 -->|"silver"| S3["output 1"]
    S1 -->|"bronze"| S4["output 2"]
    S1 -->|"nothing matched"| S5["fallback output"]
  end
  subgraph IFN["IF · one yes-or-no question"]
    direction LR
    I0["An item arrives"] --> I1{"amount over 1000"}
    I1 -->|"true"| I2["Notify the manager"]
    I1 -->|"false"| I3["Daily log"]
  end

An order over 1,000 goes one way, everything else the other

Assume your upstream node — a Webhook, Google Sheets, Airtable, whichever you have — hands the order down as JSON in this shape:

1. Step 1

   Add an IF node

   Click the + icon to the right of the upstream node, or press Tab on an empty spot, to open the nodes panel. Type if and click If, under the Flow category. It drops onto the canvas already connected upstream.

2. Step 2

   Set the first condition

   Double-click the node. A Conditions block appears with one empty comparison row, three fields left to right:

   Value 1Click the field to switch to Expression mode and write {{ $json.amount }}.

   OperatorPick the type Number on the left first, then is greater than on the right — the official name in the v2 IF node, not larger.

   Value 2Enter 1000. A plain number, no quotes.
3. Step 3

   Wire the two outputs that appear

   The node now shows true on top in green and false below in red. Drag from true into your “notify the manager” node — a Slack node posting to a manager channel — and from false into the “daily log” node, a Google Sheets Append Row for example.

4. Step 4

   Save, then test the true path

   Press Ctrl+S, then click Execute Workflow at the top right. The IF node marks the output it took with a green border. The amount is 1500, over 1000, so it should take true — and the Slack node should light up too.

5. Step 5

   Test the false path as well

   Change the upstream mock data to amount: 800 and run again. Only the Google Sheets path should light up. An IF is only verified once you have tested both sides.

Four data types, and the mistake everyone makes once

The Operator dropdown has two levels: pick the data type on the left, and the comparisons for that type appear on the right. Get the type wrong and the condition reads perfectly but comes out false every run.

Two more come up less often: Array (contains, length equal to, length greater than) and Object (only exists, does not exist, is empty, is not empty). Note that Date & Time has no is between — to test “between two times” write two conditions, is after A and is before B, combined with AND.

Combining conditions with AND and OR

Add a second condition row and an AND / OR dropdown appears between the two. The interface calls it exactly that; there is no Combinator label to hunt for. AND is worded “Keep data when it meets all conditions”. OR is worded “Keep data when it meets any of the conditions”.

Rules mode, Expression mode, and what happens to the leftovers

Open a Switch node and the first thing it asks is Mode: Rules or Expression. Rules works like a stack of IF nodes — every rule has its own condition, using the operator system you just learned, and an item leaves through the output belonging to whichever rule matched. Click Add Routing Rule and you get one more output. Three customer tiers, with { "tier": "gold", ... } arriving from upstream:

Below the rules sits Fallback Output, with three official options: None (the default — an unmatched item is dropped), Extra Output (one more output catching unmatched items, the common choice) and Output 0 (unmatched items leave with the first rule's). When you want an “unclassified” path, pick Extra Output.

flowchart TD
  A["One item enters the Switch"] --> B{"Rule 0 matches?"}
  B -->|"yes"| B1["Leaves through output 0.
The rules below are skipped"]
  B -->|"no"| C{"Rule 1 matches?"}
  C -->|"yes"| C1["Leaves through output 1"]
  C -->|"no"| D{"Rule 2 matches?"}
  D -->|"yes"| D1["Leaves through output 2"]
  D -->|"no"| E{"Fallback Output setting"}
  E -->|"None, the default"| E1["The item is dropped.
Nothing errors"]
  E -->|"Extra Output"| E2["Leaves through
the extra output"]
  E -->|"Output 0"| E3["Leaves with the
first rule's items"]

A Send data to all matching outputs toggle sits under Options, off by default; with it on, an item matching two rules is sent down both, so items get duplicated across branches. Because of the top-to-bottom order, put the strictest rule at the top. To stop caring about order entirely, write rules that exclude each other: amount >= 100 AND amount < 1000, then amount >= 1000 AND amount < 5000, then amount >= 5000 — each range built from two conditions plus AND, since Number has no is between.

Expression mode instead takes one expression returning the output number, counting from 0. The same three tiers:

Read it as a lookup table, and set Number of Outputs first — 3 here — so the node has that many lines to connect. Neither mode is the advanced one: Rules is friendlier because you read the logic off the canvas, Expression saves setup time when there are many categories and the mapping is one-to-one. Both give the same result.

Four modes, and three more choices inside one of them

The Merge node always needs two inputs — you see two connector dots when you draw a connection to it. Its Mode dropdown has four options. This is the structure n8n moved to after 2024, and it is not the “three modes” older tutorials describe.

Under Combine sit three strategies. Matching Fields pairs items on a key value, the same as a SQL JOIN — customer data on id against order data on customer_id. Position aligns by position in the array, so [{a:1},{a:2},{a:3}] plus [{b:x},{b:y},{b:z}] gives [{a:1,b:x},{a:2,b:y},{a:3,b:z}]. All Possible Combinations is the Cartesian product: 3 items and 2 items give 6.

With Matching Fields selected, Output Type decides the kind of join, and all five are there. Keep Matches outputs only items matched on both sides, an inner join. Keep Non-Matches outputs only the unmatched, which is how you answer “which customers have never ordered”. Keep Everything keeps both sides and fills unmatched fields with null, a full outer join. Enrich Input 1 lets Input 1 lead and pastes on the matching fields from Input 2, a left join; Enrich Input 2 is the mirror image.

One behavior catches almost everybody once. A Merge node only runs when data has arrived at both inputs. Rejoining after an IF split, if one path is meant to do nothing, wire a No Operation, do nothing node into Merge anyway — or Merge waits forever, quietly, with no error to explain itself.

flowchart TD
  A["Upstream node"] --> B{"IF"}
  B -->|"true"| C["Edit Fields (Set) A"]
  B -->|"false"| N["No Operation,
do nothing"]
  C --> M["Merge
Mode = Append"]
  N --> M
  M --> S["Slack, written once"]

Two last details. Ordering has a rule per mode: Append gives all of Input 1 then all of Input 2, Position keeps the same index aligned, and Matching Fields orders by the order the keys appear in Input 1 — put a Sort node before or after the Merge if you need a particular order. And the node has connectors for two inputs only: to merge three or more, chain two Merge nodes, A and B into the first, its output plus C into the second.

Batching, flattening and rolling back up

The Airtable API allows at most 5 requests a second and your sheet has 500 rows to write. Wire it straight through and after the fifth item you start collecting 429s, with the remaining 495 failing. Loop Over Items is the fix, and its unusual part is that the node forms the loop itself: the nodes on the loop side have to draw a connection back to it, and that back-connection is what makes it a loop.

flowchart TD
  A["Google Sheets
500 items"] --> B["Loop Over Items
Batch Size = 5"]
  B -->|"loop"| C["Airtable Create"]
  C --> D["Wait, 1 second"]
  D -->|"the connection back is
what makes this a loop"| B
  B -->|"done, taken once
everything has run"| E["Slack: 500 records processed"]

Batch Size sets how many items each round sends to the loop output: 5 for Airtable, 10–50 for a typical API. Options → Reset decides whether the counter resets when new items arrive — leave it off for a one-shot workflow, turn it on only when the workflow is called continuously. The done output is taken once, after everything has run, and feeds an “all finished” notification.

Split Out and Aggregate

A Gmail message whose payload holds an attachments array with five attachments is 1 item, and an upload node downstream would run once. Split Out is what turns a JSON array into n8n items — the answer to the point made earlier in this series, that n8n items and a JSON field called items are two different things. Fields To Split Out names the field holding the array, comma-separated for several. Include chooses whether each item that comes out carries the original's other fields, such as the mail subject: No Other Fields / All Other Fields / Selected Other Fields. Under Options, Destination Field Name names the key each payload sits under, or flattens it when left empty, and Disable Dot Notation (off by default) is for field names that themselves contain a ..

Aggregate is the opposite: five processed items collapsed into one summary. Individual Fields aggregates only the fields you name, with Rename Field and Merge Lists to flatten nested arrays. All Item Data (Into a Single List) packs every item's whole json into one array, with Include and Exclude lists.

Worked example: one Slack reminder per Google Sheet row

Start with the case that needs none of this section's nodes, because it shows you what “already many items” looks like. A Google Sheets read turns every row into an item on its own, so the work is done before you get there.

1. Step 1

   Add a Manual Trigger

   Create a workflow and pick Trigger manually as the first node. Pressing Execute Workflow then runs it once, on demand.

2. Step 2

   Add a Google Sheets node

   Wire on a Google Sheets node and set Operation to Get Rows in Sheet. Connect the credentials — Part 10 of this series covers that — then pick your spreadsheet and sheet. Say the spreadsheet is called “Customer list”, has 10 rows, and its fields are name, email and due_date.

3. Step 3

   Execute step and confirm 10 items arrive

   Press Execute step on the Google Sheets node. The top of the output panel on the right shows 10 items — check the count is right before you go on. Switch to the Table view to read each row.

4. Step 4

   Add a Slack node

   Wire on a Slack node, set Operation to Send Message and pick a channel — #billing-reminder, for example. Switch the Text field to Expression mode and enter:

   Statement reminder for {{ $json.name }}. Due {{ $json.due_date }} — please take care of it.
5. Step 5

   Execute the whole workflow once

   Press Execute Workflow at the top right. The Slack node's output panel shows 10 items — 10 messages sent, one per row. Open the channel and confirm 10 actually arrived.

6. Step 6

   Save it

   Save at the top right. From then on, pressing Execute Workflow sends another round. To send it automatically on the 1st of each month, swap the Manual Trigger for a Schedule Trigger, which Part 7 of this series covers.

Worked example: split the array an API returns and act on each entry

Try it end to end. Add a Manual trigger, then an HTTP Request node with Method GET and URL https://jsonplaceholder.typicode.com/users. Press Execute step and read the top of the output panel: 1 item, not 10, because the whole response is one array. Wire on a Split Out node and put the path of that array in Fields To Split Out — if HTTP Request puts it in data or at the root, use the path that matches, read off the output panel. Execute step again and the panel shows 10 items. A Slack node with Send Message and Text set to Welcome {{ $json.name }} ({{ $json.email }}) now sends 10 messages instead of one.

To roll it back up, add an Aggregate node with Aggregate set to Individual Fields and Field To Aggregate set to name, renamed to names. The output is back to 1 item holding an array of 10 names, and a Gmail node can send Processed these 10 users today: {{ $json.names.join(', ') }} — one summary instead of ten alerts.

Four combinations you will reach for most weeks

Knowing one node is only the start. Almost every real workflow is two or three of them standing next to each other.

A branch that will not fire, goes the wrong way, or refuses to split

Almost all of it comes down to four questions, asked in this order.

flowchart TD
  A["A branch did not do
what you expected"] --> B{"Did any item reach
the IF or Switch node?"}
  B -->|"no"| B1["The problem is upstream.
Read the item count on
the node before it"]
  B -->|"yes"| C{"Do the output counts add up
to the number that went in?"}
  C -->|"no"| C1["Items were dropped.
On a Switch that is
Fallback Output left on None"]
  C -->|"yes"| D{"Is the value a string
where you picked Number?"}
  D -->|"yes"| D1["Wrap Value 1 in Number,
or convert it upstream
with a Set node"]
  D -->|"no"| E{"Is a Merge node
downstream sitting idle?"}
  E -->|"yes"| E1["One input never received data.
Wire No Operation, do nothing
onto the empty branch"]
  E -->|"no"| F["Read the condition
row by row. Case and
whitespace count"]

Questions people ask next

Where to go from here