Anatomy of a Node: The Internal X-Ray

Capsule overview

A node in n8n looks like a box with a name and an icon. But inside it has a precise structure that repeats — with small variations — across all 1,650+ available nodes. Learning this anatomy once is like learning the blueprint of a car: once you know they all have a steering wheel, pedals, mirrors, and a gearshift, driving a new one becomes a matter of adaptation, not learning from scratch.

In this capsule you'll open a node and name each of its parts. You'll see where data comes in, where the options are configured, what the advanced "options" are that appear collapsed, and where the result comes out. By the end, any n8n node will be an understandable object. When you add a new one (say, a Twilio node you've never used), you won't feel paralysis — you'll know exactly what to look for and where.

This capsule is dense but short. It's worth reading with a real node open beside you so you can point at each zone as you read.

The 4 internal zones of a node

When you open a node's editor (double-click), you see this:

┌──────────────────────────────────────────────────────────────┐
│  ← [Slack icon]  Slack                          [×]          │
├─────────────┬────────────────────────────┬───────────────────┤
│             │                            │                   │
│ ZONE 1      │     ZONE 2                 │   ZONE 4          │
│ INPUT DATA  │     PARAMETERS             │   OUTPUT DATA     │
│             │                            │                   │
│  {          │  Credential:               │   (empty until    │
│    "name":  │  [Slack Production ▾]      │    you run)       │
│    "Maria"  │                            │                   │
│  }          │  Resource:                 │                   │
│             │  [Message ▾]               │                   │
│             │                            │                   │
│             │  Operation:                │                   │
│             │  [Send ▾]                  │                   │
│             │                            │                   │
│             │  Channel:                  │                   │
│             │  [#general]                │                   │
│             │                            │                   │
│             │  Text:                     │                   │
│             │  Hi {{$json.name}}         │                   │
│             │                            │                   │
│             │  ▼ ZONE 3                  │                   │
│             │  Add Option ▾              │                   │
│             │  (advanced options)        │                   │
│             │                            │                   │
│             │  [▶ Execute step]          │                   │
└─────────────┴────────────────────────────┴───────────────────┘

Zone 1: Input Data (left) — the data that arrives from the previous node, in JSON format.

Zone 2: Main parameters (center top) — the fields that ALWAYS appear when you open the node (the most important ones).

Zone 3: Advanced options (center bottom, collapsed) — secondary options that are collapsed by default. You expand them by clicking "Add Option."

Zone 4: Output Data (right) — what the node generates after running.

This structure repeats across all nodes. The only thing that changes between a Slack node and a Google Sheets node are the specific fields within each zone — but the organization into 4 zones stays the same.

Zone 1: Input Data — what arrives at the node

The left column shows the data that's coming in to the node from the previous node. n8n shows it in JSON format:

{
  "name": "Maria López",
  "email": "maria@example.com",
  "type": "VIP",
  "registration_date": "2026-05-12T14:30:00"
}

What you see here:

• JSON structure (fields and values)
• "JSON" / "Table" / "Schema" tabs to view the data in different formats
• If the previous node produced multiple items (for example, a list of rows from Google Sheets), you'll see navigation between items (Item 1 of 50, etc.)

What you do NOT see:

• Data from nodes before the previous node. You only see what arrives from the immediate predecessor. If you want data from a node further back, you use special expressions (covered in M07).

Why it matters:

Your node's parameters (Zone 2) often reference this data with expressions. For example, in the "Channel" field you can write #{{$json.type}}-team to send to the channel that matches the customer type. To write that expression correctly, you first need to look at the real data in Zone 1 and verify that the type field exists.

Zone 2: Main parameters — what configures the node

This is the zone where you spend the most time. The parameters depend on the type of node, but there's a common pattern for external-service nodes:

Pattern for external-service nodes (Slack, Google Sheets, OpenAI, etc.)

Credential:    [select credential ▾]
Resource:      [Message / Channel / User ▾]      ← which object to manipulate
Operation:     [Send / Update / Delete ▾]        ← which action to perform
[specific fields based on Resource + Operation]

Credential, Resource, Operation are the three universal parameters. Then specific fields appear based on the combination of Resource + Operation you chose.

For example:

• Slack / Message / Send → fields like Channel, Text, etc. appear
• Slack / Channel / Create → fields like Channel name, Is private, etc. appear
• Slack / User / Get → a User ID field appears.

Change Resource or Operation and the whole list of fields below changes. That's not a bug — it's the correct design. n8n shows you only what's relevant to the chosen operation.

Pattern for logic/utility nodes (IF, Set, Wait, etc.)

They don't have a Credential or Resource/Operation. They have their own direct parameters:

• IF: "Conditions" (a list of conditions)
• Set: "Fields to set" (a list of fields to create/modify)
• Wait: "Resume" (how to continue: timer, webhook, etc.)

Simpler, without the Credential/Resource/Operation layer.

Zone 3: Options — collapsed advanced options

Below the main parameters there's an "Add Option" button or an "Options" accordion that expands on click. Here live the parameters that most people don't need but that are available:

Typical examples:

• Continue on Fail: does the workflow keep running if this node fails?
• Retry on Fail: automatic retries
• Timeout: how long to wait before failing
• Custom Headers / Custom Body: advanced modifications of the HTTP request

Why they're collapsed:

n8n separates "what 90% need" (Zone 2) from "what 10% need" (Zone 3). If all the options appeared at once, the nodes would be intimidating. If you need a specific option, you know where to look for it.

When to use: mainly in M06 (debugging) and M10 (production) when you need fine control over error handling, retry, etc.

Zone 4: Output Data — what the node generates

After running the step ("Execute step" button), the right column fills with the resulting data. For a Slack node that sent a message:

{
  "ok": true,
  "channel": "C12345",
  "ts": "1715520600.001234",
  "message": {
    "text": "Hi Maria",
    "user": "U67890",
    "type": "message"
  }
}

What you see:

• The complete JSON the service returned
• In tabs: "JSON" / "Table" / "Schema" / sometimes "Binary" if there are files
• If the node produced multiple items, navigation between them

Why it matters:

Whatever appears here is what the next node will receive as Input (Zone 1 of the next one). That's why if your workflow has 5 nodes and the second doesn't produce the field the fourth expects, you find it out by looking at outputs down the chain.

Node header: what lives up top

In the top bar of the editor:

• Service icon and name (Slack, Google Sheets, etc.)
• ? button (?) that opens the node's official documentation
• ← button or "Back to Workflow" to close the editor
• × button to close (same)

Some nodes also have:

• A collapsible Notes field: a text field where you write internal documentation for the node
• Node Settings: minor configuration (node color, notes, etc.)

Input/output tabs: JSON vs Table vs Schema

Both Zone 1 and Zone 4 have tabs:

Trick: when you have long data and just want to see the field names to write your expression, go to Schema. It's the fastest mental shortcut.

Item count: 1 or many?

n8n works with "items." An item is a unit of data (a JSON object). Some nodes produce 1 item; others produce many.

Examples:

• Webhook trigger: 1 item (the data that arrived)
• Google Sheets / Read: N items (one per row)
• OpenAI / Chat: 1 item (the LLM's response)
• HTTP Request to an API that returns an array: N items (one per array element)

In Zone 4 you'll see an "Item 1 of N" counter. If your node produces 50 items, the following nodes will run 50 times (once per item) — automatically. n8n iterates for you.

This is important because workflows with multiple items can produce surprising results. If your Set node configures message = "Hi" and you receive 50 items, all 50 items will have message = "Hi". If you wanted the message to change per item, you use expressions: message = "Hi {{$json.name}}" — then each item generates its personalized message.

We go deeper into this in M04 (Your First Workflow).

Troubleshooting

Problem 1: "I don't see Input Data — it's empty"

Cause: you haven't run any step yet, or this is the first node (trigger) and you haven't fired the trigger yet.
Solution: run the previous node first. If it's a trigger, click "Listen for test event" or run it manually.

Problem 2: "I change Resource and all the fields disappear"

Cause: expected behavior. Resource + Operation determine which fields appear.
Solution: also choose the Operation. When both are selected, the correct fields appear.

Problem 3: "The advanced options I need aren't in Zone 3"

Cause: not all options exist for all nodes. Some community nodes have fewer options.
Solution: check the node's official documentation (? button). If the option doesn't exist natively, there may be a workaround using an HTTP Request node that calls the API directly.

Problem 4: "Output Data shows a red error"

Cause: the node tried to run and failed. It could be an invalid credential, a badly configured parameter, or a problem with the external service.
Solution: read the error message in the output. n8n usually shows a specific message (e.g., "channel_not_found"). We cover this thoroughly in M06.

Problem 5: "Output Data has 50 items but I only wanted 1"

Cause: the previous node produced multiple items. n8n processes each one individually.
Solution: if you wanted a single item, use an "Aggregate" or "Limit" node beforehand to reduce them. Or a Filter to keep only the item you need.

Exercises

Exercise 1: Identify the 4 zones in a real node

Open any workflow with at least 2 nodes. Double-click the second node. Visually identify:

1. Which is Zone 1 (Input)?
2. Where is the "Execute step" button?
3. How many Options does it have collapsed (click "Add Option" to see them)?
4. Is there anything in Zone 4 (Output)? If not, run it.

Exercise 2: Inspect input vs output

Create a simple workflow: Manual Trigger → Set node.

1. Configure the Set to create name = "Maria" and age = 30.
2. Run the Set.
3. Compare Zone 1 (Input) with Zone 4 (Output) of the Set.

{}  
// empty or almost empty, comes from the Manual Trigger

{
  "name": "Maria",
  "age": 30
}

Exercise 3: Change Resource and observe fields

Add a Slack node to a workflow (you don't need a credential yet, just to inspect).

1. Change Resource to "Message." Note which fields appear.
2. Change Resource to "Channel." Note which fields appear.
3. Change Resource to "User." Note them.

Exercise 4: Schema view to inspect fields

Take a workflow with real data (run any API or use a Set's output like in exercise 2). In Zone 1 (Input) switch the tab to "Schema."

What do you see different vs JSON?

{
  "name": "Maria",
  "age": 30,
  "email": "maria@example.com",
  "type": "VIP"
}

name    (string)
age     (number)
email   (string)
type    (string)

Summary

• Every node has 4 internal zones: Input | Parameters | Options | Output
• This structure repeats across the 1,650+ available nodes
• Input (Zone 1): JSON data that arrives from the previous node
• Parameters (Zone 2): main configuration (Credential, Resource, Operation, fields)
• Options (Zone 3): collapsed advanced parameters (Continue on Fail, Timeout, etc.)
• Output (Zone 4): what the node generates (will be the next one's Input)
• Useful tabs: JSON (default), Table (lists), Schema (field names only)
• Item count: if Input has N items, the following nodes run N times automatically
• Learning the anatomy once works for any new node

Additional resources

1. Node Components Documentation - Detail of each zone.
2. Data Structure Reference - How data is structured in n8n.
3. Nodes Reference - Each built-in node with its specific anatomy.

Created: May 12, 2026
Version: 1.0