<!-- BusyBot node reference — https://busybot.net/tools/edit-fields/ -->

> Node: Edit Fields (`edit_fields`) · Action · v1
> Category: Core Nodes · Credentials: none
> Updated: 2026-08-16

# Edit Fields

> Modify or add fields to data

## Overview

Create, modify, or remove data fields. Shape incoming data into the exact format required by subsequent nodes. Supports manual field mapping, JSON output mode, type conversion, and dot notation for nested objects.

**Category:** Core Nodes  
**Tool Name:** `edit_fields`  
**Version:** 1

**Appearance:** Icon: `editFields` | Color: `#10b981`

## Node Type

**Action** — processes input items and produces output

## Input / Output

| Direction | Port(s) |
|-----------|--------|
| Input | `Input` |
| Output | `Output`, `Error` |

## Credentials

This tool does not require any credentials.

### Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Mode | `options` | Yes | `manual` | Choose between manual field mapping (define fields via UI) or JSON output mode (write raw JSON). |
| | | | | Options: `manual`, `json` |
| Fields to Set | `fixedCollection` | No | `{}` | Define the fields to add or modify. Each field has a name, type, and value. Only used in Manual Mapping mode. _(shown when Mode is `manual`)_ |
| — Field Name | `string` | No | — | The name/key for the field. Use dot notation (e.g., 'user.id') to create nested objects when dot notation is enabled. |
| — Field Type | `options` | No | `string` | The data type for the field value. Values will be converted to this type. |
| | | | | Options: `string`, `number`, `boolean`, `array`, `object` |
| — Value | `string` | No | — | The value for the field. Supports expressions like {{ $json.fieldName }} to reference input data. _(shown when Field Type is `string`)_ |
| — Value | `string` | No | — | JSON array literal or expression. Supports expressions like {{ $json.fieldName }}. _(shown when Field Type is `array`)_ |
| — Value | `string` | No | — | JSON object literal or expression. Supports expressions like {{ $json.fieldName }}. _(shown when Field Type is `object`)_ |
| — Value | `string` | No | — | Numeric value or expression. Supports expressions like {{ $json.fieldName }}. _(shown when Field Type is `number`)_ |
| — Value | `string` | No | — | Boolean value (true/false/1/0/yes/no) or expression. Supports expressions like {{ $json.fieldName }}. _(shown when Field Type is `boolean`)_ |
| JSON Output | `string` | No | `{}` | Raw JSON to set as the output. Supports expressions like {{ $json.field }}. Only used in JSON Output mode. _(shown when Mode is `json`)_ |
| Include in Output | `options` | Yes | `allInputFields` | Controls what data leaves the node. 'All Input Fields' appends/merges new fields to existing data. 'Keep Only Set Fields' outputs only the explicitly defined fields. |
| | | | | Options: `allInputFields`, `keepOnlySet` |
| Options | `collection` | No | `{}` | Additional options for field editing behavior. |
| — Support Dot Notation | `boolean` | No | `true` | When enabled, field names like 'user.id' create nested objects { user: { id: ... } }. When disabled, 'user.id' is treated as a literal key. |
| — Ignore Type Conversion Errors | `boolean` | No | `false` | When enabled, type conversion errors are ignored and the original value is kept. When disabled, type conversion errors will fail the item. |
| — Include Binary Data | `boolean` | No | `true` | When enabled, binary data from input items is passed through to output. |
| Max Concurrency | `number` | No | `100` | Maximum items to process concurrently. |

## Output Data

One output item per input item — this node reshapes items, it never changes how many there are. Binary data is forwarded unless Include Binary Data is turned off.

What the output JSON contains depends on Include in Output:

- **All Input Fields** — the item's existing JSON is copied first, then the fields you set are written over it. Fields you do not touch survive.
- **Keep Only Set Fields** — the output starts empty, so only the fields you set (or the object you wrote in JSON Output mode) are present. This is how you strip data from an item.

In Manual Mapping mode each entry in Fields to Set is evaluated against the current item, converted to its Field Type, and written under its Field Name. With Support Dot Notation on, a name like `user.profile.id` creates the nested objects along the way; with it off the whole string becomes one literal key. In JSON Output mode the JSON you wrote is evaluated for expressions, parsed, and then merged into (or substituted for) the item JSON — it must resolve to a JSON object, not an array or a primitive.

Every output item also carries `_editedAt`, the time the edit was applied as a Unix timestamp in milliseconds.

Reference the result downstream by expression, e.g. `{{ $json.fullName }}`.

## Usage Examples

- add a timestamp field to each item
- rename the 'name' field to 'fullName'
- set status to 'processed'
- remove sensitive fields before output
- transform the data structure

## Example Configuration

Manual mode — adding multiple fields:

```json
{
  "type": "edit_fields",
  "parameters": {
    "mode": "manual",
    "includeInOutput": "allInputFields",
    "fieldsToSet": {
      "fields": [
        {
          "name": "fullName",
          "type": "string",
          "value": "{{ $json.firstName }} {{ $json.lastName }}"
        },
        {
          "name": "isActive",
          "type": "boolean",
          "value": "true"
        },
        {
          "name": "processedAt",
          "type": "string",
          "value": "{{ new Date().toISOString() }}"
        }
      ]
    },
    "options": {
      "supportDotNotation": true,
      "ignoreTypeErrors": false,
      "includeBinaryData": true
    }
  }
}
```

JSON mode — complete data transformation:

```json
{
  "type": "edit_fields",
  "parameters": {
    "mode": "json",
    "includeInOutput": "keepOnlySet",
    "jsonOutput": "{\n  \"user\": {\n    \"id\": {{ $json.id }},\n    \"profile\": {\n      \"name\": \"{{ $json.firstName }} {{ $json.lastName }}\",\n      \"email\": \"{{ $json.email }}\"\n    }\n  },\n  \"metadata\": {\n    \"processedAt\": \"{{ new Date().toISOString() }}\",\n    \"version\": \"1.0\"\n  }\n}",
    "options": {
      "supportDotNotation": false,
      "ignoreTypeErrors": true,
      "includeBinaryData": false
    }
  }
}
```

Dot notation for nested objects:

```json
{
  "type": "edit_fields",
  "parameters": {
    "mode": "manual",
    "includeInOutput": "keepOnlySet",
    "fieldsToSet": {
      "fields": [
        {
          "name": "user.profile.firstName",
          "type": "string",
          "value": "{{ $json.firstName }}"
        },
        {
          "name": "user.profile.lastName",
          "type": "string",
          "value": "{{ $json.lastName }}"
        },
        {
          "name": "user.settings.notifications",
          "type": "boolean",
          "value": "true"
        }
      ]
    },
    "options": {
      "supportDotNotation": true,
      "ignoreTypeErrors": false,
      "includeBinaryData": false
    }
  }
}
```

### Error Handling

| Mode | Behavior |
|------|----------|
| **stop** | Halts workflow on first error |
| **continue** | Skips failed items, passes successful ones through |
| **errorPort** | Routes failed items to Error output port |

## Tips

Creates, modifies, or removes fields on each item using static values or expression syntax. Use when you need to reshape data — renaming fields, adding computed values, or stripping unwanted properties. Produces items with the modified field structure.