Node reference
Reference for every node available in Flovello.
Signal
Nodes for emitting and receiving named signals between pipelines, enabling asynchronous, decoupled communication across your project.
Emits a signal to all subscriber pipelines. Each signal parameter maps to a typed input pin. When executed, one execution-intent row is enqueued for every subscribing pipeline; a NOTIFY wakes all cluster instances so any instance can claim and run a subscriber. Asynchronous by default; tick Wait for completion to block until every subscriber finishes and route to Error if any of them did not succeed.
Trigger node that starts the pipeline each time the matching signal is emitted. Each signal parameter appears as a typed output pin carrying the payload sent by the emitter. The pipeline subscribes automatically when saved and runs once per Send Signal invocation.
Triggers
Entry-point nodes that start pipeline execution in response to a schedule or inbound request.
Triggers the pipeline on a cron schedule. Use as the first node in time-based automations.
Triggers the pipeline at a fixed interval (e.g. every 10 minutes). Use as the first node in time-based automations where a cron expression would be overkill.
Starts the pipeline when an HTTP request hits the pipeline's trigger URL. Exposes the request method, headers, and body stream as outputs so downstream nodes can parse the payload without buffering it into memory.
Trigger node that starts the pipeline when another pipeline's Run pipeline node calls it. Each trigger parameter the pipeline declares appears as a typed output pin carrying the value the caller supplied. A pipeline can have at most one of these, because a call has to start in one unambiguous place.
Flow control
Nodes that direct which execution path runs next, including branching, switching, looping, error termination, and value selection.
Conditional branching on a boolean input. Emits the true execution pin when the condition is true and the false pin otherwise.
Routes execution to a case pin whose configured value matches the value input. Falls through to the default pin when no case matches. Case pins are configured per node instance; the value input is generic and locks to its connected type at design-time.
Terminates the pipeline with an error message. Use to abort execution when a precondition isn't met.
Iterates over each element in an array, firing the loop-body pin with element and index outputs, then the completed pin when the array is exhausted. Element type resolves on connection. A null or empty array iterates zero times and goes straight to completed.
Iterates from firstIndex to lastIndex (inclusive), firing the loop-body pin with the current index, then completed when done.
Repeats the loop pin while the boolean condition is true, re-evaluating the condition before each iteration, then fires completed once it becomes false. Wire a node that the loop body changes (e.g. a local variable) into the condition so the loop can end.
Returns one of N option values based on a zero-based index. Pure function — only the option the index picks is evaluated; the others are never run, so an option may safely read data that is only valid when it is the one selected. Fails the pipeline if the index is out of range.
Returns one of two values based on a boolean condition. Generic on both branches, in shape as well as type: scalars, arrays, maps and whole model values can be connected as long as both branches agree, and the type is fixed at design-time when the first one is. Pure function — only the branch the condition picks is evaluated; the other is never run, so a branch may safely read data that is only valid on its own side of the condition.
Pure function holding one fixed scalar value of a type you choose, for feeding a generic node that has no type of its own yet (an enum value into Select boolean, say). It is a literal, not a computation, so its `value` input takes a typed-in value only and cannot be wired. In graph JSON, set the type in the node config: `valueType` is one of STRING, INTEGER, DECIMAL, BOOLEAN, DATETIME or ENUM (STRING when absent), and for ENUM `enumType` names the enum, for example HttpMethod, or the name of an enum model. Put the value itself in the `value` input as a scalarValue string: config {"valueType": "INTEGER"} with input value scalarValue "5" yields the integer 5; config {"valueType": "ENUM", "enumType": "HttpMethod"} with scalarValue "POST" yields that enum value. An empty value is the type's zero (empty string, 0, false, the epoch), except ENUM, which must have a value. DATETIME takes an ISO-8601 timestamp with offset, e.g. 2026-01-31T09:00:00Z. The `value` output is typed by the config, so whatever it is wired into is typed by it.
Arithmetic
Pure functions for integer and decimal arithmetic operations.
Pure function returning the sum of two numbers.
Pure function returning a minus b.
Pure function returning the product of two numbers.
Pure function returning a divided by b. Integer division truncates toward zero. Decimal division uses IEEE 754 decimal64 precision (16 significant digits). Dividing by zero fails the pipeline.
Pure function returning the remainder of a divided by b. A modulo of zero fails the pipeline.
Pure function returning the negation of a number (i.e. -value).
Pure function returning the absolute value of a number.
Pure function returning the smaller of two numbers.
Pure function returning the larger of two numbers.
Pure function returning base raised to the exponent. Generic on both operands, resolving to INTEGER or DECIMAL at design-time. Integer powers require a non-negative exponent; decimal powers allow negative and fractional exponents (e.g. roots).
Pure function returning value constrained to the inclusive range [min, max]. If min is greater than max the result is min.
Comparison
Pure functions that compare two values and return a boolean result.
Pure function returning true if two values of any type are equal. Generic on both operands; type is fixed at design-time when connected.
Pure function returning true if two values of any type are not equal. Generic on both operands; type is fixed at design-time when connected.
Pure function returning true if a is greater than b.
Pure function returning true if a is less than b.
Pure function returning true if a is greater than or equal to b.
Pure function returning true if a is less than or equal to b.
Pure function returning true if A is before B.
Boolean logic
Pure functions for logical operations on boolean values.
Null handling
Pure functions for working with absent values — the nulls that optional model fields produce when a payload omits them or sends null.
Pure function returning true if the value is null. Generic on the value, in shape as well as type: a scalar, an array, a map or a whole model value can be connected, and the type is fixed at design-time when it is. Nulls reach a pipeline from optional model fields that parsed as JSON null.
Returns the value when it is not null, and the fallback otherwise. Generic on both pins, in shape as well as type: scalars, arrays, maps and whole model values can be connected as long as both pins agree, and the type is fixed at design-time when the first one is. Pure function — the fallback is evaluated only when the value is null.
Strings
Pure functions for inspecting and transforming text strings.
Pure function joining a dynamic list of text pins into a single string, in pin order. Starts with two pins and takes more — add and remove them on the node; two is the minimum, since joining fewer is just the text itself. A null text reads as no text rather than failing the run.
Pure function returning the text converted to uppercase using the root locale.
Pure function returning the text converted to lowercase using the root locale.
Pure function returning the text with leading and trailing whitespace removed.
Pure function returning the number of characters in the text.
Pure function returning the substring of text starting at the given index for the given length. Out-of-range indices are clamped to the bounds of the string.
Pure function returning true if text contains search.
Pure function returning true if text starts with prefix.
Pure function returning true if text ends with suffix.
Pure function returning text with every occurrence of search replaced by replacement. The search is matched literally — no regular expressions.
Pure function returning true if text has zero characters. Whitespace-only strings are not considered empty — pass through trim first if needed.
Pure function splitting text on a literal separator and returning the resulting parts as a string array. The separator is matched literally — no regular expressions. An empty separator returns the original text as a single-element array.
Pure function joining a string array into a single string with the given separator between each element. A null or empty array returns an empty string.
Pure function parsing text as an integer. Whitespace is trimmed before parsing; non-numeric input fails the pipeline.
Cryptography
Pure functions for encoding, hashing, and signing text — including keyed HMAC for verifying signed webhooks.
Pure function encoding text using the selected algorithm. Base64 produces the standard Base64 alphabet; URL uses application/x-www-form-urlencoded encoding.
Pure function decoding text using the selected algorithm. Base64 expects the standard Base64 alphabet; URL expects application/x-www-form-urlencoded encoding.
Pure function returning the hex-encoded hash of the input text using the selected algorithm. The output is always lowercase hexadecimal.
Pure function returning the keyed HMAC of the input text using the selected algorithm. Hex output is lowercase. Use this to verify signed webhooks (e.g. Stripe, GitHub, Shopify).
Type conversion
Functions that convert values between primitive types, between strings and streams, and out of documents.
Pure function converting an integer to its string representation.
Pure function returning "true" or "false" for the given boolean.
Pure function parsing text as a boolean. Returns true for "true" (case-insensitive, whitespace trimmed); false for everything else.
Pure function returning 1 for true and 0 for false.
Pure function returning true for any non-zero integer and false for zero.
Pure function widening an integer to a decimal.
Pure function converting a decimal to an integer, truncating toward zero.
Pure function converting a decimal to its plain string representation, without scientific notation (e.g. 0.0000001 becomes "0.0000001").
Pure function returning the underlying string value of any enum. Accepts any enum source — built-in or user-defined — and emits the raw value. Useful for piping an enum field into log-message or any other string consumer.
Pure function reading a stream fully and returning its contents as a string. Uses the charset from the stream's content-type hint when set; otherwise falls back to the selected charset.
Pure function wrapping a string as an output stream using the selected charset. Use to pipe a literal string into a node that expects an output stream (e.g. an HTTP request body).
Pure function bridging an input stream into an output stream without buffering. When the downstream consumer (e.g. http-request) writes the body, the bytes are pulled from the input stream and piped straight through. Use this to forward an FTP-downloaded file or an HTTP response body into another HTTP request without materialising it as a string first.
Extracts the text layer of a PDF, as one joined string and as an array with one entry per page. Branches on success/error; the error branch is taken for an unreadable or encrypted PDF, and also when the document carries no text at all — a scan or an image-only PDF has nothing to extract.
Models
Nodes for building, splitting, parsing, and serialising structured model values. The pins on Make, Break, and Parse to model adapt to the model you pick in the inspector.
Composes a model value from one input pin per field. Pick the model in the inspector; the node then exposes an argument input pin for every field of that model, typed to match, and emits the assembled model. A pure function — no side effects and no execution pins.
Splits a model value into one output pin per field. Pick the model in the inspector; the node then exposes an argument output pin for every field of that model, typed to match. A pure function — no side effects and no execution pins.
Parses an input stream into a typed model. Pick the model in the inspector and choose the wire format — JSON, YAML, XML, CSV or Excel. Branches on success/error so the pipeline can handle malformed input. An array variant parses the stream into an array of the chosen model.
Pure function that serialises a model, or a list of models, to a string. Supports JSON, YAML, XML and CSV. Excel needs Model to stream instead, since an .xlsx file is not text. Enable pretty for indented output. Useful for debugging — pipe the result into Log message.
Pure function that serialises a model, or a list of models, to an output stream. Supports JSON, YAML, XML, CSV and Excel. Use to send a model as an HTTP request body, or to build a spreadsheet to upload or attach.
Date and time
Pure functions for reading the current time, formatting, parsing, and doing date arithmetic.
Pure function returning the current moment in the chosen time zone.
Pure function formatting a date/time as a string. The pattern follows Java's DateTimeFormatter syntax; the default is ISO-8601.
Pure function parsing a string into a date/time. The pattern follows Java's DateTimeFormatter syntax; the default is ISO-8601.
Pure function building a duration from an amount and a unit (e.g. 5 MINUTES).
Pure function returning value + duration. Use a negative duration to subtract.
Pure function returning the duration between two date/times (end minus start).
Arrays and ranges
Functions for building arrays, creating integer ranges, and working with array elements.
Pure function returning an integer array from first to last (inclusive). Useful as input to for-each.
Pure function building an array from a dynamic list of element pins. Add and remove pins on the node; removing them all yields an empty array, which is how you make one. Generic on the element type — the first connected pin fixes it for the rest.
Pure function returning the number of elements in an array. Generic on the element type; type is fixed at design-time when connected. A null array counts as empty and returns 0.
Pure function returning the element at the given index in an array. Generic on the element type; type is fixed at design-time when connected. Out-of-range indices fail the pipeline; a null array counts as empty, so every index is out of range.
Appends an element to an array in place and returns the updated array. Has execution pins (not pure).
Removes and returns the element at the given index from an array in place and returns the updated array. Has execution pins (not pure). Out-of-range indices fail the pipeline.
Removes all elements from an array in place and returns the empty array. Has execution pins (not pure).
Pure function returning the set union of two arrays: every element of A, then every element of B that A does not already hold, with duplicates dropped from both sides. Order is first-seen, so [sv, en] and [sv, fi] union to [sv, en, fi]. Elements are compared the way Equals compares them. Builds a new array and leaves both inputs untouched; a null array counts as empty.
Maps
Functions for reading, adding and removing key-value entries in maps, and for grouping an array of items into a map of arrays.
Puts a key-value entry into a map in place and returns the updated map. Works on maps of scalars and maps of arrays alike — the value pin follows the map's value shape. Has execution pins (not pure).
Pure function returning the value stored under a key, or null when the key is absent. The value pin follows the map's value shape, so reading a map of arrays yields an array. Pair with Is null? or Default if null to handle a missing key.
Removes an entry by key from a map in place and returns the updated map. Has execution pins (not pure).
Pure function returning true when the map has an entry under the given key. A null map contains nothing and returns false.
Pure function returning the number of entries in a map. A null map counts as empty and returns 0.
Pure function returning every key in the map as a string array, sorted so the order is stable between runs. Feed it into For each to walk the map. Keys are always strings at run time, whatever key type the map declares.
Appends an element to the array stored under a key in a map of arrays, creating the array when the key is absent. The multimap primitive: wire it into a For each to group items by a shared value in one step. Mutates in place and returns the same map. Has execution pins (not pure).
Pure function grouping an array of model values into a map of arrays, keyed by one field every element carries. Pick the field on the node; a dotted path (customer.id) groups by a field of a nested model. Keys are strings at run time whatever the field's declared type. Fails when the chosen field is null on an element — group with For each and Map array append instead when the key can be absent.
Random
Pure functions that generate random values — integers, UUIDs, and booleans.
I/O and network
Side-effecting nodes for logging, pausing, sending HTTP requests, sending email, posting to Slack, and running another pipeline.
Writes a message to the execution log at INFO level. Use for debugging and auditing. Has execution pins (not pure).
Runs another pipeline in the same organization. The target must carry a Called by pipeline trigger; its declared trigger parameters appear as typed input pins. One execution-intent row is enqueued and a NOTIFY wakes the cluster, so any instance can claim and run the target. Asynchronous by default; tick Wait for completion to block until the target finishes and route to Error if it did not succeed.
Pauses execution for the given number of milliseconds before emitting the execution pin.
Sends an HTTP request and returns the raw response object. Branches on success/error; pass the response into a Break node to inspect status, body, or headers. The body input is an output stream — the upstream node writes directly to the request socket on demand, so uploads aren't buffered into memory. Use string-to-stream to pipe in a literal string, or model-to-stream to serialise a model. Wire the headers input to send custom request headers (build them with make-http-headers and add-http-header).
Pure function: fetches an OAuth2 access token via the client credentials grant and returns a credentials object that can be wired into http-request.
Sends an email from the Flovello no-reply address. To, CC and BCC each accept one address or a comma-separated list (at least one To address, at most 50 recipients in total). Branches on success/error and outputs the provider messageId on success. To prevent abuse, every recipient must be an active member of the pipeline's organization or a verified destination — any other address fails the whole send on the error branch.
Sends a message to a Slack channel using the organization's connected Slack workspace. Requires an active Slack integration. Branches on success/error so the pipeline can react to delivery failures.
Creates an empty HTTP headers collection on the execution flow. Has execution pins so each fire yields a fresh instance — chain with add-http-header to attach values, then wire the result into http-request's headers input.
Appends a value to the named header on the execution flow and returns the same headers instance. Has execution pins so the append order is deterministic. Header names are matched case-insensitively; multiple values for the same name preserve insertion order. Fails the pipeline if the headers came from an inbound request or response (read-only) — use make-http-headers to build a fresh collection.
Pure function returning the first value of the named header, or an empty string if the header is not set. Header names are matched case-insensitively.
Pure function returning every value of the named header as a string array, in insertion order. Returns an empty array if the header is not set. Header names are matched case-insensitively.
Pure function: builds an FTP credentials object from a host, port, username, password, and protocol (FTP, FTPS_EXPLICIT, FTPS_IMPLICIT, or SFTP). Wire the credentials output into any FTP operation node. A port of 0 selects the protocol default (21 for FTP/FTPS_EXPLICIT, 990 for FTPS_IMPLICIT, 22 for SFTP).
Downloads a file from an FTP/SFTP server and exposes its contents as a stream. Takes an FTP file object from Find/Get FTP files — the server connection comes from the file itself. Branches on success/error; the error branch is taken when the file does not exist. The downloaded bytes are buffered to a temporary file so the stream remains usable after the FTP session closes.
Finds files and directories on an FTP/SFTP server and returns them as an array of FTP file objects carrying name, path, size, modified time, type, and an exists flag. Filter by entry type, match names against a glob pattern, and optionally recurse into subdirectories (symbolic links are treated as files and never followed). Wire a result into Open/Remove/Move FTP file, or into a Break node to read its fields. Branches on success/error.
Looks up a single file or directory on an FTP/SFTP server by path and returns it as an FTP file object. A missing path is not an error: the returned object has exists = false so the flag can be branched on. The error branch is taken only for connection or protocol failures.
Removes a file from an FTP/SFTP server. Takes an FTP file object from Find/Get FTP files — the server connection comes from the file itself. Branches on success/error; the error branch is taken when the file does not exist.
Moves (renames) a file on an FTP/SFTP server to a new path on the same server. Takes an FTP file object from Find/Get FTP files — the server connection comes from the file itself. Branches on success/error; the error branch is taken when the file does not exist.
Writes a file to an FTP/SFTP server, creating it or overwriting whatever is already at the path. The content input is an output stream — the upstream node writes straight to the server, so uploads aren't buffered into memory. Use string-to-stream for text, model-to-stream to serialise a model, or copy-stream to forward a downloaded file (from Open FTP file or an HTTP response) without materialising it as a string; leaving content unconnected writes an empty file, which is how you drop a zero-byte sentinel. Returns the written file as an FTP file object that can be wired straight into Move/Remove FTP file. Set createDirectories to create any missing parent directories instead of failing. Branches on success/error.
Creates a directory on an FTP/SFTP server and returns it. Missing parent directories are created too, and a directory that already exists succeeds and is returned, so this is safe to run on every execution. Use it to prepare a destination before Write FTP file when the write itself should not create directories. Branches on success/error.
Removes an empty directory from an FTP/SFTP server. Takes an FTP file object from Find/Get FTP files or Create FTP directory — the server connection comes from the object itself. The directory is checked and must be empty: this node never deletes a tree, so clear the entries first with Find FTP files and Remove FTP file. Branches on success/error; the error branch is also taken when the directory is not empty or does not exist.
Email inbox
Nodes for reading and managing an external mailbox over IMAP: finding messages, reading bodies and attachments, and moving, flagging or deleting them.
Pure function: builds an email credentials object from a host, port, username, password, and encryption (SSL_TLS, STARTTLS, or NONE). Wire the credentials output into any email operation node. A port of 0 selects the encryption default (993 for SSL_TLS, 143 for STARTTLS and NONE). Use this for servers that still accept password login; Microsoft 365 requires Email OAuth2 credentials instead.
Pure function: fetches an OAuth2 access token via the client credentials grant and builds an email credentials object that authenticates with SASL XOAUTH2. This is what Microsoft 365 and Google Workspace require for IMAP. For Microsoft 365 use host outlook.office365.com, the tenant's https://login.microsoftonline.com/<tenant>/oauth2/v2.0/token endpoint, and scope https://outlook.office365.com/.default; for Gmail use imap.gmail.com and scope https://mail.google.com/. Tokens are cached and reused until they expire.
Pure function: builds an email credentials object from an OAuth2 access token you already have, authenticating with SASL XOAUTH2. Use this when the token comes from a flow the Email OAuth2 credentials node cannot run itself — for example an authorization-code grant whose refresh token you exchange with an HTTP request node. The token is used as supplied and is never refreshed.
Finds messages in a mailbox folder and returns them as an array of email objects carrying subject, sender, recipients, flags, size and attachment metadata. Filter by read state, sender, recipient, subject, body text and a date range. Bodies are NOT fetched — wire a result into Read email for the text, or into Break to read its fields. Wire a result into Move, Copy, Delete or Set email flag; those nodes need no credentials because the email object carries its own server connection. Branches on success/error.
Looks up a single message by its UID in a folder and returns it as an email object. A UID the folder does not hold is not an error: the returned object has exists = false so the flag can be branched on. The error branch is taken only for connection or protocol failures.
Fetches a message's body, which Find emails deliberately skips so that searching a large mailbox stays cheap. Outputs the plain-text and HTML parts (either is empty when the message has no such part) and the full header block, which Get HTTP header and Get HTTP header values can read. Reading does NOT mark the message as read — use Set email flag for that. Branches on success/error.
Downloads one attachment and exposes its decoded contents as a stream. Takes an attachment object from an email's attachments field — the server connection comes from the attachment itself. Wire the stream into Stream to string, Copy stream, or an HTTP request body. Branches on success/error.
Finds folders (mailboxes) on a mail server and returns them as an array of folder objects carrying name, full path, special-use role, and message and unseen counts where the server reports them. The pattern is an IMAP pattern where * matches across the folder hierarchy and % matches within one level; empty returns every folder. Branches on success/error.
Creates a folder on a mail server and returns it. Creating a folder that already exists succeeds and returns the existing folder, so this is safe to run on every execution. Use the server's hierarchy separator in the path (usually / or .). Branches on success/error.
Moves a message to another folder on the same server. Takes an email object from Find/Get email — the server connection comes from the email itself. The message has no output because its UID in the destination folder is not reliably knowable; look it up with Find emails if you need it. Branches on success/error.
Copies a message into another folder on the same server, leaving the original where it is. Takes an email object from Find/Get email — the server connection comes from the email itself. Branches on success/error.
Deletes a message. In TRASH mode (the default) it is moved to the server's trash folder and stays recoverable; in PERMANENT mode it is expunged and cannot be recovered. Takes an email object from Find/Get email — the server connection comes from the email itself. Branches on success/error.
Sets or clears one flag on a message: SEEN (read/unread), FLAGGED (starred), ANSWERED, DRAFT, or DELETED. Takes an email object from Find/Get email — the server connection comes from the email itself. Use this to mark messages as read after processing them, so a polling pipeline does not reprocess them. Branches on success/error.
Pure function formatting an email address object as text: "Name <address@example.com>", or just the bare address when the address carries no display name. Returns an empty string for a null address, so it is safe on a message with no parseable sender.
AI
In-pipeline AI. The Flovello AI step produces a typed model value from your input — a model, a string, or a PDF, image or text file — using a natural-language instruction.
Function I/O
Special nodes used inside user-defined function graphs to declare inputs and outputs.