Code

The Code node lets you run custom JavaScript within your flow. It is useful for operations that cannot be achieved with standard nodes: transforming data, performing calculations, manipulating text, signing requests, or integrating custom business logic. The node panel is organized into three tabs:

Configuration — the JavaScript editor, formatter, cheat sheet, autocomplete, and the DLP section.
Advanced — the default error path that decides where the flow goes if the script fails.
Events — tracking events that fire when the node runs, to feed your metrics.

Editor configuration

The code editor bundles tools to speed up writing and debugging:

Format: applies Prettier to your script and automatically adds await on asynchronous methods that need it.
Cheat sheet: opens a quick reference with the available global objects ($context, $memory, $user, $message, $input, $output, $utils) and their methods.
Autocomplete: as you type $, the editor suggests the available functions and namespaces along with their description.
Light / dark mode: switch the editor theme from the selector in the top-right corner.
Live validation: the editor flags common lint errors and warns when await is missing on an asynchronous method.

Accessing variables

Inside the Code node you can read and write flow variables using predefined global objects.

Context (`$context`)

Variables that persist only during the current flow execution:

// Read
const name = $context.get('name')
const name = $context.get('name', 'John') // with default value

// Write
$context.set('lastOrder.status', 'delivered')
$context.set('user', { name: 'John', plan: 'gold' })

Memory (`$memory`)

Variables that persist across workflows, tools, and nodes. They support time-to-live (TTL):

// Primitives (string, number, boolean) - optional TTL
$memory.set('name', 'John')
$memory.set('attempts', 3, 3600) // expires in 1 hour

// JSON - TTL required (in seconds, maximum 86,400 = 1 day)
$memory.setJson('user', { name: 'John', plan: 'gold' }, 86400)

// Files - async, TTL required (maximum 604,800 = 1 week)
await $memory.setFile('receipt', base64String, 604800, 'application/pdf')

Reading

const name = $memory.get('name')
const user = $memory.getJson('user')
const url = $memory.getFile('receipt').toUrl()           // temporary URL
const base64 = await $memory.getFile('receipt').toBase64()

Deletion

$memory.delete('temporary')
$memory.delete(['tmp1', 'tmp2', 'cache']) // multiple keys

Limits by data type

Type	Maximum size	TTL	Maximum TTL
String	255 characters	Optional	—
Number	15 digits	Optional	—
Boolean	—	Optional	—
JSON	15 KB	Required	86,400s (1 day)
File	10 MB	Required	604,800s (1 week)

The methods $memory.setFile(), $memory.getFile().toBase64(), and $memory.getFile().toRaw() are asynchronous. You must use await when calling them.

Migration from legacy nodes

Create a new Code (Memory V2) node.
Copy and paste the script from the legacy node.
Use the new available methods ($memory.setJson, $memory.setFile, etc.) if needed.

User (`$user`)

Information about the contact interacting with your flow:

const userId = $user.get('id')
const userName = $user.get('names')

Message (`$message`)

The last message sent by the user:

const text = $message.get('text')
const type = $message.get('type')       // TEXT, IMAGE, AUDIO, VIDEO, LOCATION, FILE
const attachmentUrl = $message.get('mediaUrl')
const lat = $message.get('lat')
const lng = $message.get('lng')

Input/Output (`$input`, `$output`)

For communication between tools and workflows:

const city = $input.get('city', 'Quito')  // with default value
$output.set('data', result)

HTTP responses

If you saved the response from an API node:

let apiResponse = $context.getHttpResponse('apiResponse')
apiResponse = apiResponse.json()

$memory.set('name', apiResponse.data.user.name)

The key in $context.getHttpResponse() must match exactly the one you configured in the “Save response” field of the API node.

Available utilities (`$utils`)

Logger

Logs values for debugging in key-value format. Logs appear in the execution history:

// Primitives are stored as-is
$utils.logger.log('userId', 1245)
$utils.logger.log('status', 'active')

// Objects and arrays are converted to string (truncated to 2,000 characters)
$utils.logger.log('orderData', { id: 1, name: 'christian' })

Each node allows a maximum of 5 log entries. The value of each entry has a limit of 2,000 characters.

Crypto

Standard cryptographic functions:

$utils.crypto.createHash('sha256')
$utils.crypto.createHmac('sha256', key)
$utils.crypto.randomBytes(32)

Lodash

Utilities for manipulating arrays, objects, and strings:

$utils._.get(object, 'nested.path', defaultValue)
$utils._.uniq(array)
$utils._.chunk(array, size)
$utils._.merge(object1, object2)

DLP (Data Loss Prevention)

At the bottom of the Configuration tab you’ll find the DLP section, which automatically masks sensitive data that the node writes to logs. Turn on the “Enable DLP” toggle to choose which types of information are masked (card number, email, phone number, etc.). It’s the recommended protection whenever your script handles personal, financial, or identity data.

Advanced tab

Configure the default error path. If the script throws an uncaught exception (for example, invalid JSON or a missing await), the flow continues through the configured path instead of stopping. Use it to show a friendly message to the user or to escalate to a human when the script fails.

