Set / Edit Fields: shape data without writing code

Why you need a data-shaping step

Chapter 9 taught you that items are the basic unit that flows through n8n, and that every item is a blob of JSON. Wiring up SaaS nodes in Chapter 11, you have almost certainly hit this:

• The HTTP Request node hands back: { firstName: "Xiaoming", lastName: "Wang", email: "[email protected]", age: 28, avatar_url: "...", ... }
• But the next node, Google Sheets, only needs three fields: { Name: "Wang Xiaoming", Email: "[email protected]", Age: 28 }

You do not want to hand-assemble ten lines of expression inside the Sheets node, and you do not want to open a Code node and write JavaScript every time either. What you want is a waypoint that cleans the upstream JSON up into the shape the downstream node wants — and that is the Set node. It calls no API, triggers nothing, does nothing to the outside world; it purely gives the JSON a new shape and passes it on.

What the Set node actually does

Think of the Set node as a small processing machine. It works in three steps:

1. Read the input items

   It receives every item the previous node produced (one blob of JSON, or many). As with any other node, n8n runs it once for each item automatically.

2. Reassemble the JSON from your settings

   In the Set node you say which fields to keep, which to add and which to change, and it builds a new JSON from your rules.

3. Emit the output items

   The reshaped items go to the next node. The original input is untouched — the Set node produces a new version, it does not edit the input in place.

That is all it does. No API call, no webhook, no side effect. It is one of the fastest and safest nodes in n8n, and it usually runs in milliseconds.

Two working modes: Manual Mapping vs JSON

Open the Set node and there is a Mode dropdown at the top with just two options:

Both modes do the same thing underneath — produce a new piece of JSON. The only difference is whether you set it up in a visual interface or paste the JSON text yourself. If you are new, always start with Manual Mapping and only switch to JSON when you need a nested structure.

Hands-on: combine firstName and lastName into full_name

This is the most typical thing a Set node is used for. Say the upstream node produces:

{
  "firstName": "Xiaoming",
  "lastName": "Wang",
  "email": "[email protected]",
  "age": 28
}

You want one more field after that called full_name, with the value Wang Xiaoming, because this example’s required output puts lastName before firstName. Note: choose an order and separator that match your users’ naming conventions. Follow along:

1. Add an Edit Fields node

   On the canvas press + to add a node, search for edit fields or set, and pick Edit Fields (Set). Wire it after the node that produces the JSON above.

2. Leave Mode on Manual Mapping

   Manual Mapping is the default, so there is nothing to change.

3. Click Add Field under Fields to Set

   A blank field card appears below. Set Type to String, because full_name is a string.

4. Put full_name in Name

   This is the new field's name, and it is the name that appears in the JSON downstream nodes see.

5. Put the expression {{ $json.lastName }}{{ $json.firstName }} in Value

   There is an Expression toggle at the top right of the Value field; switch to Expression mode and paste that in. For expression syntax see Chapter 14 — $json means the JSON of the item being processed right now.

6. Tick Include Other Input Fields

   There is an important toggle further down the node: Include Other Input Fields (the wording the v1 UI actually uses; the official docs page still says the old Keep Only Set Fields, whose logic is the other way round). Ticked = keep every original field and add the full_name you set. Unticked = keep only the fields you set and throw the rest away. Tick it here.

7. Run Execute Node and look at the result

   Press Execute Node at the top right of the node. The Output panel should produce: { firstName: "Xiaoming", lastName: "Wang", email: "...", age: 28, full_name: "Wang Xiaoming" } — every original field is still there, plus a full_name. Job done.

The five most common Set uses, at a glance

Learn these five and you have covered nine tenths of everyday Set node work.

All five are within reach of Manual Mapping mode — no Code node, no functions to write. Most of the built-in JavaScript functions available in an expression (Number, String, Boolean, Math.round, Date, and string methods such as .toUpperCase(), .trim() and .split()) can be written directly.

Include Other Input Fields: the toggle beginners trip over

This toggle is the easiest part of the Set node to get confused about, so it is worth a section of its own.

Which one when?

• Adding or changing fields while keeping the rest → tick it. This is the common case.
• A big clean-out — you only want three fields to go downstream → turn it off, then list those three fields under Fields to Set.
• Security — the upstream API response holds sensitive fields (token, password_hash) you do not want carried downstream → turn it off and let through only the safe ones.

In the old interface this toggle was called Keep Only Set Fields, and the logic was exactly reversed: ticked = keep only what you set. From v1 it is Include Other Input Fields (ticked = keep the others), which reads far more naturally. Note that the official n8n docs page still says Keep Only Set Fields to this day, so the docs not matching the wording you see in the UI is entirely normal; go by the UI.

JSON mode: the tool for restructuring

When the job is not just adding a few fields but redesigning the whole JSON structure — gathering flat fields into a nested object, for instance — Manual Mapping starts to feel clumsy. That is where JSON mode comes in.

The situation: the upstream node emits flat JSON, you have to send it to an API, and that API wants a nested payload. Say upstream gives you:

{
  "id": "ORD-1234",
  "firstName": "Xiaoming",
  "lastName": "Wang",
  "amount": 1500
}

But the format the downstream API wants is:

