Hello and welcome to video number four of the beginner course of n8n. Um, in this video, we'll be covering what kinds of data nodes use and how the data is passed from node to node.

This video is going to be a bit of a longer one, um, and we'll cover some more technical concepts, but it is very important that you understand these concepts, um, so that you can build the best workflows possible.

Let's start by explaining some core data concepts that you need to understand to make the most out of n8n.

There are two main data structures that we are going to take a look at today. The first one is what we call a JSON, and the second one is a list.

JSONs are a very common way of storing data digitally and are written between braces or curly brackets.

They are made up of key-value pairs, um, each one being separated by a comma. Lists are nothing more than a collection of objects. Um, they can be of the same or different type, written between brackets or square braces, um, also separated by commas.

A JSON can be embedded. What we mean by this is sometimes we will have a JSON where the value of a key is equal to another JSON.

We can use this to organize complex data. In this example, we can use an embedded JSON to group all the information about Emily's location into a location key.

This key contains itself, a, sorry, the value of this key is a JSON that has two keys with information on Emily's country and city.

To access the data in a JSON, we can use the standard dot notation. Here, dot JSON lets us access the JSON itself, and by typing first_name, we can access the value of the first_name key.

For embedded JSON, we can use multiple dot notations in a row. Here, to get the location, we can write dollar json.

location.country Dollar Json. location being itself a Json on which we use the dot notation to get the value of its key.

Country lists are, uh, simply a collection of objects. Uh, we can have a mix of letters and numbers. Uh, we could have a list of any type of objects and, as you can see here, written between square brackets and separated by commas.

And because Json themselves are objects, we can obviously make a list of Json.

Here we have the example Json from earlier, separated by a comma, and then two more Json that form, well, a list of Json.

As we can see here, we have the square brackets at the top, our first Json, a comma, our second Json, comma, our third Json, and then finally our last, uh, brace.

There is a very interesting correspondence between Json and tables, where we can tell that one Json is equivalent to one row with the keys being the headers of those rows.

This might remind you a little bit of the Json and table view that we saw in the previous video on ENT nodes.

Um, when we have a list of Json, we can see that Emily here, first name Emily, last name Johnson, email, and her email fits very well into the row format where we have the different keys that are the different Columns of our table.

So we can imagine that if we have a list of three Json, then we have an equivalent table with three different rows, each one with the values of the corresponding row.

Here in red, we have an example of an item. We have the first item of the list, and node nodes use items plural as inputs and as outputs.

These are the only accepted formats for node inputs and node outputs. Even should we decide to return nothing, no information, we still have to return a list with an empty JSON that would be considered the empty output for an n8n node.

So now let's look into how nodes actually use these items when we're going to be executing them and building workflows.

Each node executes one per item in the input data. So there are some exceptions, uh, that we will be covering in the advanced course, but in general, you can remember that each node executes once per item.

For example, here we are using the date and time node to format different dates.

The node will read each item, format the date, and then return it as an individual item.

This is how we build workflows by transitioning items through different nodes. So here, if we look into this screenshot here, we have a list of items, each with different dates.

And here, as the output, we have again three items because it was executed once per item, and then we have the formatted date, which is the same associated date but in a different format.

In the advanced, sorry, in the parameters of, um, the node, we can access the additional settings through the gear icon, and here we can decide to execute only once where a node will execute only for the first item of its input.

To better understand how, uh, workflows actually work, um, here we have an execution schema of a very simple workflow. The workflow starts when clicking execute workflow reads data from a Google Sheet and then filters the items depending on specific conditions.

The execute workflow node launches and returns an empty JSON, so no data at all.

All and here we can see we have our empty JSON in a list. This is returned so that the next node can execute once because we have one item.

The Google Sheets node then executes once and reads three items in the Google sheet that it's reading from, and so it returns three items. JSON one JSON 2 and JSON 3 each um being linked to the corresponding row in the Google Sheet, so we can see it outputs three items.

The filter node checks if each item satisfies a specific filter condition. Here we can see that only one of the items does, and so it only outputs one item.

When building workflows, the whole point is to configure a node to execute depending on what's in the input data. We can do this by dragging the key from the table, JSON, or schema view.

This will create what we call an expression. Expressions will, for each item, return the associated value to that key.

The n8n interface will show you an example value from the first item. So using the same uh data as before, in the schema view, we can drag the first name key into the filter conditions, and I can say I only want to allow through the filter if the first name is equal to something, for example, Emily.

Here we have the expression editor, and we have an example result for item one. So here, json.first name of item one is equal to Emily.

Remember, nodes execute once per item, and so as it executes for each item, the expression would have the value associated to that key.

Everything between two braces or curly brackets is an expression. So we can use expressions for many different use cases. We can use item variables as we saw before, so dollar json.

first name, json.last name, or email. We can also use JavaScript, so if we want to apply a JavaScript function or a JavaScript method to, for example, one of the items values, then we can use any of the built-in JavaScript functions or methods between the curly braces.

We can also in expressions combine one or multiple expressions, as well as plain text. So here we have uh using the Slack node, we have an example where we want to send for each item the first name, space, last name, and then between parentheses the email, followed by a short message that will be the same for every person just signed up to Acme.

Here we have an example of what the message would look like for the first item.

We can see that if we execute this node and we have three input items, we will get one message that is going to be different for each item in the input.

Jumping back into n8n, we can cover how to use these expressions and look at it together in the tool.

So here we have the workflow that we built in our last video, a manual execution followed by reading some data in a Google sheet, and I'm just going to click test workflow.

So we have the data already executed here. Again, using the plus up here or the little plus at the end of the node, we can add a new node.

This time we're going to use the edit Fields node that we'll cover more in detail in the next video, but just to show you a little bit how we can use Expressions, we'll leave the node configured as it is by default, and just add a new field that we're going to call full name.

So obviously full name is going to be first name followed by last name, so I can just drag the first name, drag the last name, and if I click test step, we're going to see that each item is going to have now a full name field with their first name followed by their last name.

Here in the JSON view, we'll see it a bit better.

Paul Harris, Paul Harris, Marcus Bennett, Marcus Bennett. In the expressions here, as mentioned in the slides.

We can see an example of what the result would be for the first item. So Paul Harris, what we see here, and in the expression, we can also add a little bit of JavaScript.

For example, I could want the last name to be two uppercase. Um, so this would make the first name as is in the input data and the last name would be turned into uppercase.

So here, if I execute this, um, if I test this step, we can see that now we not only have the full name, but we have the full name with the last name that is uppercase.

Thanks for listening to the fourth video of the n8n beginner course, where we covered the key data concepts of n8n.

In our next video, we'll be using everything we learned in these videos to finally start building our first workflows.

If you are working on a workflow and have a hard time understanding why your input and output data are the way they are, feel free to come back to this video and make sure you have a thorough understanding of both items and lists and JSON, as these are key concepts to understand when building workflows and using expressions.

n8n Beginner Course (4/9) - How does n8n handle data?

Scripts