Node Reference

This is the complete catalog of nodes you can drop onto a flow canvas. For each node you'll find its purpose, a table of its configuration fields (with types and defaults), and the outputs it produces. Nodes with more than one output are branching nodes — they pick one output at runtime and execution continues down whatever you wired to it. Nodes with a single default output just pass control to the next node.

Throughout, fields accept the {{ }} syntax for dynamic values — see Variables and Expressions. For how to assemble these into a working flow, see Building Flows.

The palette shows each node by its canonical name. Several nodes also accept short aliases as node types — HTTP, Request, Set, Wait, Debug, Format, and Map Status — which you'll see in imported or shared flows. These resolve to the same nodes (for example, HTTP and Request are both the HTTP Request node, and Set is Set Variable); they are not separate palette items.

---

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 execution always begins here.

Config fields: none.

Output: the flow's input, forwarded to the next node. Single default output.

---

End

Purpose: The exit point of a flow. It returns the final result. A flow can have several End nodes (for example, one on a success branch and one on an error branch); whichever is reached first ends the flow.

Config fields:

Field	Type	Default	Notes
output	object	—	Shapes the returned result. Each entry's value may use {{ }}. When set with at least one key, this defines the output object.
outputMapping	object	—	An alternative to output: a map of { resultKey: sourcePath } that pulls values from variables or input by path. Used only when output isn't set.
statusCode	number	—	For webhook responses. When set, the result is wrapped as { statusCode, body: <output> }.

With none of these set, End simply returns whatever input reached it (passthrough).

Output: the final flow result. No further outputs — End terminates the flow.

---

Condition

Purpose: If/else branching. Evaluates one or more conditions and routes to true or false.

Config fields:

Field	Type	Default	Notes
conditions	array of { field, operator, value }	—	field is an expression to evaluate, operator is the comparison, value is what to compare against (string values support {{ }}).
logic	string	and	How multiple conditions combine. and requires all to pass; or requires any one.

With no conditions configured, the node routes to true.

Operators:

equals (eq, ==), notEquals (neq, !=), strictEquals (===), strictNotEquals (!==), greaterThan (gt, >), greaterThanOrEqual (gte, >=), lessThan (lt, <), lessThanOrEqual (lte, <=), contains, notContains, startsWith, endsWith, matches (regular-expression test), isEmpty, isNotEmpty, isTrue, isFalse, exists, notExists, in (member of an array or comma-separated list), notIn.

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. A common use is routing inbound webhook events by event type.

Config fields:

Field	Type	Default	Notes
field	string (expression)	—	The value to switch on.
cases	array of { value, handle, label? }	—	Checked in order; the first match wins. handle is the name of the output for that case (string values support {{ }}).
default	string	default	The output used when no case matches.
operator	string	equals	How each case's value is compared to field.

Operators: equals (eq), strictEquals (===), in, startsWith, endsWith, contains, matches.

Outputs: one output per case (each named by its handle), plus the default output. The input passes through unchanged.

---

Loop

Purpose: Iterate over an array. For each item, the flow runs whatever you wired to the body output; when every item is done, it runs the complete output.

Config fields:

