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
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 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.
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 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 {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 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.
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" and output, which holds the agent’s text, parsed into an object or array when it is JSON and kept as the raw string otherwise.
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.
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.
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.
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.