The four node families: Trigger / Core / App / Cluster

Why start by sorting nodes into families

You met the nodes panel back in Chapter 3 — press + on an empty spot on the canvas, or click Add first step in the right-hand panel, and a list slides in from the right. The amount of stuff inside is frightening:

• 400+ official nodes (Slack, Gmail, Notion, Airtable, HubSpot, Stripe, GitHub…)
• 30+ Core nodes (IF, Switch, Merge, Edit Fields, Code, Wait, HTTP Request…)
• A whole separate row of Trigger nodes (Schedule, Webhook, and a Trigger version bundled with every SaaS)
• Plus the entire AI / LangChain set (AI Agent, Chat Model, Memory, Vector Store…)

You do not have to memorize these hundreds of names. What you actually need is this — see a node and know within two seconds which family it belongs to and what it does. That is what keeps someone else's workflow from looking like fog, and it is how you know which part of the panel to head for when you build your own.

The conclusion first, one line each (they match the four folders under the official docs.n8n.io/integrations/builtin/) —

• Trigger (a functional category) = the "start" of a workflow; it decides when the workflow runs; no input dot on the left
• Core nodes (core-nodes/) = n8n's built-in flow, data and general-purpose tools (IF, Merge, Set, Code, HTTP Request, Wait, Schedule Trigger…)
• App nodes (app-nodes/, which the docs also call Actions) = one node per outside SaaS (Slack, Gmail, Notion…)
• Cluster nodes (cluster-nodes/) = group nodes used only by AI / LangChain: one root node (for example AI Agent) carrying several sub-nodes (Chat Model, Memory, Tool, Vector Store)

The next four sections take them one at a time.

Trigger nodes: where a workflow starts

Every workflow needs a starting point, and that starting point is the Trigger node — it decides when this workflow runs. The first groups you see when you open the nodes panel are usually On app event / On a schedule / When called by another workflow, and all of them are Triggers.

Trigger nodes have one visual giveaway: there is no input dot on the left. It is the starting point, so there is nothing upstream to connect to. On the right there is one output dot that sends data downstream.

Triggers are easy to find in the panel too — the first page of the nodes panel defaults to Triggers, and when you press + on an empty spot on the canvas to start a new workflow, n8n steers you straight to picking a Trigger (without one there is no starting point, and the workflow cannot run at all).

App nodes (actions): the nodes that talk to outside services

App nodes are the largest of the four families — the docs keep them under integrations/builtin/app-nodes/, and the panel labels them Actions in apps. What they share: each node maps to one outside service (a SaaS, a database, a cloud provider), and the node wraps every operation that service's API offers.

If you have used Zapier the idea is identical — in Zapier each app maps to an action, and in n8n each SaaS maps to one App node. "App node" is the docs' file name and "Action" is the panel's UI label, so the two mean the same thing and you do not need to worry when this guide uses both.

One Action node usually holds many sub-operations. Take Slack —

• Send Message: post a message to a channel or a person
• Update Message: edit a message you already sent
• Delete Message: delete a message
• Get Channel: fetch a channel's details
• Invite User: invite someone into a channel
• …and about 20 more operations

You do not have to memorize every sub-operation up front. Once the Slack node is on the canvas, the Operation dropdown on the right lists every option; pick the one you want.

The docs group Action nodes into roughly these categories, and every one of them has its place in the panel:

The visual giveaway for App nodes: a dot on each side (the left one takes data from upstream, the right one sends it downstream), and the icon is usually that service's own logo (Slack's purple hash, Gmail's red envelope, Notion's black-and-white page). Once you see the logo you know whose node it is.

Core nodes: built-in flow, data and utility tools

Core nodes are n8n's own built-in set of nodes (the docs file them under core-nodes/). There are fewer of them than App nodes, but every one matters. Their job is managing the data flow and control flow inside a workflow, plus general-purpose tools that are not tied to any SaaS — the tees, valves and switches of the plumbing, plus a skeleton key like HTTP Request.

