All nodes/Data/Code

JavaScript Code

Runs the body of async function call(input, …) { … } in JavaScript inside an isolated sandbox (this is JS, NOT Python: no import/`:`/elif; use JSON.parse, ===, .map). Data arriving on run becomes the first argument, input. Extra ports become parameters of call. Network: public hosts are open by default, the 'Allowed hosts' list narrows access; private addresses are always closed.

JavaScript Code▶

InputValue

Type in the graph: code_javascript

Exec

An error output can be enabled to handle failures on their own path.

Ports can be split into separate execution and data handles.

Try it

Minimal working scenario

Entry

JavaScript Code▶

Exit▶

Execute + Data

Press “Copy nodes”, open the editor and hit Ctrl+V on the canvas.

Runs as pasted

When to use it

Reach for this node when the transformation is not expressible with the ready-made data nodes. template joins strings, json_set and json_filter_map reshape JSON, math_op computes, if and switch branch, map and filter walk a list. Code is for the point where your own logic starts: parsing an odd format, a loop that accumulates, folding a third-party API response into a shape the rest of the graph can use. A plain text substitution does not need code — a template reads better and has no sandbox limits.

How it works

You write the body of async function call(input, …) { … }. The signature is shown read-only and cannot be changed. The value that arrives at the Input port becomes the input argument; whatever you return leaves through the Value output and is read downstream as {{ nodes.<id>.output }}.

Extra arguments come from extra ports: the Inputs tab → Custom Inputs section. A port’s name becomes the parameter name, so it has to be an identifier (letters, digits, underscores, starting with a letter) and cannot be input, run, nodes, inputs, variables or loop.

Two functions are available for scenario variables: get_var("name") and set_var("name", value). Both are synchronous and work only with variables declared by a var node in the same scenario — an unknown name throws. Written values are persisted only after the code finishes successfully.

console.log, console.warn and console.error land in the run log, which is the main way to debug here.

Network access is open to public hosts by default; private and loopback addresses are always blocked. The Allowed hosts field narrows egress to the names you list. The code gets 5 seconds and 128 MB by default; a plan can lower those numbers, never raise them. Code is capped at 64 KiB.

Common mistakes

Only an exec edge reaches the node. Then input === null — the value travels on a data edge wired into the Input port.
Python syntax. This is JavaScript: no import, no third-party packages, no elif or colons. Use JSON.parse, ===, .map.
Returning something JSON cannot carry. The result is serialized as JSON, so Map, Set and functions arrive empty — return plain objects and arrays.
Reading a variable that no node declares. get_var requires a var node with that name.
Assuming a failed run is free. The sandbox ran, and the run is billed regardless of the outcome — a timeout and an empty body included.

Inputs

Port	Wire	Payload	Notes
Input`run`	Execute + Data`execute_data`	—

Outputs

Port	Wire	Payload	Notes
Value`success`	Execute + Data`execute_data`	—

Configuration

Field Type Default Description

Field	Type	Default	Description
Code`code`	`string`	`return input;`	Function body only (signature and braces are shown read-only in the editor). It is wrapped as async call(input, …); extra input ports become parameters. Must not be empty — an empty body still costs a run and returns null.
Allowed hosts`net_allow`	`array<string>`	—	Optional restrictive allowlist of hostnames for outbound HTTP requests. If empty, all public hosts are reachable. Private/loopback IPs are always blocked.

Codecode

string

return input;

Function body only (signature and braces are shown read-only in the editor). It is wrapped as async call(input, …); extra input ports become parameters. Must not be empty — an empty body still costs a run and returns null.

Allowed hostsnet_allow

array<string>

—

Optional restrictive allowlist of hostnames for outbound HTTP requests. If empty, all public hosts are reachable. Private/loopback IPs are always blocked.

Shared fields

Every node has these three — the platform adds them, not the node author.

expose_error_output — When enabled, show an execution output to connect nodes that run if this step fails.
split_ports_in — Show separate execution and data input handles instead of one combined port.
split_ports_out — Show separate execution and data output handles instead of one combined port.