flow_data document, grouped by category. The type value of every node is prefixed lyzr-nodes-base.. For the document structure, connections, and expression syntax, see the flow_data reference.
All string parameters support {{ }} expressions as described in the expression syntax; the tables below note only additional per-node handling. In the tables, “Req” marks required parameters.
Conventions
Two conventions apply across the catalog. First, some parameters name a field to look up in the item rather than a literal value; this applies to Set assignments, the DateTimedate parameter, the Crypto value parameter, and the Sort and Aggregate field parameters, and is called out per node. Second, numbers arrive as JSON numbers: where a parameter expects a number, boolean, or string, a value of the wrong JSON type falls back to the documented default.
Control flow
Trigger
lyzr-nodes-base.trigger is the universal entry node. Exactly one is required per workflow. It takes no parameters and has one output: output 0 emits all injected input items, or a single empty item {} if there are none, so downstream nodes always run.
No-Op
lyzr-nodes-base.noOp is a pass-through. It takes no parameters and has one output: output 0 emits all input items unchanged.
Set / Edit Fields
lyzr-nodes-base.set adds or overwrites fields on each item. It does not remove fields. Assignments are read from the first of the following accepted shapes that yields entries.
The node has one output: output 0 emits one modified item per input item, with
newItem[name] = value applied for each assignment.
If / Else
lyzr-nodes-base.if routes each item to a true branch or a false branch. It supports a rule mode and an AI mode.
Each entry of
conditions.conditions[] is a condition object with leftValue (any type; a string is stripped of a leading = and then dot-path looked up in the item, and an unresolved string is treated as a literal), rightValue (handled the same way), operator (an {operation} object or a bare string), and leftType and rightType (string, number, boolean, any, or "").
The supported operators are exists, notExists, isEmpty, isNotEmpty, equals/equal, notEquals/notEqual, contains, notContains, startsWith, endsWith, gt/greaterThan, lt/lessThan, gte/greaterThanOrEqual, and lte/lessThanOrEqual.
In AI mode, the model is asked per item with the text "Condition: <prompt>" followed by the item JSON as data, and must answer true or false. A per-item evaluation error routes that item to false.
The node has two outputs: output 0 receives matched (true) items and output 1 receives unmatched (false) items. Items pass through unchanged.
Switch
lyzr-nodes-base.switch routes each item to the first matching rule’s output.
Rules take one of two shapes. The legacy shape applies when
value is not null: {value, operand, operator} acts as a single condition. The conditions shape reads conditions.conditions[] (the same sub-keys as the If / Else node) plus conditions.combineOperation.
The node has N+1 outputs, where N is the number of rules. Output i receives items matching rule i, with the first match winning; unmatched items go to output index N, the default output. In AI mode the output is the label index, and an error or no match routes to the last label index. Items pass through unchanged.
Merge
lyzr-nodes-base.merge combines items from multiple inputs.
Mode behavior:
append concatenates all inputs. combineBySql and combineByPosition pair input 0 and input 1 by position, with input 1’s fields winning on collision. combineByFields and mergeByKey join by joinField, with input 0’s fields winning on collision. chooseBranch emits the chosen input verbatim. With fewer than two inputs, every mode falls back to append.
The node has one output (index 0) in all modes.
Loop
lyzr-nodes-base.splitInBatches runs a loop body once per item or once per batch; body nodes execute inline.
The node also reads
settings.continueOnFail (boolean, default false): on a failed iteration it appends {_error, _iteration} and continues, but if every iteration fails, the node errors.
The node emits on output index 1, the “done” output, which carries the items accumulated from the body’s terminal nodes across all iterations. Output 0 feeds the loop body during iteration. Empty input emits {} on output 1.
Loop Until
lyzr-nodes-base.loopUntil re-runs a region of the workflow until a condition holds or a budget is spent. Its Continue output (output 1) must connect back to an upstream node. That back-edge defines the loop region, which runs from that node down to the Loop Until node on every iteration. Without a Continue connection, the node fails at run time.
The node has three outputs:
- Output 0 (Done) fires when the condition holds and carries the items that reached the node on that iteration.
- Output 1 (Continue) is the back-edge and carries no data. Each iteration starts the region’s head node again with the items that entered the loop from outside.
- Output 2 (Exhausted) fires when a budget stopped the loop. It carries the best-scoring iteration’s items when
scoreExpressionis set, and the last iteration’s items otherwise. If Exhausted is not connected, these items leave through Done.
_loop object with exit_reason, iterations (counting from 1), and tokens_used, plus best_score and best_iteration (counting from 1) when scoreExpression is set. exit_reason is one of condition (Done), max_iterations, max_tokens, no_improvement, or no_items (all Exhausted). no_items means the region routed every item away, for example down an unconnected branch.
Nodes inside the region can read $loop.iteration (starting at 0), $loop.isFirst, $loop.maxIterations, $loop.tokensUsed, $loop.maxTokens (0 when there is no token budget), $loop.lastScore, $loop.bestScore, and $loop.bestIteration (counting from 1, present once a score is recorded). Inside the region, $loop.tokensUsed covers completed iterations; in condition it includes the current one.
A node that fails anywhere in the region fails the loop and the run. Per-node retry settings and error edges do not apply inside a Loop Until region.
Stop and Error
lyzr-nodes-base.stopAndError halts the workflow with a terminal, non-retryable error.
The node has no outputs; the run stops with an error.
Wait
lyzr-nodes-base.wait pauses, then passes items through. The pause is capped at 5 minutes.
The node has one output: output 0 emits the input items unchanged.
Filter
lyzr-nodes-base.filter keeps only matching items, without branching. It uses the same condition parsing as the If / Else node’s rule mode and has no AI mode.
The node has one output: output 0 emits matching items only.
Data transformation
Aggregate
lyzr-nodes-base.aggregate collapses many items into one.
The node has one output: output 0 emits exactly one item, either
{outputKey: [values...]} in individual-fields mode (including only items where the field existed) or {destField: [item1, ...]} in all-item-data mode. Empty input emits {}.
Sort
lyzr-nodes-base.sort performs a stable multi-field reorder.
Comparison is numeric when both sides are numbers, and string comparison otherwise. With no fields configured, the items pass through unchanged.
The node has one output: output 0 emits the sorted items. Empty input emits
{}.
Limit
lyzr-nodes-base.limit truncates the item list to at most N items.
The node has one output: output 0 emits the truncated slice, or all items if
maxItems is greater than or equal to the input length. Empty input emits {}.
Remove Duplicates
lyzr-nodes-base.removeDuplicates keeps the first occurrence of each unique key.
The node has one output: output 0 emits the deduplicated items with order preserved. Empty input emits
{}.
Rename Keys
lyzr-nodes-base.renameKeys renames top-level keys on each item.
The node has one output: output 0 emits one renamed item per input item. Empty input emits
{}.
TOON
lyzr-nodes-base.toon converts between JSON items and TOON (Token-Oriented Object Notation).
The node has one output. Encode emits a single item
{outputField: "<toon>"}. Decode emits the items from the document, one item per array element, with non-object elements wrapped as {value: ...}.
Computation and I/O
Code
lyzr-nodes-base.code runs sandboxed JavaScript over the input items, with a 10-second timeout.
The sandbox exposes the globals
$input.all(), $input.first(), $input.item.json, $json (the first item), $items (all items), $('NodeName') (an object with json, all(), first(), and item.json), and console.log and console.warn.
Return values map to items as follows: an array of objects becomes the output items, with objects wrapped as {json: {...}} unwrapped; an array of primitives is an error, so wrap primitives in objects; a single object becomes one item; and a primitive becomes {result: value}.
The node has one output (index 0).
HTTP Request
lyzr-nodes-base.httpRequest makes an authenticated HTTP request with an optional multipart or file body.
For non-multipart requests, the body is resolved in this precedence order: a file
body sends raw bytes; a string body is sent as-is; an object or array body is sent as JSON; bodyParameters.parameters is assembled into a JSON object; jsonBody is used as a fallback; otherwise no body is sent. For multipart requests, each bodyParameters.parameters entry becomes a file part when its value is a file, and a form field otherwise, with name set to the stringified value.
The auth sub-object
Theauth object’s scheme key selects one of "", bearer, basic, api_key, oauth2_client_credentials, aws_sigv4, jwt_bearer, or mtls. Each scheme reads its own keys:
The node has one output: output 0 emits a single item
{statusCode, headers, body}, where headers is a comma-joined map. The body value depends on responseFormat: blob yields a file object wrapped in a $blob envelope, so the body is {"$blob": {bytes, filename, content_type, size}}; text yields the raw string; and anything else yields parsed JSON with a string fallback.
Execute Workflow
lyzr-nodes-base.executeWorkflow runs another workflow, inline or by ID, with the incoming items as its input.
One of the two parameters is required; providing neither is an error.
The node has one output: output 0 emits the flattened concatenation of all sub-workflow output items. If the sub-workflow produced nothing, the node’s own input items pass through.
Utility
Date & Time
lyzr-nodes-base.dateTime performs per-item date operations.
The
diff action reads the end date from the item’s toDate field. Input dates are parsed flexibly, accepting ISO 8601, YYYY-MM-DD HH:MM:SS (with a space or T separator), YYYY-MM-DD, MM/DD/YYYY, DD-MM-YYYY, Jan 2, 2006, and RFC 1123.
The node has one output: output 0 emits each input item copied with the date key overwritten by the formatted value, the diff as a number string, or an "error: ..." string.
Crypto
lyzr-nodes-base.crypto performs per-item hashing, HMAC, or AES-256-GCM encryption.
The
encrypt action produces base64 of the nonce plus ciphertext, and decrypt decodes that format.
The node has one output: output 0 emits each input item copied with data set to the result string, or an "error: ..." string.
Human-in-the-loop
Wait for Approval
lyzr-nodes-base.waitForApproval pauses the workflow until a reviewer approves or rejects, optionally emailing reviewers and collecting form data. The approval is resolved via Resume Execution or Resolve Approval.
Each
formSchema entry’s requiredOn is one of never (the default), approve, reject, or both. The legacy required: true is treated as approve, and fields with type: "boolean" skip required-gating. The resume call supplies {approved, reason?, ...form fields}.
The node has two outputs. Output 0 (approved) emits the input items copied with all resume data merged, including form fields and approved: true. Output 1 (rejected) emits the items copied with all resume data merged plus rejection_reason and approved: false. Empty input emits a single empty item.
AI
LLM credential precedence
The AI Agent, LLM, and AI-mode If / Else and Switch nodes resolve their LLM credential in the following order: a loaded agent’s credential, then the node’sllm_credential_id, then an ambient credential supplied by the caller, then inline credentials (<provider>Api.apiKey or apiKey), and finally the platform’s default credential for the provider. If nothing resolves, the node errors.
A bring-your-own-model credential for openai, anthropic, google, groq, perplexity, xai, deepseek, huggingface, or nvidia can carry an endpoint. Calls then go through that OpenAI-compatible base URL, such as a LiteLLM proxy, instead of to the vendor directly. Give the gateway root; the service appends the chat completions path. The endpoint must be publicly reachable. Azure, Vertex, and Bedrock credentials keep their own authentication and do not route through an endpoint.
Reasoning models
Reasoning models ignoretemperature and topP, while maxTokens is honored. The reasoning model families are o1, o3, and o4, gpt-5, claude-opus-4-5 through 4-7, claude-sonnet-4-6, gemini-2.5 and later, gemini-3, deepseek-reasoner, sonar-reasoning and sonar-deep-research, and grok reasoning models.
Delegation with isSubAgent
A downstreamlyzr.agent, lyzr.llm, lyzr.tool, or lyzr.a2aAgent node with isSubAgent: true becomes a tool the upstream LLM can call within its reasoning loop, and is skipped in the main graph. A waitForApproval node placed on the delegate path wraps the delegated call in a human-approval gate.
AI Agent
lyzr-nodes-base.lyzr.agent runs a managed agent by ID. As a normal node it delegates to the platform, which resolves the agent’s model, prompt, and tools and runs the full reasoning loop, so inline LLM parameters are not read here.
As a delegate (
isSubAgent: true) the node reads description (the tool description, falling back to systemPrompt) and responseFormat (appended to the tool description as the output schema).
The node has one output: output 0 emits the first input item merged with status: "completed", output, and session_id. output holds the agent’s text, parsed into an object or array when it is JSON and kept as the raw string otherwise. session_id is the platform session the call ran in, so a downstream node can continue the same conversation or look it up later.
Conversation memory
The AI Agent and LLM nodes take three memory parameters.memoryWindow sets how many prior turns to replay, 20 by default. On an AI Agent node, memory that the platform agent already has is kept: a scope can add to it but never removes a memory module the agent configures.
LLM
lyzr-nodes-base.lyzr.llm makes an inline single LLM call, or runs a reasoning loop when tools are present.
Tools are not a node parameter. They come from an
_extra_tools field on the input item and from downstream isSubAgent delegate nodes. Prior turns are read from an input item’s history field, an array of {role, content, tool_calls?, tool_call_id?} objects.
The node has one output: output 0 emits an item with status, output (a parsed object when responseFormat is set, a string otherwise), input_tokens, and output_tokens, plus iterations in a reasoning loop. If client-side tool calls are pending, the item carries status: "requires_action" and pending_tool_calls.
Task Decomposition
lyzr-nodes-base.lyzr.taskDecomposition breaks a task into subtasks with one LLM call, runs each subtask in parallel, then aggregates the results with one more LLM call. It accepts the same inline LLM parameters as the LLM node, plus the following.
A subtask may carry its own
agent_id to run as a nested agent. This node cannot itself be a delegate.
The node has one output: output 0 emits an item with status, output (the aggregation text), subtasks[], subtask_results[] (each {id, description, status, output|error}), and summed input_tokens and output_tokens.
Tool
lyzr-nodes-base.lyzr.tool directly executes a platform tool without an LLM. It runs once per input item, and expressions in arguments are resolved against each item in turn.
The node has one output, emitting one item per input item, and every item carries
tool_name. The tool’s response is mapped as follows: an object result is spread into the item; a scalar or array result is stored at item["result"]; a response with no result key is spread into the item whole; and a non-JSON response is stored at item["result"] as the raw string.
As a delegate, the node reads tool_name (the delegate tool name), description, tool_configs, fixedInputs (injected values hidden from the LLM), and action_schema, whose properties and required become the tool’s parameter schema.
A failure the tool provider reports inside an otherwise successful response, such as success: false or Not Authenticated, fails the node, so per-node retry and the error edge apply. A delegated tool reports the failure to its parent LLM as JSON.
A tool step that needs a sign-in runs with your own connected account for that app, and a step that needs an account you have not connected fails with a message asking you to connect it. To pin a step to the account of the person who set it up instead, set persist_auth: true on its entry in tool_configs, next to that entry’s credential_id. Only that account’s owner can create or change a pinned step, and the pin only works while the step is exactly as saved: a pinned step edited since its last save fails with a message telling you to save and run again.
A2A Agent
lyzr-nodes-base.lyzr.a2aAgent calls a remote Agent2Agent server using agent-card discovery and message/send. No local LLM is involved.
The node has one output: output 0 emits an item with
status: "completed", output (the agent reply), input_tokens: 0, output_tokens: 0, and task_state if present.
Knowledge Base
lyzr-nodes-base.lyzr.rag retrieves chunks from, or trains, a Lyzr knowledge base.
Because
rag_id and query fall back to upstream fields, a node fed directly by the Trigger can run without configuration.
The node has one output. A retrieve emits {status, operation, rag_id, query, results[], context, result_count}, and a train emits {status, operation, rag_id, source, documents_trained, text_length}.
Decide
lyzr-nodes-base.lyzr.decide asks the Jev decision model typed questions about each item and writes the answers onto the item. It runs once per incoming item, and all of a node’s questions go to the model in one request. The node uses the platform’s own Typesafe AI credential, so there is nothing to configure or rotate. The model is pinned to jev-1.13.0.
Each question takes the following fields.
A
choice question writes <name> (the chosen option) and <name>_confidence. A score question writes <name> (a decimal between levels), <name>_level (the nearest level as an integer index from 0), and <name>_confidence. A probability question writes <name> as a number from 0 to 1.
The node has one output and does not branch: route on its answers with an If / Else or Switch node. Every item also carries answers (the full reply per question, keyed by question name), decide_model, and decide_usage ({input_tokens, output_tokens} for that item’s call). In answers, a probability answer appears under the model’s own type name, noul. See Decide in the Studio node reference for worked examples.
With no upstream items, the node runs once against state.
Rank
lyzr-nodes-base.lyzr.rank puts every incoming item in front of the Jev decision model at once and reorders the items by how well each answers the query. It makes one call for the whole set and uses the same credential as Decide.
The node accepts at most 255 candidates per run; more than that fails the node. With no incoming items, it emits nothing and does not call the model.
The node has one output: the incoming items, best first, trimmed to
limit if set. Tied items keep their incoming order. Each item gains rank (its position from 1), rank_score (the probability that it is the best answer; scores across the set sum to 1), rank_confidence (how clearly the top candidate separated from the rest, the same on every item), rank_model, and, when validationQuestion is set, validation_probability (the probability that the answer is yes, the same on every item).
Document intelligence
The Parse, Extraction, and Label nodes call the document service. Thetier parameter, defaulting to standard, selects the processing tier: standard covers OCR, DPI, and language options; advanced covers tables, formulas, and output format; and agentic uses a VLM. An unknown tier is an error. Parse and Extraction share the same tier configuration.
Parse
lyzr-nodes-base.lyzr.parse downloads a file and returns its parsed pages, chunks, and full text.
The common parameters are tier, timeout_seconds (default 300), file_url, file_type (inferred from the URL or file when empty; must be one of pdf, docx, xlsx, pptx, image, txt, or csv), chunk_size (default 1000), and chunk_overlap (default 100).
Tier-specific parameters are applied only for the relevant tier:
The file is resolved in this order: an explicit
file_url parameter, then an inline file in the inputs, then the first upstream file_url field. If none is found, the node errors. The download limit is 100 MB.
The node has one output: output 0 emits {status: "completed", tier, file_url, file_type, pages[], full_text, chunks[], metadata, file}, where each page is {number, text}, each chunk is {text, metadata}, and metadata holds {total_pages, total_chunks, engine}.
Extraction
lyzr-nodes-base.lyzr.extraction extracts structured data matching a JSON Schema.
If an input item carries a non-empty
full_text field, for example from a Parse node, the download is skipped and full_text (plus a file_url hint) is submitted instead.
The node has one output: output 0 emits {status: "completed", file_url, file_type, file, ...extraction fields}, where the service’s presigned file_url wins over the input value and file is present only when a file was downloaded.
Label / Classify
lyzr-nodes-base.lyzr.label classifies text against a set of rules.
The node has one output: output 0 emits
{status: "completed", text_preview, rules[], file_url, ...classification fields}, where text_preview is the first 200 characters, rules[] echoes the input rules, file_url is included if an upstream one exists, and the classification fields typically include label, confidence, and reasoning.
Safety
Guardrails
lyzr-nodes-base.lyzr.guardrails evaluates text against a Responsible AI policy and routes items to an allowed or blocked output. Service errors are terminal and fail closed; there is no fail-open routing.
The node has two outputs. Output 0 (allowed) emits the base item copied with
blocked: false, warnings, text (the redacted text if redaction happened, the original otherwise), and original_text only when redaction changed the text. Output 1 (blocked) emits the base item copied with blocked: true, block_reason, detections (an object), warnings, and original_text.