The category names in the panel have changed a few times in recent versions: they used to be Core Nodes, then split into Flow / Data Transformation / Files / Helpers (the exact wording varies a little with your n8n version). When you cannot tell them apart, search instead.

The visual giveaway for Core nodes: a dot on each side (IF and Switch branch, so they carry several output dots on the right), and the icon is abstract geometry — a forking arrow for IF, converging arrows for Merge, a pen or field icon for Set, angle brackets </> for Code. A node with no SaaS logo is almost certainly Core.

Cluster nodes: the whole AI Agent group

The docs file Cluster nodes under integrations/builtin/cluster-nodes/ as the fourth family, and they are the biggest architectural change in the n8n ecosystem since 2024. A cluster is not one node but a group of nodes — every cluster has one root node (the main node, for example AI Agent) with several sub-nodes attached below it to supply capabilities.

A typical structure looks like this (an AI Agent root with four kinds of sub-node under it) —

Cluster nodes are very easy to spot — the root node grows a row of square, downward-facing connector dots along its underside (not the left-and-right round dots of Trigger / App / Core), each one labeled Chat Model / Memory / Tool / Vector Store. Attach the matching sub-node from below and n8n treats the cluster as complete and ready to run.

Chapter 21 takes apart the full root-plus-sub arrangement and the details of the ai_* connector dots. For this chapter, just remember: a node with several downward dots on its underside = a Cluster root, and whatever snaps up under those dots = a sub-node.

How to tell which family a node belongs to

Now that you know the four families, the skill that pays off in practice is classifying a node at a glance. Check these four features and you have the answer in a second —

1. Look underneath for ai_* dots → Cluster root

   A node with a few square downward dots along its underside, labeled Chat Model / Memory / Tool / Vector Store, is a Cluster root node (AI Agent, Basic LLM Chain, QA Chain and so on). The other way round: a node with only one upward dot on top, waiting to be picked up by a root, is a sub-node (Chat Model, Memory, Tool and so on).

2. Look on the left for an input dot → Trigger

   No dot on the left (only a line leaving on the right) → it is definitely a Trigger. A node sitting alone at the far left of the canvas with nothing wired in front of it is a Trigger. The name usually carries "Trigger" or "On..." (Slack Trigger, Schedule Trigger, Webhook, On form submission).

3. Look at the icon: a SaaS logo or abstract geometry → App or Core

   A dot on each side and a service's logo for an icon (Slack's purple hash, Gmail's red envelope, Notion's black-and-white page) → almost certainly an App node. An abstract geometric icon (a fork, a confluence, a gear, angle brackets) → almost certainly a Core node.

4. Look at the panel's own categories

   The nodes panel is already sorted for you: Triggers, Actions in apps (App nodes grouped by service), Core (with the Flow / Data Transformation / Files / Helpers sub-areas) and AI or Advanced AI (Cluster nodes). When you cannot tell, go back to the panel and see which label it sits under.

The rhythm most workflows follow

How do the four families combine in a real workflow? From the shortest to the most complex, there are roughly four rhythms:

1. Shortest: Trigger → 1 App node

   "Post the same message to Slack every morning at 8:00" — Schedule Trigger wired to Slack (Send Message), done. Two nodes and one line: the simplest shape a workflow takes. Good for nudges and reminders.

2. Common: Trigger → App that reads → Core that filters → App that writes → App that notifies

   "Every morning, fetch the support tickets, keep only the urgent ones, write them into Notion and tell the sales manager" — Schedule Trigger → HTTP Request (read the ticket API) → IF (priority == urgent) → Notion (create a page) → Slack (notify). This is the classic five-node workflow, and 80% of a company's automation looks like this.

3. AI: Chat Trigger → AI Agent (Cluster) → reply

   "A customer types in the web chat → the AI support agent answers" — Chat Trigger → AI Agent, with OpenAI Chat Model (reasoning) + Simple Memory (remembering the conversation) + Wikipedia Tool (looking things up) + HTTP Request Tool (calling an internal API) attached under the AI Agent. On screen it looks like one node sprouting four tendrils, which is the classic cluster shape.

