The Code node executes custom JavaScript (Node.js 18) or Python (3.10+ native, or legacy Pyodide) as a workflow step, providing full access to incoming data for complex manipulation beyond built‑in nodes. JavaScript runs natively with promises, console.log, and external npm module support; Python runs in a sandboxed subprocess or via WebAssembly depending on n8n version. Both languages share two execution modes—Run Once for All Items (aggregation) and Run Once for Each Item (per‑item mapping)—and must return an array of objects each containing a json key [1].

What are the two Code node execution modes and how do you choose between them?

The Code node provides two execution modes. Run Once for All Items (default) executes code once regardless of input count, accessing all items via $input.all() as an array—ideal for aggregation, counting, cross‑item comparisons, or restructuring nested arrays. Run Once for Each Item executes separately per item, accessing data through $input.item.json (shorthand: $json)—best for independent field mapping and enrichment. [1] [3]

A common mistake: using “Each Item” mode for aggregation tasks like counting total records—each item sees only its own data and cannot compute a sum across all items. Use “All Items” mode when the result depends on multiple items. From n8n 0.166.0, the return format is auto‑corrected if missing the json wrapper—but for maximum compatibility, always explicitly return [{ json: { key: "value" } }]. For production environments, n8n 2.0+ runs Code nodes in isolated Task Runners by default, with process.env access blocked and ExecuteCommand/ LocalFileTrigger nodes disabled [4]. The “Try to avoid the Code node unless you really need it” community benchmark found that Code nodes performing filtering or mapping typically take 1‑3 seconds to execute, compared to near‑instant built‑in nodes—use expressions or Set/IF/Merge nodes when they suffice [5]. For the complete reference of core nodes you can combine with the Code node, see the Core n8n Nodes guide.

How do you iterate over items and transform JSON data with JavaScript in the Code node?

In “Run Once for All Items” mode, loop over all input items with for (const item of $input.all()) { item.json.newField = 1; } return $input.all();. Use the $input.all() array with .map(), .filter(), and .reduce() for functional transformations. To extract a nested array buried inside a JSON wrapper and convert it into n8n’s item structure, use: return $input.first().json.data.map(item => ({ json: item })). [6] [7]

Key data access patterns: $input.all() returns all items as an array; $input.first() returns the first item; $input.last() returns the last; $input.item.json.fieldName accesses the current item’s JSON (available in “Each Item” mode); and $json is shorthand for $input.item.json in “Each Item” mode. Always access item.json.fieldName rather than item.fieldName—the data lives under .json. For async operations, use await $http.get('https://api.example.com') in JavaScript. For complete Code node transformation patterns including flatMap expansion of nested arrays into individual items, Luxon date formatting, and AJV JSON Schema validation, see the n8n Expression Node reference.

How do you write Python code in the n8n Code node for data transformation?

Python in the Code node accesses items through _input.all() (mirroring $input.all()) and returns the transformed list with return _input.all(). List comprehension enables compact field extraction: summaries = [item.json.get("summary") for item in _input.all()]; return [{"json": {"merged_summary": " ".join(summaries)}}]. In native Python mode (1.63.0+), full Python 3.10+ standard libraries are available; in legacy Pyodide mode, only Pyodide’s built‑in package set works. [8] [9]

A critical Pyodide‑specific pitfall: when type() outputs <class 'pyodide.ffi.JsProxy'>, convert to a native Python object using to_py(). This occurs when working with n8n node data structures such as inputs and outputs. json.dumps() is not compatible with Pyodide JsProxy objects and causes workflow hangs [9]. On n8n Cloud, the Python option for the Code node does not support importing any Python libraries—whether from the standard library or third‑party packages [10]. For the complete comparison of Code node vs Execute Command node—when you need full Python capabilities with pip packages—see the n8n Node Configuration Hub.

How do you handle dates, external modules, and advanced data structures in the Code node?

Dates: In JavaScript, n8n provides the Luxon library globally— access it with DateTime without any import statement (DateTime.now().toISO()). In native Python, use from datetime import datetime and datetime.fromtimestamp(timestamp).isoformat(). External modules: Self‑hosted JavaScript can import built‑in modules (NODE_FUNCTION_ALLOW_BUILTIN=*) and external npm modules (NODE_FUNCTION_ALLOW_EXTERNAL=axios,moment,lodash) [11].

Binary data: Access binary files via $input.item.binary.fileName in JavaScript or _input.item.binary.fileName in Python. The Code node can generate binary output (PDFs, images) using Buffer operations in JavaScript or bytes() in native Python. Nested arrays to individual items: Use flatMap to expand nested structures: return $input.first().json.items.flatMap(item => ({ json: item })). For the n8n 2.0+ environment, process.env access is blocked by default inside Code nodes—pass variables via $env.VARIABLE_NAME in a Set node before the Code node to keep separation of concerns [11]. For comprehensive error handling, logging, and production‑ready patterns that combine all data structures, see the Core n8n Nodes guide.

How can JavaScript and Python in the Code node be compared for choosing the right tool?

Benchmark data reveals a stark performance gap. In legacy Pyodide mode, Python averages ~25.5 ms per execution compared to ~0.68 ms for JavaScript due to WebAssembly compilation overhead. Native Python (1.63.0+) closes this gap significantly. Beyond raw speed, a single Code node with JavaScript can replace approximately 15 standard nodes for complex logic, reducing execution overhead for enterprise‑grade automations. [12] [8]

The pragmatic decision rule: use JavaScript for performance‑ critical production workflows with npm dependencies and async API calls. Use native Python for data‑science tasks requiring pandas, numpy, or scikit‑learn in self‑hosted deployments. Use Pyodide Python only for lightweight math/string transformations where no external libraries are needed and async is not required. The community best‑practice guide “Try to avoid the Code node unless you really need it” advises: reach for built‑in nodes first, expressions next, and Code node last—since built‑in nodes are more readable, upgrade‑safe, and break less across versions [5]. For the complete expressions reference and the 58+ built‑in methods that can replace Code node logic, see the n8n Expression Node reference.

What are the most common Code node errors and how do you fix them?

Error “A ‘json’ property isn’t an object”—most frequent— occurs when the Code node returns data without wrapping it in the item structure { json: { ... } }. Always return return [{ json: { key: "value" } }]. Error workflow hangs in Python—caused by json.dumps() on Pyodide JsProxy objects; convert with to_py() first. [13] [14]

Error Code node times out—default timeout is 300 seconds; increase via node Settings or set EXECUTIONS_TIMEOUT environment variable. Error Python module import fails—on n8n Cloud, no Python libraries are importable; on self‑hosted, verify the module is installed and accessible. Error process.env undefined in n8n 2.0+—Code nodes can no longer access environment variables directly; pass values via $env in nodes upstream of the Code node. For systematic debugging strategies that catch these errors at runtime, see the n8n Error Handling nodes guide.