Field	Type	Default	Notes
source	string (path or {{ }})	—	The array to iterate. Point it at an array value (e.g. a previous node's list output).
itemVariable	string	item	The variable name that holds the current item inside the loop body.
indexVariable	string	index	The variable name that holds the current zero-based position.
maxIterations	number	1000	Safety cap on how many items are processed (the platform also enforces an upper bound).

If source isn't an array (or is empty), the loop does no iterations and goes straight to complete.

Outputs: body (runs once per item, with itemVariable and indexVariable set) and complete (runs after the last item; it can read the collected results of all iterations).

---

HTTP Request

Aliases: 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.

Config fields:

Field	Type	Default	Notes
connectionId	connection reference	—	The connection to send through (carries the base URL and authentication). Preferred way to pick a connection.
connectionSlug	string	—	Alternative to connectionId — reference a connection by its slug. Supports {{ }}. One of connectionId or connectionSlug is required.
method	string	GET	HTTP method. A request body is sent only for POST, PUT, and PATCH.
path	string	/	The path appended to the connection's base URL. Supports {{ }} — e.g. /servers/{{ input.serverId }}/status.
headers	object	{}	Request headers; values support {{ }}. (Authentication headers from the connection are added for you.)
body	object or string	—	Request payload, for write methods only. Supports {{ }}.
bodyType	string	—	Set to raw to treat body as a raw string (it's substituted, then parsed as JSON if possible). Otherwise body is treated as an object.
bodyOmitEmpty	boolean	—	When true, drops body keys whose templated value resolved to empty or unresolved — handy for optional fields.
responseMapping	object { key: sourcePath }	—	Reshape the response into named fields. A response. prefix reads from the full response; otherwise paths read from the response body.

You can put {{ }} anywhere in path, headers, and body to inject input, configuration, or earlier node outputs.

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. Connection-level concerns — base URL, authentication, timeouts, and safety checks — are handled by the connection itself; see Connections and Authentication.

---

Transform

Purpose: Reshape data by mapping source values to target fields, optionally applying a transform to each value as it's copied.

Config fields:

Field	Type	Default	Notes
mappings	array of mapping objects	—	Each mapping is { source, target, transform?, expression?, default? } (see below).
mode	string	merge	merge starts from the incoming input and adds/overwrites mapped fields; replace starts from an empty object.

Per-mapping fields:

Field	Notes
source	Where to read the value from. Accepts a {{ }} expression or a plain path.
target	Where to write the value in the output (a path).
expression	An expression to compute the value directly, instead of source.
default	Used when the resolved value is missing (undefined/null).
transform	A transform to apply to the value — either a simple name (string) or a parameterized object { type, ... }.

Simple transforms (use the name as a string):

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, base64Encode, base64Decode.

Parameterized transforms (use an object { type, ... }):

type	Key parameters (defaults)
split	delimiter (,)
join	delimiter (,)
slice	start (0), end
replace	pattern (''), flags (g), replacement ('')
map	field
filter	field, value
find	field, value
pad	length (10), char (space), side (end)
default	value
coalesce	values (array of paths), fallback
template	template (string with {{ }}, plus the current value)
enrichArray	fields (a map of fieldName → template, applied per item)
flattenVersions	versionsField (versions), nameField (name)
math	operation (add/subtract/multiply/divide/modulo/power), operand

An unknown transform name leaves the value unchanged.

Output: the assembled object. Single default output.

---

Status Map

Alias: Map Status.

Purpose: Declaratively map an external value onto an internal one — for example, a provider's status string onto your platform's status. Cleaner than nested conditionals.

Config fields:

Field	Type	Default	Notes
sourceField	string (expression)	—	The value to look up.
mappings	object { externalValue: internalValue }	—	The lookup table. The source value is matched against the keys.
default	any	unknown	Returned when no key matches.
outputField	string	status	The key the mapped value is written to in the output.
passthrough	boolean	true	When true, the mapped field is merged onto the incoming input; when false, the output is just { [outputField]: <mapped> }.

Output: the input with the mapped field added (or just the mapped field if passthrough is off). Single default output.

---

Set Variable

Alias: Set.

Purpose: Store one or more computed values into flow variables so later nodes can reference them by name.

Config fields:

Field	Type	Default	Notes
variables	array of { name, value }	—	Each entry stores a value under name. The value may be a whole-value {{ }} (raw value preserved), a string with embedded {{ }}, a literal, or an object. Entries without a name are skipped.

Output: the input, passed through unchanged. Single default output. The variables you set are available to any node downstream.

---

Delay

Alias: Wait.

Purpose: Pause the flow for a set amount of time before continuing.

Config fields:

Field	Type	Default	Notes
delay	number (milliseconds)	0	How long to wait. Capped at 300,000 ms (5 minutes). A value of 0 continues immediately.

Output: the input, passed through after the wait. Single default output.

---

Log

Alias: Debug.

Purpose: Write a message (and optionally some extracted values) into the run's execution trace, to help you understand what a flow is doing while you build and debug it.

Config fields:

Field	Type	Default	Notes
message	string	Log node executed	The message to record. Supports {{ }}.
level	string	info	Log level label.
data	object { key: sourcePath }	—	Optional values to capture alongside the message; each path is read and recorded under its key.

Output: the input, passed through unchanged. Single default output. The message appears in the flow's History trace.

---

Format Message

Alias: Format.

Purpose: Build a notification message from a template and format it for a specific channel. Typically used in notification flows just before an HTTP Request that delivers the message.

Config fields:

Field	Type	Default	Notes
template	string	—	The message body. Supports {{ }}; use \n for line breaks. Required.
format	string	text	The output format (see below).
title	string	—	Optional heading/title for formats that support one (e.g. embeds, blocks). Supports {{ }}.
color	string (hex or integer)	—	Optional accent color for embed/block formats.
variables	object { key: expression }	—	Extra values computed and made available to the template before it's rendered.

Formats: text, markdown, html, slack_blocks, discord_embed, telegram. An unknown format falls back to text.

Output: the formatted message (its exact shape depends on the chosen format), including the rendered message text and title. Single default output. For end-to-end notification setup, see Notification Plugins.

---

Related: Building Flows · Variables and Expressions · Connections and Authentication · Notification Plugins · Capabilities and Flow Contracts