4. Complex: several Triggers → IF branches → parallel App nodes → Merge → sub-workflow → error handling

   "A new customer arrives (three Triggers: Webhook + Manual + Schedule) → route by country → in parallel, send the welcome email / add them to the CRM / open a Slack channel → merge back into the main line → call the 'send an alert' sub-workflow → on failure retry 3 times automatically, and if it still fails tell IT." You will only meet 15-plus-node workflows like this in the later chapters, so there is nothing to be afraid of.

The pattern shows: usually one Trigger (sometimes several), App nodes doing the heavy lifting (over 60% of the node count), Core nodes as the pipe fittings that join the App nodes up (IF decides which way to go, Set reshapes the data, Merge brings the lines together), and Cluster as the AI-only "one node with several tendrils" structure.

The fastest way to find a node in the panel

Knowing the categories is what lets you read a workflow, but in practice you will never scroll through them one by one to find a node. Typing a keyword beats everything else.

1. Type the service name: Slack, Sheet, Gmail, Notion

   There is a search box at the top of the panel. Type slack and it filters down to the Slack-related nodes (both Slack and Slack Trigger show up). That finds 99% of the integrations you use.

2. Type a function word: if, set, code, wait, http

   Core nodes have no service name, so search by what they do. Type if and you get IF and Switch; type set and you get Set / Edit Fields; type http and you get HTTP Request.

3. Nothing found → it may be a community node (community package)

   A more niche regional or industry-specific SaaS may have no official node, but n8n has a community nodes mechanism — an admin has to install the package on the back end. That is an advanced operation, so ask IT to install it for you. Note: the English edition generalizes the source’s region-specific example; check providers and data-residency requirements in your own location.

4. No node for that SaaS at all → call it yourself with HTTP Request

   Nothing official and nothing from the community? Fine — as long as that service has a REST API, use the HTTP Request node (Chapter 12) and fill in the URL, method, header and body from its API docs. This is n8n's skeleton key: if they have an API, you can reach it.

Troubleshooting

These are the situations people hit most often when they first work with the nodes panel:

1. The nodes panel will not open

   There are two ways in: press + on an empty spot on the canvas, or, in a new workflow, click Add first step in the right-hand panel. If there are already nodes on the canvas, hover over the dot on a node's right side and a + appears; clicking that opens the panel too, and wires the new node in behind that one.

2. Too many categories to find anything

   Do not scroll page by page — type a keyword straight into the search box at the top. The categories are designed for people browsing; in practice, searching is the fastest route.

3. I typed the node I want and nothing came up

   Three possibilities: (1) the spelling does not match — if google sheets finds nothing, try sheets; (2) it may be a community node, which an admin has to install as a community package on the back end; (3) the service has no official node — in which case use HTTP Request (Chapter 12) against its API.

4. The node was renamed and you cannot find it (Function → Code, Set → Edit Fields)

   n8n renames nodes from time to time. The two you meet most: the Function node was replaced entirely by Code in v1, the docs' Function page is now a 404, and older workflows are migrated automatically or marked legacy on import; Set is now called Edit Fields (Set). When a name from an older tutorial finds nothing, type the new name (Code, Edit Fields).

5. You picked a SaaS App node but there is no input dot on the left

   You have probably picked the service's Trigger version (Slack Trigger instead of Slack). Delete it and pick the plain App version — searching slack brings up both nodes, so choose the one without "Trigger" in the name.

6. You added a Core node and do not know where to wire it

   Core nodes usually sit in the middle of a workflow (between the Trigger and the final App node). Put IF where you want the branch, Set where you want to reshape the data, Merge where the lines come back together. A Core node on its own does nothing; it only means something sandwiched between other nodes.

7. You added AI Agent, pressed Execute, and got "no language model"

   AI Agent is a Cluster root node, and it must have a sub-node (OpenAI Chat Model, Anthropic Chat Model or similar) attached to the Chat Model dot on its underside before it can run. Same story if you enable Memory / Tool without attaching the matching sub-node: you get an error about an empty connector. An AI Agent on its own will not move.

FAQ