Expressions & variables

The basic pattern

Every node's output is reachable with the same shape:

{{prefix:label.output.field}}

prefix identifies the kind of node, label is the node's name (normalized, see below), and .output. leads into what the node produced. A reference without .output. (for example {{trigger:start.items}}) still resolves for backward compatibility, but .output. is the form to write.

Node prefixes

A node key carries one of seven prefixes. Six resolve to data; note: always resolves to null because a note produces no output.

See the Node reference for what each node type puts under .output..

Label normalization

A node's label is turned into the key used in {{prefix:label...}} by one rule, applied in order:

1. 1
   Trim
   Leading and trailing whitespace is removed.
2. 2
   Transliterate accents
   Accented characters become their ASCII base letter.
3. 3
   Lowercase
   The whole string is lowercased.
4. 4
   Replace other characters
   Every character that isn't a-z0-9 becomes an underscore.
5. 5
   Collapse and trim underscores
   Repeated underscores collapse to one; leading and trailing underscores are removed.

So a Core node labelled “Check Status” is core:check_status, and an integration step labelled “API Call” is mcp:api_call. A reference written with the human-readable label, such as {{mcp:Fetch Profile.output.data}}, is rewritten to {{mcp:fetch_profile.output.data}} before evaluation.

Nested paths and array indexing

{{mcp:fetch.output.user.name}}
{{mcp:fetch.output.items[0]}}
{{core:split.output.edges[0].node.text}}

Dotted paths walk nested objects; key[N] indexes into a list. An out-of-range index, or indexing something that isn't a list, resolves to null. .length works as a property on lists and objects, and on a list of objects list.field returns the list of that field's values.

Split item aliases

Inside a Split body, short forms give you the current item and its position:

item is an alias of current_item, and index is an alias of current_index: {{current_item.field}} and {{item.field}} resolve identically. These values exist only inside the split body. A While node exposes its 0-based pass counter as {{core:loop.output.iteration}}.

Workspace variables ($vars)

Variables are reusable values (URLs, IDs, settings) shared by every workflow of a workspace. You manage them in Settings > Credentials & Variables, on the Variables tab, and reference them with {{$vars.name}} or the alias {{vars:name}}.

1. 1
   Open the Variables tab
   Go to Settings > Credentials & Variables and select Variables.
2. 2
   Add a variable
   Click Add variable. Enter a Name (letters, digits, and underscores, not starting with a digit, at most 64 characters), pick a Type (Text, Number, Boolean, or JSON), and enter the Value.
3. 3
   Reference it
   Use Copy reference in the list, or type {{$vars.name}} in any node field.

{{$vars.apiUrl}}
{{vars:config}}
{{$vars.config.api.url}}

Variables belong to the workspace you are working in (your personal space or an organization), so every workflow of that workspace can read them. A JSON variable can be navigated like any other object. Values are stored encrypted and fetched once when a run starts; a run paused for more than 10 minutes may see updated values when it resumes. Deleting a variable makes references to it resolve as empty. Your plan may limit how many variables you can create.

Whole value vs text

When a field's whole value is exactly one {{ ... }} block, the result keeps its type: a number stays a number, a list stays a list, an object stays an object. This is the only way to pass a real object or list into a field that expects one.

When the expression is embedded in text, or there are several blocks, each block is resolved and the result is a string. In that case a resolved object or list is written as JSON ({"a":1}), and a block that resolves to null becomes an empty string. In a condition, a null result counts as false.

{{mcp:fetch.output.items}}              → a list
Found {{size(mcp:fetch.output.items)}} items  → a string, "Found 3 items"

Built-in functions

46 function names are available as plain calls inside {{ }}, for example {{uppercase(mcp:fetch.output.name)}}. Two are aliases (len of size, fromjson of json). Names are case-insensitive (formatDate and formatdate are the same function). matches is not among them: it is an operator (see below).

Type conversion

Checks and fallbacks

coalesce is the tool for polling: read the value from every attempt, newest first, and you get the latest one that is not empty.

Math

Text

Dates and formatting

formatdate accepts a number of epoch milliseconds (formatted in UTC), an ISO date (2026-09-24), or an ISO date and time without a time zone (2026-09-24T14:05:09). Any other value, including an ISO timestamp that ends in Z or an offset such as +02:00, is returned unchanged, without an error. In the pattern, DD, YYYY, and YY are read as dd, yyyy, and yy. The separators used by formatnumber and formatcurrency follow the server's settings, not your language.

JSON

A typical use of json() is turning a text field into typed data for a parameter that expects an object. Parsing is limited to 256 KB per string value, 64 levels of nesting, and 2 MB per document. Unlike every other error, malformed JSON is reported in the inspector instead of resolving to empty.

{{json(mcp:fetch.output.body)}}
{{json('{"responseModalities":["IMAGE"]}')}}

Operators and collection filters

Expressions use the Spring Expression Language (SpEL) operators: arithmetic + - * / %, comparison == != < > <= >=, logical && || ! (or and, or, not), the ternary cond ? a : b, and matches for regular expressions.

{{nums.?[#this > 10]}}
{{users.?[age >= 18 and active == true]}}
{{users.?[age >= 18].![name]}}
{{users.?[age >= 18].size()}}

Filters and projections chain, and a filter with no match returns an empty list, never null. Only a safe set of methods can be called on values: on text length, isEmpty, isBlank, trim, strip, toLowerCase, toUpperCase, contains, startsWith, endsWith, substring, replace, replaceAll, replaceFirst, matches, split, indexOf, lastIndexOf, charAt, toString; on lists size, isEmpty, contains, get; on objects get, getOrDefault, containsKey, containsValue, size, isEmpty. Type references, constructors, and other method calls are blocked.

Two different defaults: interface pipe vs default()

Interfaces and workflow fields use the same {{ }} braces but two different fallback mechanisms:

A file resolved into an interface template is rendered as its storage path, so <img src="{{photo}}"> gets a usable address directly. See Interfaces & apps for the full templating model.

Common pitfalls

The Code node's extra result level

A Code node's returned value is exposed downstream as {{core:<label>.output.result.<field>}}: the engine wraps what you return under an extra result key. A mapping written as {"result":"{{core:normalize.output}}"} produces a double result.result and reads as empty. Map past the wrapper: {"result":"{{core:normalize.output.result}}"}.

Sub-workflow outputs use the bare child key

A Sub-Workflow node returns the child's node outputs keyed by the child node's key without its prefix: {{core:call_child.output.result.step_result.output.transformed.url}}, not result.core:step_result. The prefixed form resolves to empty without an error.

Legacy forms

For backward compatibility the resolver still recognizes older dotted forms (steps., triggers., data., current_item., mcps.). Write the prefixed form.

The expression editor

Fields that accept expressions open an editor with categorized autocomplete for node outputs and functions, and a syntax guide with examples. The interface mapping inspector has its own function-help popover for the functions most useful when wiring data into a page.

Troubleshooting

Related pages