n8n Edit Fields Node (Set Node): The First Node Every Builder Should Master
The Edit Fields node — also called the Set node — is one of the most important nodes in n8n. It is the node you will use in nearly every workflow you build, and understanding it deeply separates beginners who struggle with data manipulation from builders who can handle any data transformation cleanly. Its purpose is straightforward: modify, add, or remove fields on items passing through your workflow.
This guide covers 15 to 20 different practical uses of the n8n Edit Fields node, from simple field renaming to data type conversion, JSON manipulation, array construction, and real-world integrations with Google Sheets and other data sources.
What the n8n Edit Fields Node Does
The Edit Fields node operates on the items flowing through your workflow and lets you control exactly what fields those items carry. You can rename a field, change its value, convert its data type, add a completely new field, or remove fields you no longer need. You can also combine multiple operations in a single Edit Fields node — renaming one field while adding another and converting a third all in the same step.
The node has two primary modes: manual mapping and expression. Manual mapping is the default and is where most operations happen — you define each field by name, pick its type, and set its value using a fixed input or by dragging in a reference from the previous node’s output. Expression mode gives you full access to n8n’s expression language, letting you compute values dynamically, combine fields, run transformations, and build complex logic directly in the field value.
Renaming Fields
Renaming a field is one of the most common operations in the Edit Fields node. You take an incoming field with one name and output it with a different name. The practical use case comes up constantly — an API returns a field called “user_id” but your downstream node expects “id,” or a Google Sheet column is named “Ultra Runner” but you want it as “runner” for cleaner data handling.
The key thing to understand when renaming: by default, the Edit Fields node only outputs the fields you explicitly define. If you rename “ultra_runner” to “runner” but do not include “name” and “miles_ran” in your node configuration, those fields disappear from the output. This catches many beginners off guard. The solution is either to include those fields explicitly in your Edit Fields configuration, or to turn on the “Include Other Input Fields” option — which passes through all fields from the input that you did not explicitly modify.
Adding New Fields
The Edit Fields node is also how you create new data that did not exist on the incoming item. You define a field name, choose a data type, and set a value — either fixed or computed from an expression. This is useful for adding metadata to items (timestamps, status labels, computed scores), setting default values for fields that might be missing upstream, or building structured data from raw inputs.
When adding fields via expression, you have access to the full item data from the previous node, all n8n variables, and JavaScript functions. You can concatenate strings, do arithmetic, format dates, and construct values from multiple source fields in a single expression. This is where the Edit Fields node becomes genuinely powerful — not just passing data through, but transforming it.
Data Type Conversion
One of the most practical uses of the Edit Fields node is converting fields between data types. Common conversions include: string to number (when an API returns a numeric value as text and a downstream node needs an actual number), number to string (when you want to concatenate a number into a text message), and string to boolean (when a field comes in as “true” or “false” text but needs to be a real boolean for a conditional check).
The data type selector in the Edit Fields node handles most of these conversions automatically when you set the correct type. If you set a field’s type to “number” and drag in a string value, n8n will attempt to parse it as a number. For more complex conversions — parsing a date string into a specific format, converting a comma-separated string into an array — you use the expression mode and n8n’s built-in transformation functions.
Working with Arrays and JSON
The Edit Fields node handles complex data types including arrays, objects, and JSON. You can build an array from scratch by setting a field’s type to “array” and defining its elements. You can construct a JSON object by setting the type to “object” and mapping in key-value pairs. When you drag a reference from a previous node into an expression field, n8n automatically wraps it in the appropriate JSON structure.
A common pattern is using Edit Fields to restructure nested data before sending it to an API or storing it in a database. An incoming item might have flat fields that need to be nested into an object, or nested data that needs to be flattened into individual fields. The Edit Fields node is the right tool for both directions of this transformation.
The “Include Other Input Fields” Option
One of the most useful settings in the Edit Fields node is “Include Other Input Fields.” When enabled, every field from the incoming item that you did not explicitly define in the node is automatically passed through to the output. This means you only need to specify the fields you want to change — everything else carries over untouched.
This setting is particularly valuable in workflows where items have many fields and you only need to modify one or two. Without it, you would need to explicitly list every field you want to keep. With it, you configure only the changes and let everything else pass through. Use this option as your default when you want to modify rather than replace the item structure.
Real-World Example: Edit Fields with Google Sheets
A typical real-world use of the Edit Fields node is in a Google Sheets pipeline. You read rows from a spreadsheet — each row becomes an item with fields for each column. Before passing those items to the next step in your workflow, you use Edit Fields to: rename columns to match your target system’s expected field names, convert string fields to numbers for calculation, add computed fields like a full name concatenated from first and last name columns, and remove any columns that are not needed downstream.
This pre-processing step before your core workflow logic keeps subsequent nodes clean and predictable. Instead of handling messy raw column names and inconsistent types throughout your workflow, you normalize everything once in an Edit Fields node immediately after the data source and work with clean structured data from that point forward.
Manual Mapping vs. Expression Mode
Most Edit Fields configurations use manual mapping — the drag-and-drop interface where you pick a field name, select a type, and set a value using the node panel. This covers the majority of use cases and is the fastest way to set up common transformations. Expression mode is for cases where the field value needs to be computed: combining multiple fields into one, running a conditional to set different values based on input data, or applying a function to transform the incoming value.
You can mix both modes in a single Edit Fields node. Some fields can use fixed values or simple drag-and-drop references while others use full expressions. This flexibility makes the node adaptable to nearly any data transformation scenario without needing to add additional code nodes or split the logic across multiple steps.
