Data Transformers

Data Transformers let you run deterministic text logic on any value your agent pulls in from variables, actions, or flows—no custom code required. Use them to normalise CRM fields, branch on boolean checks, or clean up API payloads before the LLM ever sees the data.

When to use Data Transformers

Format external data (e.g. strip symbols from phone numbers or rewrite salutations) before you reference it inside prompts.
Enforce guard rails by comparing values or routing between true/false outputs.
Share the same transformation across multiple agents, Pre-conversation Actions, or flow nodes and keep everything in sync.

Open the workspace view

Open Data Transformers in any of three ways: select the Data Transformers card on an agent’s page, press Cmd/Ctrl+K and search for Data Transformers, or use Build → Data Transformers in the sidebar. The page isn’t in the default sidebar, so to use that route, add it first with Customize sidebar — see Navigating Studio. The card on an agent’s page shows a count such as 3 transformers. That count covers every transformer in your account, not only the ones that agent uses, and the card opens the same list as the sidebar page. A transformer link in a Co-pilot reply opens that transformer straight in the editor.

The page shows one card for each transformer in your account, most recently updated first. A card shows the name, a one-line description (hover to read all of it, or No description if you left it empty), and when the transformer was created and last updated. Select a card to open it in the editor, or use the menu on the card for Edit and Delete.

Use the search bar to filter by name or description. Under the cards, Show sets how many cards appear on each page (10, 20 or 50; the default is 10), and the arrows move between pages. If you have no transformers yet, or a search matches none, the page reads No Data Transformers Yet with a Create Data Transformer button.

Create or edit a transformer

