The n8n Code node:
real examples that run.

n8n's docs say the Code node runs JavaScript or Python. Cool. They don't tell you what to actually build with it. Here's what mine do in a stack that runs 24/7 — copy-paste examples, not theory.

The Code node is the one node without a ceiling. That's not a metaphor.

Official docs: "Use the Code node to write custom JavaScript or Python and run it as a step in your workflow." Technically true. Practically useless as a description.

Here's the actual deal. Every other n8n node has a fixed interface: fields, dropdowns, toggles. The Code node hands you the data from the previous step and says: figure it out. Return what the next node needs. That's it.

What that looks like in real workflows: reshaping a payload so fields match what the next node expects. Filtering 80 records down to 12. Generating slugs or timestamps that don't exist in the input. Writing conditional logic that would take 6 nested IF nodes in the visual editor. Sometimes a 4-line fetch() is just faster than configuring an HTTP Request node. Every limitation in n8n's visual builder disappears the moment you open a Code node.

If you're fighting the expression editor for more than 30 seconds, you need the Code node

My rule: if I'm fighting the expression editor for more than 30 seconds, I open a Code node. If I need to loop over items and apply logic to each one, Code node. If I'm building a chain of Set/Merge nodes to massage one input, I stop and write it in code instead.

Where I don't use it: anything a built-in node already handles cleanly. Splitting a string? {{ $json.name.split(" ")[0] }} as an expression is fine. The Code node is for when that stops being fine.

The three situations that always require it: reshaping data for a downstream node, filtering items before they propagate, and any conditional logic complex enough that nested IF nodes would make the canvas unreadable. If you're building any of those, skip straight to Code.

The n8n item model: get this wrong and you'll fight every Code node you write

This is where most beginners hit a wall. n8n passes data between nodes as an array of items. Each item looks like this:

[
  {
    "json": {
      "name": "Derek",
      "email": "derek@example.com",
      "score": 42
    }
  },
  {
    "json": {
      "name": "Someone Else",
      "email": "other@example.com",
      "score": 17
    }
  }
]

Your Code node receives this array and must return an array in the same shape. The outer { json: ... } wrapper is mandatory. Skip it and you'll get an error or broken output.

There are two modes in the Code node:

• Run once for all items — you get the full array as $input.all(), return a new array
• Run once for each item — you get one item at a time as $input.item, return one item

Most data transformation tasks use "Run once for all items." Use "per item" mode when each row is completely independent and you want n8n to handle the loop.

