Hello and welcome to video number one of the advanced course for n8n. In this course, we will be covering everything you need to know to become an expert workflow builder.

In this video specifically, we'll talk about how data flows through n8n workflows. In the beginner course, we started to create short branches, so you might have wondered, if we have multiple branches, what order do the different nodes in those branches execute in?

So we're going to talk about node execution order.

For workflows created in version 1.0 and above, n8n will execute each branch in turn, completing one branch before starting another. Branches are ordered based on their position in the canvas, from topmost to bottommost.

If two branches are at the same height, it is the leftmost branch that will execute first.

In this workflow, you can see that the node execution order would be wait, then wait one, then wait two, and wait three, followed by wait four and wait five.

So we'll be going top to bottom, left to right. This can be changed on a workflow basis, however it is not recommended.

This will execute uh the first node of each branch, then the second node of each branch and so on and so forth. When building workflows where branches depend on each other's output, it is always recommended to merge branches together before using the data from those branches, instead of changing the node execution order.

As covered in the beginner course, we can use the if node to split data into multiple branches. The if node splits the input items down two distinct branches, whether the condition is true or false.

We already saw this in the beginner course. We won't be covering this uh in this video.

We can also use the switch node to create N branches and also assign a fallback branch, creating n total branches that split the items amongst them.

So here we have 10 items in the switch's input, and these are being split into one item, one item, one item, and seven items, totaling 10.

A similar effect can be produced by dragging two output branches from a single node. This will send all of the items from the node's output down each one of those branches.

Following the order of execution we mentioned previously, this can be useful when you want to execute two separate sets of distinct actions from a set target point.

The same way that we can split data into different branches, we can also merge data from different branches using the merge node.

The merge node is a peculiar node because it has not one, but two inputs. The node waits for data from both branches to arrive and then performs one of the following merge options: append, combine, choose.

Append will simply output the sum of both branches, appending them one to another.

Choose will let you, well, choose one, the other, or no items to pass. This can be useful to ensure that two or more branches have finished executing before continuing with the workflow.

And finally, combine lets you merge the inputs by field position or all combinations. A good mental model for the merge node is the SQL join operation.

Inner and outer joins are equivalent to keeping matches or not keeping matches. The left join is equivalent to enhancing or enriching the first input branch, and the right join enhancing the second input branch.

Unions are equivalent to aens in this case.

Another useful node when dealing with sets of items is the loop over items node. Sometimes when dealing with large amounts of data or when using certain nodes, we need to be able to treat items as individual sets of items.

In comes the split in batches node or loop over items. It allows you to split the input items into different batches of a given size.

For example, here the batch size is of one, and so there's only going to be one item going down the loop.

Most of the time you don't need this node and end nodes already execute once per item.

However, this can be a very useful node when dealing with certain types of nodes. Some nodes will return n items even though they have only one input item.

An example of this would be Google Sheets. If we are reading data from a sheet, we're going to be reading potentially n lines of data here.

If we need to read multiple sheets because we have multiple items, we can loop over the items to be able to read each sheet per item.

We'll cover this in the um examples. Loopover items can also be useful when dealing with API rate limits.

So sometimes APIs will, sometimes APIs will only allow us to make X actions over y amount of time. So for example, only 10 calls per minute or 100 calls every 10 seconds.

Loopover items can help us spread out those different API calls, especially if we have a lot of them to do.

By splitting into batches, we can use the weight node and make sure that we aren't overloading the API. You can access the different runs in the output panel here by clicking on run.

This will be useful for understanding what items are going through the different different runs and how they're being changed as you loop over the items.

The loop over items node, as well as all the other nodes that are in the loop you create, will have a green number next to the green check mark, indicating what number loop they're on.

You can also access the different output items in the same way as you did for the loop over.

