Node Reference
Complete reference for every node in the flow builder: fields, defaults, and outputs.
This is the complete catalog of nodes you can drop onto a flow canvas, in the order the palette lists them. For each node you'll find its purpose, the fields in its configuration panel, and the outputs it produces. Nodes with more than one output are branching nodes — they pick one output at run time and execution continues down whatever you wired to it. Nodes with a single output just pass control to the next node.
Every node's panel starts with a Label and a Description, which name the box on the canvas and remind you what it does. Fields throughout accept the {{ }} syntax — see Variables & Expressions. For assembling nodes into a working flow, see Building Flows.
Palette groups
- Flow Control — Start, End, Condition, Switch, Loop
- Data — HTTP Request, Transform, Status Map, XML Parse, Crypto, Set Variable
- Utility — Delay, Log, Format Message
Start
Purpose: the entry point of every flow. It receives the flow's input and passes it through unchanged. A flow has exactly one Start node and always begins there; the builder refuses to save a flow with none, or with more than one.
Fields: none beyond the label and description.
Output: the flow's input, forwarded to the next node. Single output.
End
Purpose: the exit point. It returns the final result. A flow may have several End nodes — one on a success branch, one on an error branch — and whichever is reached first ends the run.
| Field | What it does |
|---|---|
| Output Mode | Passthrough (return all input data), JSON Template (with variables), or Field Mapping (path-based). |
| Output JSON | Shown in JSON Template mode. A JSON object whose values may use {{ }} — this becomes the flow's result. Invalid JSON is flagged and not saved into the node. |
| Output Fields | Shown in Field Mapping mode. Pairs of output field name and the path in the input or variables to read it from. |
| Status Code (for webhooks) | Optional. When set, the result is wrapped so the webhook replies with that HTTP status and the output as its body. Must be between 100 and 599. |
In Passthrough mode, End simply returns whatever reached it.
Output: the flow's result. End terminates the run.
Condition
Purpose: if / else branching. Evaluates one or more conditions and routes to true or false.
| Field | What it does |
|---|---|
| Logic | How multiple conditions combine: and (all must pass, the default) or or (any one). |
| Conditions | A list of rows. Each row has a field (an expression or path, for example input.status), an operator, and a value to compare against. String values may use {{ }}. |
Operators: Equals, Not Equals, Strict Equals (===), Strict Not Equals (!==), Contains, Not Contains, Starts With, Ends With, Regex Match, Greater Than, Greater Than or Equal, Less Than, Less Than or Equal, In List, Not In List, Is Empty, Is Not Empty, Is True, Is False, Exists, Not Exists.
In List and Not In List accept an array or a comma-separated list. Is True also matches the text true and the number 1; Is False matches false and 0. Regex Match rejects patterns that are excessively long or built to backtrack catastrophically, and treats such a pattern as no match.
The builder will not save a Condition node with no conditions. At run time, a node that somehow has none routes to true.
Outputs: true and false. The input passes through unchanged to whichever branch is taken.
Switch
Purpose: multi-way branching on a single value — cleaner than chaining many Conditions. The classic use is routing inbound webhook events by event type.
| Field | What it does |
|---|---|
| Switch On Field | The expression whose value is matched, for example input.webhook.body.type. Required. |
| Match Operator | Equals (the default), Contains, Starts With, Ends With, In List or Regex Match. |
| Cases | A list of rows, checked in order — the first match wins. Each row has a value to match (which may use {{ }}), a handle that names the output connector for that case, and an optional label. Every case needs a handle, and two cases may not share one. |
| Default Handle | The output used when no case matches. Defaults to default. |
Outputs: one per case, each named by its handle, plus the default. The input passes through unchanged.
Loop
Purpose: iterate over an array. For each item the flow runs whatever you wired to body; when every item is done it runs complete.
| Field | What it does |
|---|---|
| Source Array | The array to iterate, for example {{ http-request.data.items }}. Required. |
| Item Variable Name | The variable holding the current item inside the body. Default item. |
| Index Variable Name | The variable holding the current zero-based position. Default index. |
| Max Iterations | How many items to process. Default 1000; the platform caps it at 10,000 however high you set it, and at least 1. |
If the source isn't an array, or is empty, no iterations run and the flow goes straight to complete.
Outputs: body (once per item, with the item and index variables set) and complete (after the last item; it receives the collected results of every iteration).
HTTP Request
Purpose: call an external API through one of your plugin's connections, then route by success or error. This is the workhorse of most plugins.
| Field | What it does |
|---|---|
| Connection | The connection to send through, carrying the base URL and authentication. Required — the builder blocks a save without one. |
| Connection Slug Override | Optional. Addresses a connection by slug instead, and supports {{ }} — for example {{config.mode}}-api to switch between a sandbox and a live connection. Takes precedence over the selected connection. |
| Method | GET, POST, PUT, PATCH or DELETE. Default GET. |
| Path | Appended to the connection's base URL. Supports {{ }} — for example /servers/{{ input.serverId }}/status. Required. Leave it empty only for a connection whose base URL is already the complete endpoint. |
| Body Type | Shown for POST, PUT and PATCH. JSON Object (default), or Raw String to author the whole body as one template string that is substituted and then parsed. |
| Request Body | Shown for POST, PUT and PATCH. The payload; values support {{ }}. |
| Omit empty/unresolved-template keys from body | A checkbox. Drops body keys whose templated value came out empty or unresolved — useful for optional fields a provider rejects when blank. Fixed literal values are always kept. |
| Custom Headers | Extra request headers; values support {{ }}. The connection's own authentication headers are added for you. |
| Response Mapping | Optional. Pairs of output field name and a path into the response, reshaping the result into named fields. Prefix a path with response. to read the status or headers instead of the body. |
Put {{ }} anywhere in the path, headers or body to inject input, configuration or an earlier node's output. Base URL, authentication, timeouts, retries and the safety checks on the target address all come from the connection — see Connections & Authentication.
Outputs: success when the response indicates success, otherwise error. The success output carries the (optionally mapped) response data; the error output carries an error message. A request whose path resolves to an internal or private address is refused and takes the error branch.
Transform
Purpose: reshape data by mapping source values onto target fields, optionally applying a conversion to each value as it is copied.
| Field | What it does |
|---|---|
| Mode | Merge with input (the default) starts from the incoming data and adds or overwrites the mapped fields; Replace (only mapped fields) starts from an empty object. |
| Mappings | A list of rows, each described below. |
| Field | What it does |
|---|---|
| Source Path | Where to read the value from. A plain path such as http-1.data.status, or a {{ }} expression. Clicking the field also lets you pick a path from the response tree. |
| Target Field | Where to write it in the output. Dotted paths create nested objects. |
| Default (if source is empty) | Used when the resolved value is missing. |
| Transform | An optional conversion applied to the value (list below). |
| Expression | An expression that computes the value directly instead of reading a source path — for example value * 2, or an array method whose result you then convert with a Transform. |
Transforms available in the dropdown: toString, toNumber, toBoolean, toUpperCase, toLowerCase, trim, length, first, last, reverse, unique, flatten, sort, toJson, parseJson, keys, values, toISOString, toTimestamp, abs, ceil, floor, round, urlEncode, urlDecode, split, join, slice, replace, map, filter, find, pad, coalesce, template, enrichArray, flattenVersions, math.
Most take no parameters. Those that do read them from the mapping's own settings, and their defaults are: split and join use a comma; slice starts at 0; replace takes a pattern, flags (g) and a replacement; map, filter and find take a field name (and, for the latter two, a value to match) so they need no callback; pad defaults to length 10 with spaces added at the end; coalesce takes a list of paths and a fallback; template renders a string with {{ }} plus the current value; enrichArray adds computed fields to every item; flattenVersions flattens a list of parents each holding a nested versions array; and math takes an operation (add, subtract, multiply, divide, modulo, power) and an operand.
Output: the assembled object. Single output.
Status Map
Purpose: declaratively map an external value onto an internal one — a provider's status string onto the platform's status, say. Cleaner than nested conditionals.
| Field | What it does |
|---|---|
| Source Field | The expression to read the value from, for example http-request.data.status. Required. |
| Mappings | The lookup table: each row is one external value and the internal value it becomes. At least one row is required. |
| Default Value | Returned when no row matches. Default unknown. |
| Output Field Name | The key the mapped value is written to. Default status. |
| Pass through input data | On by default: the mapped field is merged onto the incoming data. Off: the output contains only the mapped field. |
Output: the input with the mapped field added, or just the mapped field when passthrough is off. Single output.
XML Parse
Purpose: turn an XML response string into an object, so the same {{ node.field }} references that work for JSON APIs work for XML-only ones. Drop it straight after an HTTP Request whose provider answers in XML.
| Field | What it does |
|---|---|
| XML Source | The expression yielding the raw XML, for example {{http-request.data}}. Leave it blank to parse whatever reached the node. |
| Unwrap single root element | On by default. When the document has one root element, its contents are lifted to the top so fields are reachable directly rather than through the root's name. |
| Root Tag | Optional. Names the element to unwrap explicitly, overriding the automatic detection. |
| Output Field | Optional. Nests the parsed object under this key instead of spreading it at the top level. |
| Coerce numbers & booleans | On by default. Converts leaf text such as 123 or true into a number or boolean. Values that would not survive the round trip — a leading-zero code like 007 — stay text. |
| Merge with input | Off by default. When on, the parsed fields are merged on top of the incoming data so the HTTP status and other fields remain available. |
Repeated sibling elements become arrays, attributes are exposed under their own keys, and CDATA and character entities are decoded. If the source is already an object it passes through unchanged.
Outputs: success with the parsed object, or error when there is nothing parseable.
Crypto
Purpose: compute a hash, an HMAC signature, an AES cipher or a base64 encoding — the things a provider's request-signing scheme needs and expressions deliberately cannot do. The result is referenced downstream as {{ <node-id>.result }}.
| Field | What it does |
|---|---|
| Operation | Hash (MD5/SHA), HMAC signature, AES encrypt, AES decrypt, Base64 encode or Base64 decode. The remaining fields change to suit. |
| Algorithm | For hashing and HMAC: md5, sha1, sha256 (the default) or sha512. For AES: a cipher name such as aes-128-cbc (the default) or aes-256-cbc. |
| Data | The input, as a template — for example {{config.merchant_id}}|{{input.amount}}. |
| Key | The HMAC or AES key, as a template. Required for HMAC and both AES operations; the builder blocks a save without it. |
| Key Encoding | How to read the key bytes: utf8 (raw string), hex, base64, or md5 (the key's MD5 digest, which some gateway schemes require). |
| IV and IV Encoding | For AES in CBC mode. Encoding is hex by default, or utf8 or base64. Not needed for ECB. |
| Input Encoding | How the data is read. utf8 for hashing, HMAC and AES encrypt; hex for AES decrypt. |
| Output Encoding | How the result is written: hex (default) or base64; utf8 for AES decrypt and base64 decode. |
| Upper-case result | Upper-cases a hex or base64 digest, which some signature schemes demand. |
| Output Field | The key the result is written to. Default result. |
Outputs: success with the incoming data plus the computed field, or error. The builder warns (but still saves) when the Data field is empty, since the node would then sign an empty string.
Set Variable
Purpose: store computed values in flow variables so later nodes can reference them by name.
| Field | What it does |
|---|---|
| Variables | A list of name and value rows. A value that is exactly one {{ }} placeholder keeps its raw type; a value with placeholders inside text becomes a string; anything else is stored as written. Rows with no name are skipped, and the builder requires a name on every row. |
Output: the input, unchanged. Single output. The variables you set are available to every node downstream.
Delay
Purpose: pause the flow before continuing — useful when a provider needs a moment before the resource it just created can be queried.
| Field | What it does |
|---|---|
| Delay (milliseconds) | How long to wait. Capped at 300,000 (five minutes); 0 continues immediately. |
Note: a delay counts against the flow's own execution timeout, which is 30 seconds unless you raised it in Flow Settings.
Output: the input, passed through after the wait. Single output.
Log
Purpose: write a message, and optionally some extracted values, into the run's trace, to help you see what a flow is doing while you build it.
| Field | What it does |
|---|---|
| Log Message | The message to record. Supports {{ }}. |
| Level | Debug, Info (the default), Warning or Error. |
| Data to Extract | Optional pairs of a name and a path; each path is read and recorded under that name alongside the message. |
Output: the input, unchanged. Single output. The message appears in the Execution Trace, subject to the same redaction and truncation as the rest of the trace.
Format Message
Purpose: build a message from a template and shape it for a particular channel. Typically used in a notification flow just before the HTTP Request that delivers it.
| Field | What it does |
|---|---|
| Format | Plain Text (default), Markdown, HTML, Slack Blocks, Discord Embed or Telegram. |
| Title | Optional heading, used by the block and embed formats. Supports {{ }}. |
| Message Template | The message body. Supports {{ }}; a literal \n becomes a real line break. Required. |
| Color | Optional accent colour for the embed and block formats, as a hex value or an integer. |
| Computed Variables | Optional named expressions, evaluated first and then available to the template. |
What each format produces: Plain Text and Markdown pass the message through and only differ in how they label it; HTML escapes the special characters so the body is safe to embed; Slack Blocks builds a header, section, divider and a timestamp context block; Discord Embed builds an embed with description, colour, timestamp and optional title; Telegram prefixes a bold title and marks the message as Markdown. An unrecognised format falls back to plain text.
This node renders the template twice when the first pass produces text that itself contains placeholders — the pattern the seeded notification flows use, where an earlier Transform loads the per-event template out of configuration and this node then fills its fields in.
Output: the formatted message, in a shape that depends on the format, together with the rendered text and title. Single output. For end-to-end setup see Notification Plugins.
Related: Building Flows · Variables & Expressions · Connections & Authentication · Notification Plugins · Capabilities & Flow Contracts