JavaScript examples from a production stack (copy these, don't invent them from scratch)

1. Reshape an array of items

You got a list of leads from a webhook. Each item has first_name, last_name, phone, and 12 other fields. The next node only needs full_name, email, and source. Clean it up:

const items = $input.all();

return items.map(item => {
  const d = item.json;
  return {
    json: {
      full_name: `${d.first_name} ${d.last_name}`.trim(),
      email: d.email?.toLowerCase() ?? '',
      source: d.utm_source || 'direct'
    }
  };
});

2. Filter items by condition

A Google Sheet has 200 rows. You only want rows where the score is above 30 and the status is "active". An IF node gets ugly for this — just write it:

const items = $input.all();

const qualified = items.filter(item => {
  const d = item.json;
  return d.score > 30 && d.status === 'active';
});

// Return empty array if nothing matches (don't crash)
if (qualified.length === 0) {
  return [{ json: { result: 'no_matches', count: 0 } }];
}

return qualified;

3. Generate computed fields

You need a URL slug from a blog post title, a formatted date for a CRM, and a unique ID for deduplication. Do it all in one Code node instead of chaining three Set nodes:

const d = $input.item.json;

// Generate slug from title
const slug = d.title
  .toLowerCase()
  .replace(/[^a-z0-9\s-]/g, '')
  .trim()
  .replace(/\s+/g, '-');

// Format the date
const publishDate = new Date(d.created_at);
const formatted = publishDate.toLocaleDateString('en-US', {
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

// Build a dedup key
const dedupKey = `${d.source}-${d.email?.toLowerCase().replace(/\W/g, '')}`;

return {
  json: {
    ...d,          // keep original fields
    slug,
    publish_date_formatted: formatted,
    dedup_key: dedupKey
  }
};

4. Build a summary from multiple items

You have 50 Stripe charge records. You need to send one Telegram message with the day's revenue total, average charge, and count — not 50 separate messages. Aggregate in the Code node:

const items = $input.all();

const charges = items.map(i => i.json.amount / 100); // Stripe amounts in cents
const total = charges.reduce((sum, amt) => sum + amt, 0);
const avg = total / charges.length;
const count = charges.length;

return [{
  json: {
    revenue_total: `$${total.toFixed(2)}`,
    revenue_avg: `$${avg.toFixed(2)}`,
    charge_count: count,
    summary: `💰 Today: ${count} charges · $${total.toFixed(2)} total · avg $${avg.toFixed(2)}`
  }
}];

Python mode works the same way, with one limitation that catches people off guard

Python mode works the same way — same data model, same return shape. I use it when I need pandas-style data work or when a library I want isn't available as a plain JS npm package.

5. Parse and reformat dates (Python)

from datetime import datetime

item = _input.item['json']

raw_date = item.get('date_string', '')

try:
    # Try ISO format first
    dt = datetime.fromisoformat(raw_date.replace('Z', '+00:00'))
except ValueError:
    try:
        # Try common US format
        dt = datetime.strptime(raw_date, '%m/%d/%Y')
    except ValueError:
        dt = None

if dt:
    formatted = dt.strftime('%B %d, %Y')
    iso = dt.isoformat()
    day_of_week = dt.strftime('%A')
else:
    formatted = 'Invalid date'
    iso = None
    day_of_week = None

return {
    **item,
    'date_formatted': formatted,
    'date_iso': iso,
    'day_of_week': day_of_week
}

6. Score and rank items (Python)

items = _input.all()

def score_lead(d):
    score = 0
    if d.get('company_size', 0) > 10:
        score += 30
    if d.get('has_budget') == True:
        score += 40
    if d.get('timeline') in ('immediate', '30days'):
        score += 30
    return score

scored = []
for item in items:
    d = item['json']
    d['lead_score'] = score_lead(d)
    d['lead_tier'] = 'hot' if d['lead_score'] >= 70 else ('warm' if d['lead_score'] >= 40 else 'cold')
    scored.append({'json': d})

# Sort hottest first
scored.sort(key=lambda x: -x['json']['lead_score'])

return scored

Five Code node mistakes in order of how much time they waste

Forgetting the wrapper. Ninety percent of first-time errors. You write return { name: "test" } instead of return [{ json: { name: "test" } }] and n8n either errors or passes garbage downstream. Always wrap. Always return an array, even if it has one item.

Wrong input mode. "Run once for all items" gives you $input.all(). "Run once for each item" gives you $input.item. If you mix these up, your code either errors or processes only the first item. Check the dropdown at the top of the panel before you wonder why nothing works.

Not guarding against nulls. Webhook data is messy. API responses are messy. A field you expect to be a string is sometimes null, sometimes an empty object, sometimes missing entirely. d.email?.toLowerCase() ?? '' is defensive. d.email.toLowerCase() is a workflow crash waiting for production traffic to trigger it.

Letting errors blow up the workflow. An uncaught exception in a Code node kills the whole execution. Wrap anything that touches external data in try/catch, return a structured error item, and let a downstream IF node decide what to do about it. Silent failures are better than stopped workflows.

Stuffing everything into one node. I've seen Code nodes that transform, filter, aggregate, and format — 80 lines doing 6 different jobs. That thing is impossible to debug. Split it: one node transforms the shape, the next filters, the next aggregates. Each one is small enough to test with "Execute this node."

const items = $input.all();

return items.map(item => {
  try {
    const d = item.json;
    
    // Your risky operation here
    const result = JSON.parse(d.raw_payload);
    
    return {
      json: {
        ...d,
        parsed: result,
        parse_error: null
      }
    };
  } catch (err) {
    return {
      json: {
        ...item.json,
        parsed: null,
        parse_error: err.message
      }
    };
  }
});

The Code node is the ceiling remover. Once you're comfortable with it, n8n stops having limits for you.

A Code node in isolation doesn't do much. The power is in where it sits: what triggers the workflow, what calls the API before it, what sends the Telegram message after. The Code node handles the awkward middle part where data needs to change shape and the visual builder can't express the logic you actually need.

Most people hit their first real n8n wall not because the tool can't do something, but because they haven't touched the Code node yet. That IS the wall. The moment you're comfortable dropping in a Code node and writing ten lines of JavaScript, the tool stops having limits for your use case. That's not an exaggeration. It's just what's true about how the architecture works.

If you'd rather start from a working stack than build each piece from scratch, I put together 14 production workflows I actually use inside a live AI-operated business. Several of them have Code nodes doing exactly this kind of data work, and each one ships with documentation explaining what every node is doing and why I made that call.

If you're not ready to buy anything, the See Code Intelligence MCP → has the full tool list I use to run this operation — including which n8n plan, which AI nodes, and what integrations are actually worth setting up.