{
  "orderId": "ORD-1234",
  "customer": {
    "name": "Wang Xiaoming",
    "vip": true
  }
}

Handling nesting in Manual Mapping is awkward; in JSON mode one paste settles it:

1. Switch Mode to JSON

   In the Mode dropdown at the top of the node pick JSON. Fields to Set disappears and a large text box takes its place.

2. Paste the JSON template

   Paste this whole block into the text box:

   {
     "orderId": "{{ $json.id }}",
     "customer": {
       "name": "{{ $json.lastName }}{{ $json.firstName }}",
       "vip": {{ $json.amount > 1000 }}
     }
   }

   String values have to be wrapped in quotes ("{{ ... }}"), boolean and numeric ones do not ({{ $json.amount > 1000 }} is straight true or false).

3. Use Include Other Input Fields to decide whether to keep the original fields

   JSON mode has the same toggle. Most of the time you paste JSON precisely because you are restructuring, so you turn it off — keeping only the fields the JSON template defines.

4. Run Execute Node and check that the structure is right

   The Output panel shows the JSON structure you pasted, with every expression already filled in with real values. Now you can wire up the downstream HTTP Request node and call the API.

Worked example: turn a nested API response into one sheet row

Put the Set node skills from the previous sections together into a short workflow you would really use. The situation: you called an order API with HTTP Request, the JSON that comes back is nested, and you have to append it to an order-tracking sheet in Google Sheets (one row, 4 columns).

What the upstream HTTP Request node returns:

{
  "data": {
    "user": {
      "name": "Wang Xiaoming",
      "email": "[email protected]"
    },
    "order": {
      "id": "ORD-9527",
      "amount": 2800
    },
    "meta": {
      "ts": "2026-08-16T10:30:00Z"
    }
  }
}

The sheet's header: Order ID | Name | Email | Amount | Timestamp | VIP

Put a Set node in the middle to do the reshaping:

1. Pick Manual Mapping as the Set node's Mode

   You are mapping onto the sheet's fixed columns, so setting one field at a time is the clearest way.

2. Turn Include Other Input Fields off

   Carrying the original nested structure into Sheets is pointless, so turn the toggle off and keep only the six fields set below.

3. Click Add Field six times and fill them in, in order

   Match them column by column against the sheet's header:

   Name	Type	Value (expression)
   Order ID	String	{{ $json.data.order.id }}
   Name	String	{{ $json.data.user.name }}
   Email	String	{{ $json.data.user.email }}
   Amount	Number	{{ $json.data.order.amount }}
   Timestamp	String	{{ $json.data.meta.ts }}
   VIP	String	{{ $json.data.order.amount > 1000 ? 'VIP' : 'Standard' }}

4. Run Execute Node and check the flat structure

   The Output should be 6 purely flat fields: { "Order ID": "ORD-9527", "Name": "Wang Xiaoming", "Email": "...", "Amount": 2800, "Timestamp": "...", "VIP": "VIP" }.

5. Wire up a Google Sheets Append node

   Set the Sheets node's Data Mode to Map Each Column Below. Because the field names already line up exactly with the sheet's header, you can drag the fields from the left panel straight into the matching boxes on the Sheets node — no need to type the expressions again.

That is the Set node's typical working pattern: comb the messy JSON the upstream node threw at you into something the downstream node can digest. Sheets, Slack, Notion and Airtable are all fussy about field formats; put a Set in the middle to tidy the data and the downstream node becomes much easier to configure.

Set vs Function vs Code: which one to use when

Three nodes in n8n can reshape data, but they are for different jobs. You may have run into the Function node in older tutorials, so here it is, sorted out once:

How do you choose? Ask yourself first: "Can Set do this?" If it can, use Set; only move up to Code when it cannot. The Set node is visual, easy to read, hard to get wrong and quick to run; the Code node can do more, but you have to write code, handle the errors, and a non-engineer who inherits it will have a harder time.

A few advanced Set node tricks

1. Add nested fields with dot notation (Manual Mapping mode)

Manual Mapping mode can produce a nested structure too; the trick is to build a path in the Name field with dots:

• Name = customer.name, Value = {{ $json.firstName }}
• Name = customer.email, Value = {{ $json.email }}

The output is { customer: { name: "Xiaoming", email: "..." } }. That saves you switching to JSON mode.

2. Covering many items in one pass

Like every other node, the Set node runs once for each item automatically. So you do not write a loop — send 10 items in from upstream and Set produces 10 reshaped outputs. On each pass $json points at the item being processed right then.

3. Use Continue On Fail so a broken item does not block the whole workflow

The Settings gear at the top right of the Set node holds Continue On Fail. When an expression fails on one item (a field that does not exist producing undefined.foo, say) and this is off, the whole workflow stops in red. With it on, that item is marked as an error but the workflow keeps running: you can see in the output which items broke while the rest carry on downstream.

4. A Set node at the start of a workflow makes a fake-data generator

No real trigger yet, but you want to test the logic of the nodes after it? Drop in a Manual Trigger plus a Set node, set the Set node's Mode to JSON, paste a block of fake JSON and turn Include Other Input Fields off — now pressing Execute Workflow sends one fake item down the workflow. A lifesaver for debugging.

Common pitfalls and fixes

FAQ