Skip to main content
Code

​
Overview

The Code node lets you write custom JavaScript to transform data, perform calculations, implement complex logic, or handle tasks that other nodes can’t.
Best for: Data transformations, calculations, custom business logic, data formatting, and complex data manipulation.

​
When to Use Code Node

Perfect for:
  • Data transformations and formatting
  • Mathematical calculations
  • Custom business logic
  • JSON parsing and manipulation
  • Data validation and cleaning
  • Date/time operations
Not ideal for:
  • AI analysis (use Agent node)
  • API calls (use HTTP Request node)
  • Simple conditions (use Condition node)

​
Configuration

Code Editor: Write your JavaScript transformation logic Access Previous Nodes: All previous node outputs are available as variables

​
Examples

​
Calculate Statistics

// Access data from previous nodes
const scores = agent.scores || [];

// Calculate statistics
const average = scores.reduce((a, b) => a + b, 0) / scores.length;
const max = Math.max(...scores);
const min = Math.min(...scores);

// Return result
return {
  average_score: average.toFixed(2),
  highest_score: max,
  lowest_score: min,
  grade: average >= 90 ? "A" : average >= 80 ? "B" : "C"
};

​
Validate and Clean Data

// Access form data
const email = trigger.email || "";
const amount = trigger.amount || 0;

// Validate
if (!email.includes("@")) {
  throw new Error("Invalid email format");
}

if (amount <= 0) {
  throw new Error("Amount must be greater than zero");
}

// Clean and return
return {
  email: email.trim().toLowerCase(),
  amount: parseFloat(amount.toFixed(2)),
  validated: true
};

​
Accessing Code Output

Use the code node name to access returned values in subsequent nodes: 
{{code_node_name.output.customer}}
{{code_node_name.output.total}}
{{code_node_name.output.formatted_date}}
{{code_node_name.output.processed_items[0].name}}

​
Best Practices

Return data as objects for easy access in later nodes. This makes it simple to reference specific values in subsequent nodes using dot notation.
Use || or optional chaining to provide default values and prevent errors when data is undefined or null.
Wrap risky operations in try-catch blocks to prevent workflow failures. This allows you to handle errors gracefully and provide meaningful error messages.
Complex logic might be better in an Agent node. Use code nodes for straightforward transformations and calculations, not for tasks requiring intelligence or context understanding.
Document what your code does for future reference. Clear comments help you and your team understand the logic when revisiting the workflow later.

​
Next Steps

Agent

Use AI for intelligent processing

HTTP Request

Fetch external data