Anywhere a step accepts text – writing into a field, making a decision, naming a file – you can insert a variable. A variable holds whatever an earlier step produced: a value you typed, a scraped value, an Excel cell, an extracted invoice field, or a record from a loop. When the process runs, Automize replaces the variable with its current value.

1. Inserting a variable

Wrap the variable's name in curly braces:

{firstName}        → Cedric
{invoiceTotal}     → 1234.56

The name must match the variable exactly – variable names are case-sensitive, so {Total} and {total} are different.

Note: If a token can't be matched to a variable, it's left in place unchanged (and logged as unreplaced) rather than blanked – so a typo shows up as the literal {name} in your output.

2. Reaching inside records (nested access)

When a variable holds a record (an object with fields) or a list, you drill into it with a separator. Five separators are completely interchangeable – pick whichever reads best, though we recommend :: as the house style:

`::` (recommended)	`{invoice::supplier}`
`.`	`{invoice.supplier}`
`:`	`{invoice:supplier}`
`->`	`{invoice->supplier}`
`\|`	`{invoice\|supplier}`

All five resolve to the same value. Chain them to go deeper, and use a 0-based index to reach list items:

{invoice::lines::0::amount}        → the first line's amount
{order::customer::address::city}

Older processes may use any of the other separators – they all still work – but using :: everywhere keeps your processes consistent.

3. Keys that contain spaces or punctuation

If a field name itself contains a space, a dot, a pipe or another separator character, a bare separator can't reach it. Quote the segment, or use bracket subscript – both forms do the same thing, so pick whichever is clearer:

{record::"first name"}        → reaches the "first name" key
{record::'total (USD)'}       → single or double quotes both work
{record["first name"]}        → bracket subscript
{record::items[2]}            → mix separators and brackets
{record["nested"]["deep"]["value"]}

4. Fallbacks – the || operator

Use || inside a token to supply fallbacks. Automize tries each option left to right and uses the first one that has a real value:

{record::nickname || record::firstName}      → nickname, else firstName
{record::email || "no email on file"}        → email, else the literal text
{a::x || b::x || c::x}                        → the first of three sources that exists

Things to remember:

A quoted option ("…" or '…') is used as literal text, not looked up – perfect for a default message.
An unquoted option is a normal variable lookup.
An empty value is skipped, so {x || "fallback"} uses the fallback when x is empty.
Zero and false are real values and are not skipped – {count || "none"} returns 0 when count is 0.
|| inside quotes is literal text, not the operator.

|| is a separator and a fallback operator – it is not a "filter" pipe. {name | upper} does not upper-case anything; to transform a value, use a formula (next section).

5. Formulas and functions

Start a token with = to run a formula. Automize has a large library of spreadsheet-style functions:

{=ROUND(invoice::total * 1.15, 2)}
{=CONCAT(record::firstName, " ", record::lastName)}
{=UPPER(supplier::name)}
{=IF(invoice::total > 1000, "approve", "review")}
{=IFERROR(record::vat, 0)}

Function families include Math (ROUND, SUM, MIN, MAX…), Text (CONCAT, TRIM, LEFT, SUBSTITUTE, REGEXEXTRACT…), Date/time (TODAY, NOW, EOMONTH, NETWORKDAYS…), Logic (IF, AND, OR, SWITCH), Lookup (VLOOKUP, XLOOKUP, INDEX, MATCH), validation tests (ISNUMBER, ISEMAIL, ISBLANK…), and data/AI helpers (AI, TRANSLATE, EXCHANGE). For the full list see What calculation functions are supported.

6. When something is wrong

A process never crashes on a bad variable – instead it inserts a sentinel so you can see exactly what failed:

`#VAR!`	The variable or path doesn't exist
`#VALUE!`	Wrong type for the operation
`#NAME!`	Unknown function name
`#DIV/0!`	Division by zero
`#N/A!`	Value not available (catch with IFNA)
`#REF!`	Invalid reference
`#NULL!`	Null or empty operand

Replace a sentinel with something friendly by wrapping the risky part in IFERROR(…) or adding a || "default" fallback. See also Formula errors.

7. Good to know

{} and { } (empty or whitespace braces) are left as literal text – they are not treated as variables.
There is no escaping. {{name}} is not a way to print a literal "{name}" – avoid stray braces in ordinary text.

Built-in variables – dates, folders, environment and the current user, ready in every run.
Loop variables – the record available on each pass of a loop.
What calculation functions are supported
Process environment variables

Working with variables in RPAs