Events tab

Register tracking events that fire when the node runs. They feed your metrics and let you correlate the execution of this node with conversions or drop-offs. Check the Events guide to learn how to configure and consume them.

Use cases

Extract fields from the object saved by an AI Agent

A workflow where an AI Agent node generates a structured response (for example, a JSON with intent, product, and sentiment) and saves it to context with the Save response option enabled. The following Code node reads that object, validates its fields, and puts them into individual variables so downstream nodes can react without calling the model again.

// The AI Agent saved its response as $context.ai_agent_response
const response = $context.get('ai_agent_response')

// Fields come from the agent's structured output object
const intent = $utils._.get(response, 'intent', 'unknown')
const product = $utils._.get(response, 'product.name')
const sentiment = $utils._.get(response, 'sentiment', 'neutral')

// Leave each field ready for downstream nodes
$context.set('intent', intent)
$context.set('product', product)
$context.set('sentiment', sentiment)

// Persist to memory whatever you want to reuse in future conversations
$memory.setJson('lastInteraction', { intent, product, sentiment }, 86400)

$utils.logger.log('intent', intent)
$utils.logger.log('product', product)

Use $utils._.get(obj, 'nested.path', defaultValue) to read nested fields without breaking if the model omits any of them.

Normalize the response from an API node

A workflow where an API node returns a list of orders with field names in English and downstream nodes expect them in Spanish. The Code node transforms the response before continuing.

const response = $context.getHttpResponse('ordersApi').json()

const orders = response.data.map((p) => ({
  numero: p.order_number,
  cliente: p.customer_name,
  total: p.total_amount,
}))

$memory.setJson('orders', orders, 3600)
$context.set('orderCount', orders.length)

Validate and mask sensitive data

A workflow where an earlier Question node collected the user’s email and saved it to context. The Code node validates and masks it before storing or displaying it, returning only what’s strictly needed.

const email = $context.get('email')
const isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)

if (!isValid) {
  $context.set('emailValid', false)
  return
}

const [user, domain] = email.split('@')
const masked = `${user.slice(0, 2)}***@${domain}`

$context.set('emailValid', true)
$context.set('emailMasked', masked)
$memory.set('email', email, 604800) // 1 week

Split a list into batches for processing

A workflow that needs to process a large list (for example, 300 contacts) by calling an API that only accepts 50 per request. The Code node splits the list into batches and stores them in memory so a downstream node can iterate over them.

const contacts = $memory.getJson('contacts')
const batches = $utils._.chunk(contacts, 50)

$memory.setJson('contactBatches', batches, 3600)
$context.set('totalBatches', batches.length)
$context.set('currentBatch', 0)

Allowed MIME types for $memory.setFile():

Category	Types
Text	`text/plain`
JSON/XML	`application/json`, `application/xml`, `text/xml`
Images	`image/jpeg`, `image/png`, `image/gif`
Videos	`video/mp4`, `video/ogg`, `video/webm`, `video/x-msvideo`, `video/mpeg`
Audio	`audio/mpeg`, `audio/wav`, `audio/ogg`, `audio/aac`, `audio/flac`
Documents	`application/pdf`

Next steps

AI Agent node

Configure an agent and save its response to context so you can process it with Code.

API node

Call external services and read the response with $context.getHttpResponse().

Context variables

How the flow’s temporary variables you read with $context work.

Memory variables

Persist data across workflows, tools, and conversations.

Getting Started

Developer

Jelou CLI

Outbound Messaging

Inbox

Marketplace

Channels

Configuration

Billing

Editor configuration

Accessing variables

Context (`$context`)

Memory (`$memory`)

Reading

Deletion

Limits by data type

Migration from legacy nodes

User (`$user`)

Message (`$message`)

Input/Output (`$input`, `$output`)

HTTP responses

Available utilities (`$utils`)

Logger

Crypto

Lodash

DLP (Data Loss Prevention)

Advanced tab

Events tab

Use cases

Next steps

AI Agent node

API node

Context variables

Memory variables

​Editor configuration

​Accessing variables

​Context ($context)

​Memory ($memory)

​Reading

​Deletion

​Limits by data type

​Migration from legacy nodes

​User ($user)

​Message ($message)

​Input/Output ($input, $output)

​HTTP responses

​Available utilities ($utils)

​Logger

​Crypto

​Lodash

​DLP (Data Loss Prevention)

​Advanced tab

​Events tab

​Use cases

​Next steps

AI Agent node

API node

Context variables

Memory variables

Editor configuration

Accessing variables

Context (`$context`)

Memory (`$memory`)

Reading

Deletion

Limits by data type

Migration from legacy nodes

User (`$user`)

Message (`$message`)

Input/Output (`$input`, `$output`)

HTTP responses

Available utilities (`$utils`)

Logger

Crypto

Lodash

DLP (Data Loss Prevention)

Advanced tab

Events tab

Use cases

Next steps