How to use the Code node in n8n?

The Code node in n8n lets you run small, controlled pieces of JavaScript inside a workflow so you can transform data, build custom logic, or prepare API payloads. You drop it into a workflow like any other node, and it receives the JSON from previous nodes and outputs JSON for the next ones. Think of it as a tiny serverless function living inside your automation, good for logic that’s too complex for other nodes but still small enough that it doesn’t belong in a full external service.

 

What the Code Node Actually Is

 

The Code node is a JavaScript execution step. It runs in a sandbox, synchronously, during the workflow execution. You write JavaScript in the editor section called Run Once for Each Item (default mode) or Run Once (explicit mode if you switch it), depending on how you want it to behave.

• Run Once for Each Item: n8n feeds each input item (a JSON object) to your code one by one. You return one item or multiple items per input.
• Run Once: Your code receives the entire input array and returns a new array. Good for combining, filtering, or aggregating results.

You always output an array of objects containing a json property. This is what the next node receives.

 

The Direct, Practical Way to Use It

 

Drop a Code node into your workflow → open it → write JavaScript inside → make sure you return an array of objects with a json key. That’s the minimum you need to use it correctly.

 

Understanding What Comes Into the Node

 

Inside a Code node, the input data is accessible via special variables provided by n8n:

• items: An array of all input items, each item having json (primary data) and sometimes binary (files).
• item: In Run Once for Each Item mode, this refers to the current item.
• $input: Helper object that lets you access items more explicitly (e.g., $input.item.json).

You don't create these — they’re injected by n8n.

 

A Real, Working Example (Run Once for Each Item)

 

This transforms a user's full name into first and last name. It receives something like { "name": "Ada Lovelace" } and outputs structured data.

// Split the name into two parts
const [first, last] = item.json.name.split(' ');

// Always return an array of objects with json:
return [
  {
    json: {
      firstName: first,
      lastName: last,
    }
  }
];

 

Example for Run Once Mode (multiple input items → single output array)

 

This example collects all email addresses from previous nodes and outputs a combined list in one item.

// items = array of all input items
const emails = items.map(i => i.json.email);

// Return one item that contains all emails
return [
  {
    json: {
      emails: emails
    }
  }
];

 

Common Production Uses

 

• Transforming payloads before sending them to an API.
• Cleaning or restructuring JSON received from webhooks.
• Applying conditional logic that’s too complex for Switch or Set nodes.
• Merging or flattening data arrays.
• Generating signatures or encryption for authenticated API calls (within reason).

 

Production Tips (from real n8n environments)

 

• Keep logic small. If it turns into many lines or feels like an actual program, move it out to an external API or Function service.
• No async/await needed unless you enable it. The Code node behaves synchronously unless you're using the “Code (async)” node variant.
• Always return an array. If you forget this, the node fails.
• Don’t mutate items in place unless you mean to. Better to create new objects.
• Watch for large arrays. The node runs in memory; giant arrays slow down workflows.
• No external imports. You cannot import npm packages. Only vanilla JavaScript.

 

How to Think About the Code Node

 

The Code node is your escape hatch for logic that’s awkward with UI nodes but too lightweight to build a microservice for. It’s best used for transformations, validations, and small custom branching logic. It is not a full programming runtime, so treating it as such leads to slow workflows, timeouts, and painful debugging. Keep it small and purposeful, and test with sample data as you build.