Build a programmatic-style node#
This tutorial walks through building a programmatic-style node. Before you begin, make sure this is the node style you need. Refer to Choose your node building approach for more information.
You need the following installed on your development machine:
- Node.js and npm. Minimum version Node 16. You can find instructions on how to install both using nvm (Node Version Manager) for Linux, Mac, and WSL here. For Windows users, refer to Microsoft's guide to Install NodeJS on Windows.
You need some understanding of:
- REST APIs
- Expressions in n8n
Build your node#
In this section, you'll clone n8n's node starter repository, and build a node that integrates the SendGrid. You'll create a node that implements one piece of SendGrid functionality: create a contact.
n8n has a built-in SendGrid node. To avoid clashing with the existing node, you'll give your version a different name.
Step 1: Set up the project#
n8n provides a starter repository for node development. Using the starter ensures you have all necessary dependencies. It also provides a linter.
Clone the repository and navigate into the directory:
- Generate a new repository from the template repository.
- Clone your new repository:
git clone https://github.com/<your-organization>/<your-repo-name>.git n8n-nodes-friendgrid cd n8n-nodes-friendgrid
The starter contains example nodes and credentials. Delete the following directories and files:
Now create the following directories and files:
These are the key files required for any node. Refer to Node file structure for more information on required files and recommended organization.
Now install the project dependencies:
Step 2: Add an icon#
Save the SendGrid SVG logo from here as
n8n recommends using an SVG for your node icon, but you can also use PNG. If using PNG, the icon resolution should be 60x60px. Node icons should have a square or near-square aspect ratio.
Don't reference Font Awesome
If you want to use a Font Awesome icon in your node, download and embed the image.
Step 3: Define the node in the base file#
Every node must have a base file. Refer to Node base file for detailed information about base file parameters.
In this example, the file is
FriendGrid.node.ts. To keep this tutorial short, you'll place all the node functionality in this one file. When building more complex nodes, you should consider splitting out your functionality into modules. Refer to Node file structure for more information.
Step 3.1: Imports#
Start by adding the import statements:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
Step 3.2: Create the main class#
The node must export an interface that implements
INodeType. This interface must include a
description interface, which in turn contains the
Class names and file names
Make sure the class name and the file name match. For example, given a class
FriendGrid, the filename must be
1 2 3 4 5 6 7 8 9 10 11
Step 3.3: Add node details#
All programmatic nodes need some basic parameters, such as their display name and icon. Add the following to the
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
n8n uses some of the properties set in
description to render the node in the Editor UI. These properties are
Step 3.4: Add the resource#
The resource object defines the API resource that the node uses. In this tutorial, you're creating a node to access one of SendGrid's API endpoints:
/v3/marketing/contacts. This means you need to define a resource for this endpoint. Update the
properties array with the resource object:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
type controls which UI element n8n displays for the resource, and tells n8n what type of data to expect from the user.
options results in n8n adding a dropdown that allows users to choose one option. Refer to Node UI elements for more information.
Step 3.5: Add operations#
The operations object defines what you can do with a resource. It usually relates to REST API verbs (GET, POST, and so on). In this tutorial, there's one operation: create a contact. It has one required field, the email address for the contact the user creates.
Add the following to the
properties array, after the
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
Step 3.6: Add optional fields#
Most APIs, including the SendGrid API that you're using in this example, have optional fields you can use to refine your query.
To avoid overwhelming users, n8n displays these under Additional Fields in the UI.
For this tutorial, you'll add two additional fields, to allow users to enter the contact's first name and last name. Add the following to the properties array:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Step 4: Add the execute method#
Step 5 set up the node UI and basic information. It's time to map the node UI to API requests, and make the node actually do something.
execute method runs every time the node runs. In this method, you have access to the input items and to the parameters that the user set in the UI, including the credentials.
Add the following the
execute method in the
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
Note the following lines of this code:
1 2 3 4 5 6 7
Users can provide data in two ways:
- Entered directly in the node fields
- By mapping data from earlier nodes in the workflow
getInputData(), and the subsequent loop, allows the node to handle situations where data comes from a previous node. This includes supporting multiple inputs. This means that if, for example, the previous node outputs contact information for five people, your FriendGrid node can create five contacts.
Step 5: Set up authentication#
The SendGrid API requires users to authenticate with an API key.
Add the following to
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
For more information about credentials files and options, refer to Credentials file.
Step 6: Add node metadata#
Metadata about your node goes in the JSON file at the root of your node. n8n refers to this as the codex file. In this example, the file is
Add the following code to the JSON file:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
For more information on these parameters, refer to Node codex files.
Step 7: Update the npm package details#
Your npm package details are in the
package.json at the root of the project. It's essential to include the
n8n object with links to the credentials and base node file. Update this file to include the following information:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
You need to update the
package.json to include your own information, such as your name and repository URL. For more information on npm
package.json files, refer to npm's package.json documentation.
Test your node#
You can test your node as you build it by running it in a local n8n instance.
- Install n8n using npm:
npm install n8n -g
- When you are ready to test your node, publish it locally:
1 2 3
# In your node directory npm run build npm link
Install the node into your local n8n instance:
1 2 3
# In the nodes directory within your n8n installation # node-package-name is the name from the package.json npm link <node-package-name>
Check your directory
Make sure you run
npm link <node-name>in the nodes directory within your n8n installation. This is probably something like
Open n8n in your browser. You should see your nodes when you search for them in the nodes panel.
Make sure you search using the node name, not the package name. For example, if your npm package name is
n8n-nodes-weather-nodes, and the package contains nodes named
snow, you should search for