Click Create Data Transformer (or use the menu beside an existing item and choose Edit).
Enter a Name (required) and an optional Description so team-members understand what the transformer does. Each name must be unique among your transformers. Saving a name that’s already taken fails with “A transformer with this name already exists in this workspace”.
Under Inputs, enter a test Value for input1. Use Add Input if the transformer needs more than one incoming value (input2, input3, and so on).
- Extra inputs have a ✕ button; input1 can’t be removed. Studio asks you to confirm (Delete Input) before it removes one.
- An input that a block’s Input still refers to can’t be removed — Studio shows “Cannot delete input2 - it is referenced by expressions”, so point that block at another input first.
- Removing an input renumbers the inputs after it (input3 becomes input2) and updates each block’s Input to match, but not references you typed into other fields, such as a Compare Value, so check those afterwards.
- A transformer with more than one input can’t be applied in-line from the variable popper, which only offers single-input transformers — use it from a Set Variable or Decision step instead. See Use a transformer in Set Variable and Decision steps.
Build the Expression Pipeline:
- Each block (e.g. expr1, expr2) represents one transformation step.
- Choose the Transformation type and set the block’s Input:
  - {{input1}} (or any {{input#}}) runs against that input’s value.
  - Any {{expr#}} lets you chain from a previous block’s output.
- Fill out the parameters that appear for the selected type (see the table below).
- Add more blocks with Add Expression or remove a block with the ✕ icon (except the first one). Studio asks you to confirm (Delete Expression) first.
  - A block that a later block’s Input still refers to can’t be removed — Studio shows “Cannot delete expr2 - it is referenced by other expressions”.
  - Each new block starts with its Input set to the block before it, so in a chain where each block feeds the next, you can remove only the last block until you point the next block’s Input somewhere else.
  - Removing a block renumbers the ones after it (expr3 becomes expr2), but Studio doesn’t rewrite references to them, so check each remaining block’s Input afterwards.
Click Run to try the full chain against your test values. The Output box shows the result of the last block so you can verify the logic. Run needs a test Value that isn’t blank for every {{input#}} named in a block’s Input — if one is empty, Studio asks you to fill it in first. If Run or Create refuses to go ahead, see If Run or Create won’t go through.
Click Create (or Update when editing). The transformer is saved and ready to use. You can apply a single-input transformer in-line in most fields where you insert a variable, and use any transformer from a Set Variable or Decision step — see Apply a transformer to variables. Editing a transformer changes it for every agent that uses it, but an agent you’ve published keeps running the version it was published with, and reads Unpublished edits, until you Publish it again (see What Waits for Publish).

Supported expression types

Transformation	Typical use cases	Key parameters
Find & Replace	Swap keywords, scrub PII, convert newlines to HTML, etc.	Search Value (required), Case sensitive (on by default — uncheck to match regardless of case) and Replace Value. This is a plain-text replace-all: every match is replaced, and the search value isn’t read as a regular expression. To match or insert a line break or tab, type two backslashes — `\\n` for a new line, `\\t` for a tab, and `\\r` and `\\s` for a carriage return and a space. A single `\n` matches the two characters backslash and `n` exactly as written, and any other pair of backslashes becomes one backslash, so to match two backslashes in a row, type four.
Substring	Extract a specific part of the text for enhanced text processing.	Start Index (required, a zero-based whole number — a negative number counts from the end of the text, so `-3` starts at the third character from the end, and a number that reaches back past the start of the text starts at the first character) and an optional Length (`1` or more; leave it blank to return everything from Start Index to the end). Both take plain numbers only — `{{…}}` references aren’t accepted in these two fields.
Search String	Find where a value appears inside the text, then branch on whether it was found at all. Returns the zero-based position of the first occurrence, or `-1` when the value is not present.	Search Value (required, accepts `{{expr#}}` references), Case sensitive (on by default — uncheck to match regardless of case).
String Length	Measure how long a value is — for example, to reject an account number that is the wrong length before calling an API.	No parameters. Returns the count as a number; empty input returns `0`.
Extract Letter (fixed)	Pull a fixed-length letter code out of free-form text — a two-letter country code, a three-letter currency or airport code — without writing a pattern.	Length (required, accepts `{{input#}}` / `{{expr#}}` references; a literal value must be a whole number of `1` or more). Returns the first run of letters whose whole length equals Length, or an empty string when no run qualifies — so a Length of `2` against `abcd` returns nothing, while `123 ab cdef` returns `ab`. Only ASCII `A`–`Z` / `a`–`z` count as letters.
Extract Letter (min–max)	Pull a letter code whose length you only know roughly — a reference prefix, a product code — out of a transcript by letter count, ignoring shorter and longer words around it.	Min Length (required), Max Length (optional — leave blank for no upper bound); both accept `{{input#}}` / `{{expr#}}` references, and literal values must be whole numbers of `1` or more with Min Length no higher than Max Length. Returns the first letter run whose whole length fits the range, or an empty string — with a minimum of `2` and a maximum of `3`, `a bc defg hij` returns `bc`. Same ASCII-only rule as Extract Letter (fixed).
Extract Email	Pull the first email address out of free-form text — a spoken sentence, a `Name <email>` header — without writing a pattern.	No parameters. Returns the first address found, or an empty string when there is none.
To UpperCase	Normalise a name, code or answer to capital letters — for example before a Compare step, or when an API expects capitals.	No parameters. Converts every letter to upper case and leaves everything else as it is.
To LowerCase	Normalise a value to small letters — an email address, a keyword — before comparing it or passing it on.	No parameters. Converts every letter to lower case and leaves everything else as it is.
Extract Number (fixed)	Pull a fixed-length number out of free-form text — a four-digit passcode, a six-digit reference — without writing a pattern.	Length (required, accepts `{{input#}}` / `{{expr#}}` references; a literal value must be a whole number of `1` or more). Returns the first run of digits whose whole length equals Length, or an empty string when no run qualifies — so a Length of `3` against `raj123 10/2019` returns `123`, and `2019` is skipped because it has four digits. Only the digits `0`–`9` count.
Extract Number (min–max)	Pull a one-time passcode, account number, or reference code out of a transcript by digit count, ignoring shorter and longer runs such as years or street numbers.	Min Length (required, `1` or more), Max Length (optional — leave blank for no upper bound); both accept `{{expr#}}` references. Returns the first digit run whose whole length fits the range, or an empty string.
Arithmetic	Work out a value from two numbers — add a surcharge, scale a quantity, take a remainder to bucket a reference. Generates a value rather than transforming one, so the block has no Input field.	Operator (Add (+), the default, plus Subtract (−), Multiply (×), Divide (÷) and Modulo (%)), Value 1 and Value 2 — all three required. Values may be whole or decimal and may be negative, and each accepts `{{input#}}` / `{{expr#}}` references, including text that mixes literal digits with a reference. The result is plain text: `2` add `3` is `5`, `4` multiplied by `2.5` is `10`, `9` divided by `2` is `4.5`, and floating-point noise is cleaned up so `0.1` add `0.2` gives `0.3`. Dividing or taking a remainder by zero is rejected when the value is literal. A referenced value that resolves to blank or non-numeric text counts as `0`, so the only time Arithmetic fails at run time is a zero divisor.
Random Number	Generate a random whole number — a verification code, a randomised queue position, a sampling bucket. Generates a value rather than transforming one, so the block has no Input field.	Min Value and Max Value (both required, inclusive of both bounds). Bounds may be negative and each accepts `{{input#}}` / `{{expr#}}` references, including text that mixes literal digits with a reference. Literal bounds are validated on save; at run time a bound that resolves to blank or non-numeric text counts as `0`, and a resolved minimum above the maximum returns `0`.
Pad String	Pad a value out to a fixed width — zero-fill a reference number, right-align a figure to a column width, or pad a code before handing it to an API.	Pad From (Left, the default, or Right), Pad Character (required — exactly one character; a single space is valid and is never trimmed away) and Target Length (required — a whole number from `1` to `100,000`). Both Pad Character and Target Length accept `{{input#}}` / `{{expr#}}` references. Input already at or beyond Target Length is returned unchanged — this transformation only pads, it never truncates — and an empty input is padded out to the full target length. A pad character longer than one character is rejected rather than cut short.
Round Number	Round a value to at most a given number of decimal places — a price to two decimals, a percentage to one.	Rounding (Round (nearest), the default, Floor (down) or Ceil (up)) and Precision (a whole number from `0` to `100`, or an `{{input#}}` / `{{expr#}}` reference; blank means `0`, a whole number). Trailing zeros are not added: `1.1` at a Precision of `2` stays `1.1`, so chain Pad String when you need a fixed display width. A blank or non-numeric input is treated as `0`.
Trim String	Strip stray characters from a value before it reaches a prompt or an API call — trailing whitespace from a pasted field, or an unwanted wrapping character.	Trim From (Both Ends, the default, Start Only or End Only) and Characters to Trim (leave blank to strip space, tab, newline, carriage return, NUL and vertical tab; anything you enter replaces that default set). Each character you list is stripped on its own, so `,.` strips commas and periods rather than the sequence `,.`. Unlike Find & Replace, a single backslash is enough here — `\t` for a tab, `\n` for a new line, `\r`, `\v`, `\0` and `\s` (a space), and `\\` for a backslash. Unicode spaces such as a non-breaking space aren’t in the default set, so list them if the input needs them stripped.
Regex Extract	Pull a matching portion of text using a regular expression. Useful for extracting dates, IDs, emails, or any structured fragment from free-form input. Returns an empty string when the pattern does not match.	Pattern (required), optional Flags (tick `/i` for case-insensitive, `/m` for multiline), Match index (`0` = first match, `1, 2…` = nth match, `-1` = last match), Match group (`0` = whole match, `1, 2…` = numbered capture group).
Matches Regex	Answer yes or no on whether the text matches a pattern, then gate a Decision node or a Conditions step on the result.	Pattern (required, accepts `{{expr#}}` references), optional Flags `/i` (case-insensitive) and `/m` (multiline). Returns `true` or `false`.
Datetime	Turn a date and time — an appointment slot, a timestamp from your CRM — into a number, so a Compare step can tell which of two moments comes first.	Format (required — prefilled `yyyy-MM-dd HH:mm:ss`; the help icon beside it lists the supported tokens, which Date formats and timezones repeats with examples) and Timezone (the zone the input’s clock time is in, `UTC` by default). Returns a Unix timestamp in milliseconds (UTC). Set Format to `ISO` for ISO 8601 input, `X` for a timestamp in seconds or `x` for one in milliseconds. An offset in the input, such as `+11:00` or `Z`, takes precedence over Timezone when the format reads it — see Behaviour worth knowing.
Date	Compare calendar days and ignore the time of day — a date of birth, a due date, a delivery day.	Format (required — prefilled `yyyy-MM-dd`). There is no timezone: the result is midnight UTC on the date as written in the input, as a Unix timestamp in milliseconds. Any time or offset in the input is dropped, though the Format must still match it — `2025-12-09T10:23:56+11:00` with a Format of `ISO` gives midnight UTC on 9 December 2025. Accepts the same `ISO`, `X` and `x` formats as Datetime; for a timestamp, the day is taken in UTC.
Date Offset	Move a date forward or back — to check whether an appointment is less than a week away, or whether a renewal falls due in the next 30 days.	Format (required — prefilled `yyyy-MM-dd`) and Timezone (`UTC` by default) read the incoming date the same way Datetime does. Then Action (After (+), the default, or Before (−)), Value (a whole number of `0` or more, prefilled `1`, or an `{{input#}}` / `{{expr#}}` reference) and Unit (Hours, Days — the default — Weeks, Months or Years), all three required. Returns a Unix timestamp in milliseconds (UTC), like Datetime, so the result can go straight into Compare: `2026-01-01` with a Format of `yyyy-MM-dd`, Timezone `UTC`, `After (+)`, `7` and `Days` gives `1767830400000`, which is 8 January 2026 at 00:00 UTC.
Compare	Turn comparisons into explicit `true`/`false` answers (e.g. numeric thresholds, matching strings). The block’s Input is the left-hand side.	Operator (Equal To, the default, Not Equal To, Less Than, Greater Than, Less Than or Equal To or Greater Than or Equal To), Value (the right-hand side of the comparison; accepts `{{input#}}` / `{{expr#}}` references) and Case sensitive (on by default; it only affects text comparisons). When both sides are plain numbers they are compared as numbers; otherwise they are compared as text — see Behaviour worth knowing.
Conditions	Combine two values with `AND` or `OR`. Ideal for gating Pre-conversation Actions and other steps. Returns `true` or `false`.	Operator (`AND`, the default, or `OR`) and Condition — the second value to combine with the block’s Input, usually an `{{expr#}}` reference. Both values are read as true or false by the rule in Behaviour worth knowing.
Ternary Operator	Return one of two messages depending on whether the incoming value counts as true or false.	True Output and False Output — both required, so neither can be left blank (a single space doesn’t count). Each accepts text and `{{input#}}` / `{{expr#}}` references. The block’s Input is read as true or false by the rule in Behaviour worth knowing; True Output is returned for true and False Output for false.

You can mix and match types inside the same pipeline. Every block outputs plain text, so downstream steps (and the agent) can read the result immediately.

Empty inputs are handled gracefully. If an input value is empty — or an expression references an input that was never supplied — the reference resolves to an empty string and the pipeline keeps running, instead of failing the transformation. This means transformers attached to optional variables (for example, a CRM field that is sometimes blank) no longer need guard expressions just to survive missing data. Pad String is the one exception: an empty input comes out as a full-length run of the pad character rather than as an empty string. In the editor, Run needs a test Value that isn’t blank for each input a block’s Input refers to, so you can’t try blank handling out there.

Behaviour worth knowing

Extract Number (fixed) and Extract Number (min–max) match on the whole run of digits. With a Length or Max Length of 3, a four-digit run such as 2019 is skipped entirely rather than clipped to 201 — so a date in the text will not be mistaken for a 3-digit code.
String Length counts characters the way software does, not the way the eye does: an emoji counts as 2.
Pad String counts length in whole characters, while String Length counts the way software does — an emoji is one position to Pad String and 2 to String Length. Chaining String Length into the Target Length of a Pad String block will therefore not line up on emoji or other astral characters.
Pad String accepts an emoji or an accented letter as a pad character, but rejects one built from several code points — a combining accent, or a multi-person emoji such as 👨‍👩‍👧 — rather than padding by visual clusters.
Extract Email covers everyday addresses. It does not match accented or non-Latin local parts, quoted local parts, or intranet addresses without a dot (user@localhost).
Regex Extract caps the work a pattern can do — input up to 100,000 characters, patterns up to 1,000 characters, and up to 10,000 matches — and returns a clear error rather than stalling if a pattern exceeds them.
Modulo (%) truncates both values to whole numbers first, and the sign of the result follows the first value: -7 modulo 3 is -1, not 2; 7 modulo -3 is 1; and 10.9 modulo 3.9 is 1.
Compare treats a side as a number only when it is a plain number: an optional minus sign, digits, and an optional decimal part, such as 42, -7 or 3.14 (spaces around it are ignored). Anything else, including 1,000, $50, +5, .5, 1e3 and 10 kg, is text. If both sides are plain numbers, Compare compares them as numbers, so 10 is greater than 9 and Case sensitive makes no difference. If either side is text, it compares both as text, so Less Than and Greater Than follow alphabetical order and Case sensitive applies: $10 is less than $9, because 1 comes before 9. To compare amounts such as $50, strip the symbol first (for example with Find & Replace).
Conditions and Ternary Operator decide true or false the same way, ignoring capitals and any spaces around the text. These count as true: true, yes, y, 1, any other number that isn’t zero, and any other text at all. These count as false: false, no, n, 0 (and 00 or 0.0), and a blank value. So a status word such as active counts as true, and so do none, null and off. If you need an exact match, run a Compare or Matches Regex step first and feed its true or false result into Conditions or Ternary Operator.
The two Extract Letter transformers match on the whole run of letters, exactly as the two Extract Number transformers do with digits — a run that is too long is skipped rather than clipped. Only ASCII letters count, so digits, spaces and punctuation end a run, and accented or non-Latin letters are not letters at all.
Round Number sends an exact half away from zero (-2.5 rounds to -3), while Floor (down) and Ceil (up) go toward negative and positive infinity (-2.1 floors to -3). A blank or non-numeric input counts as 0 rather than failing the chain.
Unlike Random Number, which never fails a chain, the Extract Letter and Extract Number transformers, Round Number and Pad String do fail the expression at run time if a referenced parameter resolves to an invalid number — a length or bound that isn’t a whole number of 1 or more, a Precision that isn’t a whole number from 0 to 100, a range whose bounds are the wrong way round, or — for Pad String — a pad character that is blank or longer than one character. Arithmetic is more forgiving: it fails only on a zero divisor, because a blank or non-numeric reference counts as 0. An empty result from an Extract Letter or Extract Number transformer is not a failure — it simply means no run matched. What the agent receives when a transformer fails during a conversation is covered in When a transformer fails during a conversation.
Datetime, Date and Date Offset return a millisecond timestamp, not a date to read out to a caller. When one of them is the last block and you click Run, the Output box shows the result as a readable UTC date — 2026-01-08T00:00:00Z, or 2026-01-08 for Date — but a later block, and your agents, flows and actions, always receive the number. Use these results for comparisons.
Date Offset month and year steps stop at the end of a shorter month: 31 January plus one month and 31 March minus one month both give 28 February (29 in a leap year).
Date Offset in Days, Weeks, Months or Years keeps the local clock time across a daylight-saving change in the selected Timezone, while Hours counts elapsed time. From 09:00 on the day before the clocks go forward, one day later is 09:00, but 24 hours later is 10:00. An input that carries its own offset, such as +11:00, stays on that fixed offset instead, with no daylight-saving adjustment.
An offset in the input, such as +11:00 or Z, takes precedence over Timezone in Datetime and Date Offset only when the Format reads it — with a Z, ZZ or ZZZ token, with ISO, or, for a trailing Z only, with a quoted 'Z'. Otherwise, input that carries an offset doesn’t match the format and the block fails.
With a date-only Format, Date Offset and Datetime read the date as midnight in the selected Timezone, whereas Date always uses midnight UTC. Keep Timezone on UTC when you compare a Date Offset result with a Date result, or the two will be hours apart.
A literal Value in Date Offset that isn’t a whole number of 0 or more is rejected when you save or run. A referenced Value that resolves to blank, a decimal, a negative number or text counts as 0, so the date passes through unchanged rather than failing the block.
To offset a value that is already a timestamp — the output of an earlier Datetime block, for example — set Format on the Date Offset block to x (milliseconds) or X (seconds).
For all three date transformers, input that doesn’t match the Format fails the block with an error saying so, and a blank input returns a blank result. A later Compare treats a blank result as text rather than a number, so a missing date can still come out true — if the date can be blank, check for that first. Use yyyy for the year: YYYY is rejected.
The Co-pilot can add date steps, but only in a fixed set of formats: yyyy-MM-dd or dd/MM/yyyy for Date; yyyy-MM-dd HH:mm:ss, yyyy-MM-dd'T'HH:mm:ss or yyyy-MM-dd'T'HH:mm:ssZ for Datetime; and any of those five for Date Offset. For ISO, a timestamp or any other format, edit the block’s Format yourself.

Date formats and timezones

Datetime, Date and Date Offset read the incoming text using the Format you write, and the text has to match the format exactly. Click the help icon beside Format to see this list in Studio.

Part	Tokens	Reads
Year	`yyyy`, `yy`, `y`	`2025` for `yyyy`, `25` for `yy`
Month	`MM`, `M`, `MMM`, `MMMM`	`03` for `MM`, `3` for `M`, `Mar` for `MMM`, `March` for `MMMM`
Day	`dd`, `d`	`05` for `dd`, `5` for `d`
Weekday	`ccc`, `cccc`	`Fri` for `ccc`, `Friday` for `cccc`
Hour	`HH`, `H` for a 24-hour clock; `hh`, `h` for a 12-hour clock	`14` for `HH`, `02` for `hh`
Minute	`mm`, `m`	`05` for `mm`, `5` for `m`
Second	`ss`, `s`	`09` for `ss`, `9` for `s`
AM or PM	`a`	`PM` — use it with `hh` or `h`
Offset	`Z` or `ZZ`, `ZZZ`	`+11:00` for `Z` and `ZZ`, `+1100` for `ZZZ`
Literal text	Wrap it in single quotes	`'T'` reads a letter T

You can type a space, -, /, :, . and , as they are. Wrap any other letters in single quotes, such as the T in yyyy-MM-dd'T'HH:mm:ss. These examples all describe 21 November 2025:

Format	Reads text like
`yyyy-MM-dd`	`2025-11-21`
`dd/MM/yyyy`	`21/11/2025`
`yyyy-MM-dd HH:mm:ss`	`2025-11-21 14:30:00`
`yyyy-MM-dd'T'HH:mm:ss`	`2025-11-21T14:30:00`
`yyyy-MM-dd'T'HH:mm:ssZ`	`2025-11-21T14:30:00+11:00`
`ISO`	`2025-11-21T14:30:00Z`
`MMM dd, yyyy h:mm a`	`Nov 21, 2025 2:30 PM`

Timezone, on Datetime and Date Offset, is the same picker as the Timezone card in an agent’s settings. Select it to open a list with Search timezones ready to type in. Type part of a region or city name to find a zone; a name with a space in it, such as “new york”, finds America/New_York. An abbreviation such as PST, EST, CST or MST puts the matching North American zones first, and UTC or GMT puts UTC first. Other abbreviations, such as IST, AEST or BST, aren’t recognised, so search by city or region instead. The zone in use has a tick and the list opens scrolled to it, and a search that finds nothing says No timezone found. Each entry shows the zone name, its offset today and its full name, for example Asia/Tokyo (+09:00) Japan Standard Time. UTC is the default. The offset in the label is only a guide; the transformer applies the offset that was in force on the date it’s reading, so daylight saving is taken into account.

Tips for complex pipelines

Use descriptive descriptions so future editors understand why a pipeline exists.
When chaining expressions, double-check each block’s Input field; expr2 defaults to the previous block, but you can point it at any earlier result.
Clicking Run often helps you catch whitespace or case-sensitivity issues before anyone attaches the transformer to production prompts.

If Run or Create won’t go through

Run and Create (or Update) make the same checks first. Studio shows only the first problem it finds, as a pop-up message, so fix it and try again to see whether anything else is left. The usual causes:

The Name is blank. Create (or Update) stays greyed out until you enter one, and Run needs a name too.
A block has no Transformation chosen, or its Input is blank — for example “expr1: Input source is required”.
A required parameter is missing or not valid — for example “expr1: Search value is required for Find & Replace” or “expr2: Pad Character must be a single character”.
A block refers to something that doesn’t exist, such as {{input3}} when you have two inputs (“expr1: Invalid reference “input3”. Must reference an input or expression.”), or to itself or a block that comes after it (“expr2: Expression reference expr3 is invalid (must reference a previous expression)”). This applies to a block’s Input and to most of the parameter fields that accept references, such as Search Value or Value.
Run only: a test Value is blank for an input that a block’s Input refers to. Studio says “Input source “input1” is empty. Please enter a test value for input1 to run the transformation.” Blank values are fine when the transformer runs in a live conversation (see the note above), but not in the editor’s Run.
The pipeline itself fails on your test values — for example a date that doesn’t match its Format. Studio shows the error as a pop-up message and the Output box stays empty.

Apply a transformer to variables

In most text fields that accept variables — for example Guidelines, Greeting & Sign-off, a Say message or an API request — you can apply a transformer in-line. Choose the transformer first, then the variable:

Type {{ to open the variable popper.
Tick Apply data transformation at the bottom of the popper.
Choose the transformer from the Select transformer dropdown. It lists transformer names only, and stays greyed out until the box is ticked. It reads No transformers available if you don’t have any single-input transformers.
Click the variable you want, or arrow down to it and press Enter. The inserted snippet renders as [TransformerName({{variableName}})], and the stored value includes the transformer ID so the platform can run the pipeline automatically.

The popper inserts a variable the moment you click it and then closes. If you click the variable first — or tick Apply data transformation but leave Select transformer empty — you get the plain {{variableName}} with no transformation. Delete it and insert it again in the order above.

A few things to know:

The Select transformer list only offers transformers with exactly one input. A transformer you built with Add Input (two or more inputs) never appears there — use it from a Set Variable or Decision step instead, as described below.
Action references can’t be transformed. Ticking Apply data transformation hides the ACTIONS group in the popper, and the option isn’t available while you’re inserting an action reference in Guidelines.
The option isn’t offered in the fields of Set Variable and Decision steps, or in the fields of the transformer editor itself.

This works for system, interaction, and custom variables. On execution the platform pushes the transformed value into the agent prompt, HTTP request body, or wherever the variable lives.

Use a transformer in Set Variable and Decision steps

The Set Variable and Decision steps in a flow list your transformers, including those with several inputs. Like the Data Transformers page, they show the 100 most recently updated. For each input (input1, input2, and so on) you give a value, which can include {{variables}}. See In-conversation Actions for the flow editor, including the Set Variable Node and Decision Node.

Set Variable — pick the variable, then choose the transformer in the Transformation Logic dropdown (the other choice is Static Value). The transformer’s result is stored in the variable.
Decision — in a condition, choose the transformer under Condition Rule and fill in the Input Values. The condition matches when the transformer’s result is true, so end the pipeline with a step such as Compare, Matches Regex or Conditions.

When a transformer fails during a conversation

A transformer that passed Run can still fail on real data — for example a referenced length that turns out to be text, or a zero divisor. The conversation carries on; what the agent gets depends on where the transformer is used and how many inputs it has.

Applied in-line to a variable — a variable that has no value at all comes out as empty text, and the transformer isn’t run. If the transformer runs and fails, the agent gets the variable’s original, untransformed value.
Set Variable — with a single-input transformer, a failure stores the original input value in the variable. With two or more inputs nothing is stored: the assignment is skipped and the flow keeps going.
Decision — with a single-input transformer, a failure hands the original input to the condition, which matches only if that input is itself true. With two or more inputs the condition counts as not matched, and the Decision moves on to its next condition (or Otherwise).

Try your transformer with Run, including awkward values such as text where a number belongs, before you attach it to a live agent.

Manage safely

Usage-aware deletion – clicking Delete runs a usage check first. If the transformer is referenced by any agent, action, or flow node you will see a detailed report and deletion is blocked until you remove those references. See Deleting a transformer.
Instant search – the list loads up to 100 transformers, most recently updated first, and filters them in your browser as you type, so there are no extra round trips. If you keep more than 100, the least recently updated ones don’t appear in the list or in search, and the Set Variable and Decision steps don’t offer them either.
Exports & clones – AI Agent exports, imports and duplicates automatically carry along any referenced transformers and rebuild usage links in the target workspace. Duplicate links the copy to the original agent’s transformers instead of copying them, so editing a transformer changes both agents (each one that has been published reads Unpublished edits until its next Publish). Importing into the workspace the agent was exported from does the same, and creates again any transformer that has since been deleted. Importing into a different workspace reuses a transformer whose Expression Pipeline is exactly the same, even under a different name, and creates any other as a new transformer, adding _(2) to its name if the name is taken.

Deleting a transformer

Choose Delete from the menu beside a transformer. Studio first checks where it is used, and the menu item reads Checking… while it does. If the check can’t be completed, Studio asks you to try again and deletes nothing.

Not in use — a Delete Data Transformer window asks you to confirm. Select Delete (or Cancel to keep it) and the transformer is removed. This can’t be undone.
In use — a Data Transformer In Use window says how many items still use it and lists them, grouped under AI Agents, Pre-conversation Actions, Post-conversation Actions and Flow Nodes. Each entry shows the item’s name and a Fields list of where the transformer is used. Actions and flow nodes also show the AI agent they belong to, and flow nodes show their flow. Deletion is blocked until you remove those references. Select Close, point each item at a different transformer (or remove the transformation), then delete again.

Anything that holds the transformer counts as a reference: an agent’s own fields such as Guidelines or Greeting & Sign-off (wherever you applied it in-line), a pre-conversation or post-conversation action, or any step in a flow, including Set Variable and Decision steps. The platform repeats the check when the delete goes through, so a delete that races someone wiring the transformer into a flow at the same moment is refused too. In that case Studio shows “Failed to delete data transformer” and the transformer stays in your list. You can also ask the Co-pilot to delete a transformer. It shows a card that names the transformer and warns that deletion can’t be undone, and deletes it only after you select Delete transformer (Cancel leaves it in place). The same rule applies: if an agent still uses the transformer, the Co-pilot refuses and tells you what’s using it, so remove those references first.

AI Agents

Inject transformed values into greetings, guidelines, and agent settings.

Pre-conversation Actions

Combine transformers with API responses before a call starts.

Get Started

Build

Campaigns

Optimize

Manage

Best Practices

Library

Telephony

Product

Trust & Security

When to use Data Transformers

Open the workspace view

Create or edit a transformer

Supported expression types

Behaviour worth knowing

Date formats and timezones

Tips for complex pipelines

If Run or Create won’t go through

Apply a transformer to variables

Use a transformer in Set Variable and Decision steps

When a transformer fails during a conversation

Manage safely

Deleting a transformer

AI Agents

Pre-conversation Actions

When to use Data Transformers

Open the workspace view

Create or edit a transformer

Supported expression types

Behaviour worth knowing

Date formats and timezones

Tips for complex pipelines

If Run or Create won’t go through

Apply a transformer to variables

Use a transformer in Set Variable and Decision steps

When a transformer fails during a conversation

Manage safely

Deleting a transformer

Related pages

AI Agents

Pre-conversation Actions