Expression syntax

JavaScript expression syntax for variables, operators, and conditions in workflows.

An expression is a short piece of JavaScript, a widely used programming language, that reads or computes a value. Expressions in a workflow reference values with the $vars prefix, and they are used in configuration fields, Decision and Switch conditions, and Script code.

Variables and data flow describes how data moves between nodes and how variables work.

Variable references

Every value you reference lives under $vars:

$vars.httpRequest1.output.body      // node output
$vars.orderTotal                    // variable
$vars.manualTrigger1.output.userId  // trigger input

• Node output: $vars.<nodeName>.output. Every node exposes its result under .output. The shape of that object depends on the node, so each page of the node reference lists the output fields of its node.
• Variables: $vars.<name>.
• Trigger inputs: $vars.<triggerName>.output.<inputName>.

Nested properties use dot notation, and array elements use bracket notation:

$vars.httpRequest1.output.body.customer.email
$vars.httpRequest1.output.body.items[0].id

Where you write expressions

The rule in short: write $vars… directly in Script code, in conditions, and in fields set to Expression, and wrap it in {{ $vars… }} inside text fields set to Fixed value.

Most configuration fields can hold either a fixed value or an expression. An icon at the right end of the field opens a menu with three options:

• Fixed value: enter a value directly.
• Expression: write a JavaScript expression. The editor offers IntelliSense, which suggests names and properties as you type. In this mode the field shows an = before the expression.
• Clear value: empties the field.

The Insert menu next to the field label opens a searchable list of the values that are available at that node. The list is a tree under $vars, with one entry for each node, its output, and the fields inside it, and each field shows its type, such as string or object. The list also has a $metadata group with the entries FolderKey, InstanceId, ProcessKey, and ElementCount.

Fixed value fields

A field set to Fixed value holds text. To embed an expression in the text, select a value from the Insert menu, which wraps the reference in double curly braces. The editor checks the reference and reports a problem below the field, for example when a property does not exist on the node's output:

https://api.example.com/users/{{ $vars.manualTrigger1.output.userId }}

Expression fields and Script code

A field set to Expression, Decision and Switch conditions, the Update Variable section, and Script code take the expression directly, with no braces:

$vars.httpRequest1.output.code === 200

In an expression field, text and a value are combined by joining them with + or by using a template literal. Both of the following produce the same result:

"https://api.example.com/users/" + $vars.manualTrigger1.output.userId
`https://api.example.com/users/${$vars.manualTrigger1.output.userId}`

Operators

Standard JavaScript operators are supported:

Operator	Example	Result
Equality	$vars.status === "active"	true or false
Inequality	$vars.count !== 0	true or false
Comparison	$vars.price > 100	true or false
Logical AND	$vars.isVerified && $vars.isActive	true or false
Logical OR	$vars.role === "admin" || $vars.role === "owner"	true or false
Ternary	$vars.count > 0 ? "has items" : "empty"	string

String operations

"Hello, " + $vars.firstName
$vars.message.toUpperCase()
$vars.email.includes("@uipath.com")

Template literals combine variables and static text:

`Hello ${$vars.firstName}, your order #${$vars.orderId} has shipped.`

Optional chaining

The ?. operator safely reads properties that may be undefined:

$vars.httpRequest1.output.body?.items?.[0]?.id

The result is undefined, instead of a runtime error, if any intermediate property is null or undefined.

Nullish coalescing

The ?? operator provides a default value when a value is null or undefined:

$vars.userName ?? "Anonymous"

Common errors

Symptom	Cause	What to do
An expression resolves to undefined	You referenced a node's output before that node runs, or a field that doesn't exist on the output	Reference output only from upstream nodes; check the node's reference page for its actual output fields. Use optional chaining (?.) for properties that may be missing.
A Decision or Switch condition behaves unexpectedly or fails	The condition isn't a bare boolean expression, for example, it's written as a return statement	Write a plain expression that resolves to true or false, for example $vars.order1.output.total > 1000. Do not use return.
Cannot find name '$vars' (or '$self')	The variable isn't in scope at this node, or $self is used on a node that produces no output of its own	Reference only variables shown in the variable picker for that node. $vars resolves to in-scope variables only; $self is available only on nodes that produce output.
A value from another node is not available to reference	Scope is upstream-only: a node cannot see downstream nodes, nodes in a sibling branch, or nodes inside a loop it has already exited	Restructure so the producing node is upstream of where you reference it, or carry the value through a variable that's in scope.
$vars.<node>.error isn't available	A node's error output is in scope only when error handling is enabled on it (or its error path is connected)	Enable error handling on the node, or connect its error handle, then reference $vars.<node>.error.
Failed to evaluate expression =js:(https://...): Unexpected token ':'	A plain value, such as a URL, is in a field set to Expression without quotes, so it is read as JavaScript	Switch the field to Fixed value, or put the text in quotes, for example "https://api.example.com/users".
{{ }} shows as literal text, or a text field does not resolve	Mode mismatch: {{ }} works only in fields set to Fixed value	Use {{ $vars.x }} only in fixed-value fields. In expression fields and in Decision and Switch conditions, write $vars.x directly with no braces.

Decision and Switch conditions run as expressions at runtime. A return statement is valid only in Script node code.

Notes

• Expressions are evaluated at runtime, not at design time. Syntax errors surface when the node executes.
• An expression in a configuration field must resolve to the type that field expects. A condition field must resolve to true or false.
• An expression field shows an = before the expression to mark expression mode. The =js: prefix that appears in a .flow file is an internal serialization format, and you never type it in the editor.
• Type checking is partial. References into outputs without a fixed structure are not fully validated, so a typo in a nested field name can pass without a warning. Compare nested paths with the output fields listed in the node reference.

Next steps

• Variables and data flow: how data moves between nodes.
• Script: write JavaScript in a node.
• Community: ask questions and share workflows with other builders on the UiPath Forum.