Hey and welcome to video number two of the advanced course for n8n. In this video, we'll be covering some of the more advanced n8n nodes and how to use them In the beginner course, we covered expressions.

Expressions are how we access data from items in a node. Expressions are just little bits of JavaScript that we write between curly brackets.

You can easily get the expression associated to a certain item by using the drag and drop feature, as you can see here.

We're just dragging the invitations sent into the field in which we want the expression. This will automatically create the expression to get that item.

You can, of course, also write your own expressions between curly brackets. The simplest use case for this is basic arithmetics, for example, subtracting the value of one item from another, addition, multiplication, etc., etc. But within those curly brackets, you can write any JavaScript.

Within expressions, you can access previous node data, but also use data transformation functions that are native to n8n.

There are functions to deal with numbers, dates, strings, and much more. In this example, we're using the extract domain function to get the domain from an email address.

So maxim@acme.com, the domain is acme.com.

Here are some useful examples of inbuilt functions. We have the is empty that returns a a bullet here are some useful of here Here are some examples of useful built-in functions.

We have is empty that checks if an object has key value pairs. We have has field, which checks if the object has a given field.

We can also remove duplicates, check the difference between two arrays, or as we saw previously, extract a domain from a string.

You can find the whole list of data transformation functions at the URL below in the n8n documentation when dealing with dates.

and times you can use the Luxon library within your expressions. It's a JavaScript library that makes it a lot easier to work with dates and times.

For example, you can use the dollar now expression to access the current date of time and and in your workflows, the dollar now will return the current date and time.

Even when building automations, you can create date objects with functions like from format and then turn them back into strings with two string or two local string and it then nodes pass date objects as strings between them.

So you need to be careful to be converting these strings back into date object if you want to be making um transformations on them with the Luxon library.

Dollar now returns an object with the current date and time. Dollar now to string makes it a little bit more readable with a string format. Today gives the date of today with a timestamp at midnight, etc., etc. Now that you have a better handle on expressions, we can take a deeper look into the code node.

The code node lets you extend the flexibility of n8n much further than its native nodes, allowing you to execute a script or piece of code on your input items.

The code node allows you to write JavaScript or Python that we will be executed on the input items and return them as output items, or you can generate a whole new set of output items.

With the code node, you must ensure that you are returning a new set of items or the node will return an error.

This means you must return a list or array of JSON objects.

If you want a code node to return nothing, you can simply return a list with one empty JSON object as you see below. We just return square brackets.

And then inside curly brackets, the code node can be useful for replacing switch nodes or performing calculations across items, sums, averages, distributions, etc. etc. When using the code node, we would want to access items from the previous nodes.

This works in pretty much the same way as expressions.

We have built-in variables. Dollar input. All will return all the input items from the current node. This will be very useful when iterating over all of the input items.

Dollar JSON works the same way as in expressions, allowing you to access the current item. The code node is reading now as selecting the language, Python or JavaScript.

The code node has two different modes that it can use. You can either decide to run once for all items, in which case your code will have to output one or multiple items in a list format, so a list or array of JSON objects, or you can decide to run once for each item, in which case the code node will be executed once for each item individually, and you will have to return no longer a list of JSON objects, but a JSON object, a singular JSON object.

Which one to choose? It really depends on what you're trying to accomplish.

For example, do you want to find all of the duplicates? Run once for all items is probably easier. The next node we're going to look at is the HTTP node.

We often describe it as Postman in a node. As its name indicates, this node lets you make HTTP requests or in other words, lets you use APIs.

The HTTP node has settings for every different part of the HTTP request, header, body, query parameters, URL, etc. etc. These will all be found in the main node settings.

The advanced settings of the HTTP node allow you to deal with pagination, timeouts, and other common use cases. For example, if you're calling an API that gives you the URL of the next page in the response.

You can configure it in the pagination settings to make the HTTP node deal with pagination without having to create a loop.

This will save you a ton of time when building API requests. The HTTP node also lets you use credentials from other nodes, so you don't have to figure out how to authenticate the services.

This is often one of the most tedious parts of using an API.

You can just select the credential from the list of predefined credentials and use the HTTP node as you would for any other API.