items node itself where you can see for each different iteration of a loop what were the output items for the nodes in the loop so here we are in n8n and the uh first thing I'd like to show you is a quick example on the node execution order so here if we test this workflow and I'm using the weight node so we can sort of see it go through uh at a bit more visible rate here we'll have the first branch that will be executed in its entirety and then once we are finished with this Branch we'll move on to the second branch that will execute completely followed by the third branch that will execute completely so keep this in mind when building workflows uh branches will execute top to bottom and left to right so now we're going to be using uh this workflow to show two different ways of using the merge node so here we have a very simple workflow um that we pretty much covered in the beginner course we get a list of 10 contacts we use the if node to create two branches depending on if it's a personal email or a professional email and here we're going to be using the edit fields node to add a email type personal or email type professional so if we execute this workflow we see the split and what we might want to do here is now continue working on all of these contacts as a whole so using here the merge node I can add in and connect the two inputs and we can see here we have three items here seven items here and if I select the append it will combine all items of input one and all items of input two so here if I test this step we're back to 10 items and each item will now have a email type personal or email type professional because we had our top branch that was personal, we have all of our personals first and then all of our professionals.

Another way of using the merge node, uh, so what we're going to do is give ourselves, give ourselves a little bit of space is to, um, do what we call enrichment.

So what we could do here, let's just give ourselves a bit of space here.

I have another Google Sheet that we're going to read, and this Google Sheet contains information about the companies. So if I execute this, we're going to see we have information on the companies, their website, and their country.

So what we can do here is on the branch of professionals, so people who have an associated company, we can enrich these contacts with information from the companies here.

If we were to use a simple append, we would have different items for the contacts and for the companies.

So what we're going to do instead is we're going to combine the data.

Um, what we need to do here is figure out how can we, um, link the contacts to the companies. So I'm going to show you two ways.

The first way, and we could simply do it here, would be, uh, to add a key called domain here using the email. In a little bit of JavaScript, we could split the email at the @ sign and then take the first value.

So this is going to give us everything after the @ sign.

So if we test this step, for each contact we have the domain, and now each contact has a domain key, and each company also has a domain key that we can see here, website.

So here we can add a new merge node, and this time instead of appending, we're going to combine here.

We have the different inputs. We can see that we have the Google sheet inputs and the tag as professional to make it a little bit clearer here.

Let's rename this to get companies. And looking at the merge node, we can see that to merge by fields, we need to give the name of a field in input one and the name of a field in input two.

This is basically going to be our matching key.

So our two inputs are get companies input one and then this set, sorry, this edit Fields node, which is going to be input two that we can read up here, input one and input two.

From get companies, we want the website and from TAG as professional, we want the domain. Here we would like to, we can choose between keeping matches, keeping non-matches, or keeping everything.

In this case, uh, we're because we're doing an enrichment, what we're going to do is keep all of input two with data from input one added.

This is because we're working on a contact basis and we want to enrich all of the contacts that have professional emails with, um, company information.

So here, if I test this step, we can now see that Marcus Bennett from Quantum, we now have the information from the other sheet, uh, that was that contained information on their website and the country.

This is a great way that we can enrich, um, branches with extra information.

This can be a Google sheet, a database, an API call, and then we just merge the data depending on the field.

If we wanted to do an enrichment, uh, through, for example, API calls, where for each item we would do one HTTP request, we could merge not by Fields but by position and have a very similar result.

Just finishing off this workflow, I can pull this in here and now if we execute the workflow, we can see that we've created two distinct branches and this one we need to set it as execute once because we only need one time all of the companies and we can see that we have very similar to the first uh result when we just did the simple penda merge, 10 items here, a split, and an enrichment.

Oops, 10 items here, a split with an if, three appear here, seven down here that get enriched, and then we merge them back into 10.

And so here we have pretty much the same information as the sheets, but with a bunch more information that we added through these branches.

Thanks for listening to this first video of the n8n advanced course where we covered node execution order, splitting, and merging branches. In the next video, we'll take a deep dive into some more advanced n8n nodes.

n8n Advanced Course (1/8) - Working with complex data flows

n8n Advanced Course (1/8) - Working with complex data flows