Code Step

What is a Code Step?

The Code Step is a flow tool that runs small, allow-listed Python snippets to validate data, update variables, and route the conversation. It runs on a normal tool step. Use it for the precise, deterministic work that an LLM shouldn’t guess at — format checks, counters, flag logic, and parsing structured data returned by a webhook.

The `run()` Contract

Every Code Step must define exactly one top-level function named run:

def run():
    return True

The function:

Must be named run and take no arguments
Must return a bool, a list[bool] or tuple[bool, ...], or a whole number (int) naming a condition row
Must not use decorators, nested functions, or classes
Must not use imports, global, or nonlocal
Must only call allow-listed functions

How the return value routes the step:

`run()` returns	Routes to
`True`	The first condition
`False`	The last condition (Otherwise)
`True, False, ...` (a list or tuple of booleans)	The condition at the position of the first `True`, or Otherwise if none is true
A whole number `N`, e.g. `return 3`	Condition row `N`, counting from 1. `0` behaves like `False`. A number past the last row goes to the last row, with a note on the call.

Other return values (a string, a decimal such as 1.0, a list of strings, or a list that mixes booleans and numbers) fail closed: the step routes to Otherwise and the error is written to the call’s system notes.

def run():
    return "true"   # invalid: a string

def run():
    return 1.0      # invalid: a decimal

def run():
    return 2        # valid: routes to the second condition

See Routing with multiple conditions for worked examples.

Do not indent def run(): — it must start at the first column.

Variables and Inputs

Read and write configured variables with double-brace {{...}} placeholders, and pass extra values in as mapped inputs.

def run():
    email = {{contact.email}}
    {{contact.email_verified}} = bool(email and "@" in email)
    return {{contact.email_verified}}

See Variables & Inputs for reads, writes, the custom namespace, and input_1-style mapped inputs.

Compile and Run

The Code Step is checked when you save it and again when the flow is compiled. When the call reaches the step, the code is prepared once (placeholders rendered, validated against the allow-list, compiled) and that prepared version is reused every time the step runs:

Placeholders are rendered into executable Python
The code is parsed and checked against the deny-by-default validator
run() executes and its return value is normalized into ordered boolean outputs

Compile errors, run errors, run success, and any print(...) output are written to the call’s system notes, including the line number on failure. For example:

Tool | Code Step | Print: email present: True
Tool | Code Step | Run success: outputs={'0': True, '1': False}
Tool | Code Step | Run error on line 2: name 'input_1' is not defined | return bool(input_1)

Use print(...) for debugging: unquoted placeholders like print({{contact.email}}) print the resolved value, while print("{{contact.email}}") prints the literal placeholder text.

Next Steps

Allowed Functions — The full deny-by-default allow-list
Examples — Common patterns and troubleshooting
Routing — Return multiple booleans to branch
Tool Steps — How tool steps and conditions work

Get Started & Build

Calls, Contacts & Batches

Numbers & Routing

Tools, Automations & Integrations

Account, Billing & Security

What is a Code Step?

The `run()` Contract

Variables and Inputs

Compile and Run

Next Steps

​What is a Code Step?

​The run() Contract

​Variables and Inputs

​Compile and Run

​Next Steps

What is a Code Step?

The `run()` Contract

Variables and Inputs

Compile and Run

Next Steps