This makes extending the access to services that already have native nodes a lot easier. Another cool feature of this node is the import curl or cURL.

A lot of API documentations will give you the cURL for a request and you can simply paste this into the node and the node will configure itself.

You can also ask Chat GPT or other generative AI tools to generate the cURL for you and save a ton of time setting up the node.

We'll look at an example of this later. Let's look at how the code node works in practice. Uh, here I'm just going to drag the code node into a workflow and we're going to see that we have the two different modes, so we have one, once for all items and run once for each item.

When you add the code node, we're going to have by default some code here.

This code just creates uh a new key in the input data called my field and set uh to a value of one. Um, so here we can see that if we're running once for all items, it loops over all of the input and for each item is going to add the field.

So if I had 10 fields here, it would add my new field equal to one to every item. If I switch it over to run once for each item, um, this time the code is going to look a little bit different.

We don't need to iterate over every input value, and therefore, we can just set input item json.

myNewField to 1 and return the item. This has the same output. If now we, you know, drag in some test data here, here I just have a Google sheet with some um information on client orders, we can run through an example of how to use the code node.

Here I have in my JSON uh a bunch of different orders, uh order value, order count, total order value, and what I'd like to figure out here is what is the total of the total order value.

So for every item, I want to sum the total order value and get the result. So what we're going to do here, we're going to keep the loop.

First, we're going to create a variable called total, set it to zero. We're still going to loop over every item, except this time we're going to say total plus equals item.

json.total order value. Then uh here, if I execute this, it won't do anything useful because I need to return the total here.

Because we are in the run once for all items mode, I need to return a JSON object.

So here I can simply return total and return my variable total here. This will return one item that shows the sum total of everything.

Let's say here I was coding and I had made a little mistake and I had forgotten my plus. Uh here this obviously would have been the wrong value.

It's clear that this value is 55,000, the total cannot be 23,000. What we can do here is use the um console because everything that happens in n8n is Javascript, we can use the console to sort of figure out what's happening.

So here, clearly, I have a problem somewhere in my loop.

So I could console.log the value of total and see if it's evolving over time. When I test the step, I'm going to see the different values here.

It would be quite easy to recognize 55,000, 83,000. These are simply the values of total order value.

Looking back through my code, I can see we're missing a little plus. If I run it again, this time we'll see the value that keep going up.

Now going uh into another example for run once for each item, I could um let's reset the code node.

I could say I could be interested in uh because we have the total order value and the order count, I could get for example, the um average order value for every person.

Um in this case, because all of the data is within the individual item, it's just a lot easier to write um some code for run once for each item.

In this case, I could get the input.item.json. This time I want the total order value and I want to divide it by the order count.

So here I can put there um average value equals, delete this line, delete this line, and then set the new field and then just return the full item.

Here if I execute, I can see that uh was returned 6,000, 9,000, 2,200.

Uh these seem to be the um values for total order value divided by order count. So that's for the code node. Um as mentioned in the slides, you can use expressions, variables, anything that you can use in expression, you can use in the code node um as well as all of the built-in functions that are going to help you save a lot of time.

Now I'm going to show you how you can use the import curl to easily set up your HTTP node when an API reference has a curl example.

So here I'm just going to import a new HTTP node and here I have an A documentation for a search on People Data Labs, and I'm just going to copy this uh curl from here.

Here I can import it. Uh, just paste the data. Um, obviously here the API key uh is given as a header, but I have a uh predefined header or directly here and uh because I'm going to be using uh the generic credential type, I don't need to be sending headers.

But as you can see here, um importing the curl is going to import all of these different fields already formatted correctly into your HTTP request.

Um and now we can just uh execute. I'm just going to set the size to one to use a few less credits and now I can just test the step.

Um, the HTTP uh request went uh as planned. Uh, I returned one location, Mexico, help phone numbers, and it returned a single person, so everything went as expected.

Thanks for listening to the second video of the n8n advanced course where we covered expressions, the code node, and the HTTP node.

In the next video, we'll be covering pinning data and editing outputs.

n8n Advanced Course (2/8) - Advanced technical nodes

Scripts