Code Patterns

Code Node Patterns

JavaScript and Python patterns for n8n Code nodes — data transformation, API response processing, date handling, and binary data.

JavaScript Patterns

Data Transformation

Flatten Nested Objects

const items = $input.all();

return items.map(item => ({
  json: {
    id: item.json.id,
    name: item.json.user.name,
    email: item.json.user.email,
    city: item.json.user.address.city
  }
}));

Group Items by Field

const items = $input.all();
const grouped = {};

for (const item of items) {
  const key = item.json.category;
  if (!grouped[key]) grouped[key] = [];
  grouped[key].push(item.json);
}

return Object.entries(grouped).map(([category, items]) => ({
  json: { category, items, count: items.length }
}));

Deduplicate Items

const items = $input.all();
const seen = new Set();
const unique = [];

for (const item of items) {
  const key = item.json.email;
  if (!seen.has(key)) {
    seen.add(key);
    unique.push(item);
  }
}

return unique;

Filter and Transform

const items = $input.all();

return items
  .filter(item => item.json.status === "active" && item.json.age >= 18)
  .map(item => ({
    json: {
      fullName: `${item.json.firstName} ${item.json.lastName}`,
      email: item.json.email.toLowerCase(),
      tier: item.json.spending > 1000 ? "premium" : "standard"
    }
  }));

API Response Processing

Extract Paginated API Data

const response = $input.first().json;
const results = response.data || response.results || [];

return results.map(record => ({
  json: record
}));

Handle API Error Responses

const response = $input.first().json;

if (response.error || response.statusCode >= 400) {
  return [{
    json: {
      success: false,
      error: response.error || response.message || "Unknown error",
      statusCode: response.statusCode
    }
  }];
}

return [{ json: { success: true, data: response.data } }];

Merge Data from Multiple API Calls

const users = $("Get Users").all().map(i => i.json);
const orders = $("Get Orders").all().map(i => i.json);

return users.map(user => ({
  json: {
    ...user,
    orders: orders.filter(o => o.userId === user.id),
    totalOrders: orders.filter(o => o.userId === user.id).length
  }
}));

Date Handling

Format Dates

const items = $input.all();

return items.map(item => ({
  json: {
    ...item.json,
    formattedDate: new Date(item.json.createdAt).toLocaleDateString("en-US"),
    isoDate: new Date(item.json.createdAt).toISOString(),
    timestamp: new Date(item.json.createdAt).getTime()
  }
}));

Calculate Date Differences

const items = $input.all();
const now = new Date();

return items.map(item => {
  const created = new Date(item.json.createdAt);
  const diffMs = now - created;
  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));

  return {
    json: {
      ...item.json,
      daysAgo: diffDays,
      isRecent: diffDays <= 7
    }
  };
});

Generate Date Ranges

const startDate = new Date($json.startDate);
const endDate = new Date($json.endDate);
const dates = [];

for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
  dates.push(new Date(d).toISOString().split("T")[0]);
}

return dates.map(date => ({ json: { date } }));

Aggregation

Sum, Average, Count

const items = $input.all();
const values = items.map(i => i.json.amount);

return [{
  json: {
    count: values.length,
    sum: values.reduce((a, b) => a + b, 0),
    average: values.reduce((a, b) => a + b, 0) / values.length,
    min: Math.min(...values),
    max: Math.max(...values)
  }
}];

Pivot Table

const items = $input.all();
const pivot = {};

for (const item of items) {
  const row = item.json.month;
  const col = item.json.category;
  if (!pivot[row]) pivot[row] = {};
  pivot[row][col] = (pivot[row][col] || 0) + item.json.amount;
}

return Object.entries(pivot).map(([month, categories]) => ({
  json: { month, ...categories }
}));

Working with Binary Data

Create CSV from Items

const items = $input.all();
const headers = Object.keys(items[0].json);
const csv = [
  headers.join(","),
  ...items.map(item => headers.map(h => `"${item.json[h] ?? ""}"`).join(","))
].join("\n");

return [{
  json: { filename: "export.csv" },
  binary: {
    data: {
      data: Buffer.from(csv).toString("base64"),
      mimeType: "text/csv",
      fileName: "export.csv"
    }
  }
}];

Parse CSV Content

const csvContent = $input.first().json.content;
const lines = csvContent.split("\n");
const headers = lines[0].split(",").map(h => h.trim().replace(/"/g, ""));

return lines.slice(1).filter(l => l.trim()).map(line => {
  const values = line.split(",").map(v => v.trim().replace(/"/g, ""));
  const obj = {};
  headers.forEach((h, i) => obj[h] = values[i]);
  return { json: obj };
});

Python Patterns

Basic Data Transformation

items = _input.all()

result = []
for item in items:
    result.append({
        "json": {
            "name": item.json["firstName"] + " " + item.json["lastName"],
            "email": item.json["email"].lower(),
            "active": item.json["status"] == "active"
        }
    })

return result

Filter Items

items = _input.all()
return [item for item in items if item.json.get("status") == "active"]

Aggregate Data

items = _input.all()
values = [item.json["amount"] for item in items]

return [{
    "json": {
        "count": len(values),
        "total": sum(values),
        "average": sum(values) / len(values) if values else 0,
        "min": min(values) if values else 0,
        "max": max(values) if values else 0
    }
}]

Date Operations

from datetime import datetime, timedelta

items = _input.all()
now = datetime.now()

result = []
for item in items:
    created = datetime.fromisoformat(item.json["createdAt"].replace("Z", "+00:00"))
    days_ago = (now - created.replace(tzinfo=None)).days

    result.append({
        "json": {
            **item.json,
            "daysAgo": days_ago,
            "isRecent": days_ago <= 7
        }
    })

return result

JSON Processing

import json

items = _input.all()
raw = items[0].json.get("rawData", "{}")
parsed = json.loads(raw) if isinstance(raw, str) else raw

return [{"json": parsed}]

Best Practices

1. Always return an array of items — [{ json: { ... } }]
2. Handle empty inputs — check $input.all().length before processing
3. Use $() to reference nodes — safer than $node["Name"]
4. Avoid side effects — don't make API calls from Code nodes, use HTTP Request
5. Keep code simple — complex logic is hard to debug in n8n
6. Use try/catch — wrap risky operations to prevent node failures
7. Log for debugging — use console.log() in test mode
8. Prefer JavaScript — broader community support and examples