Skip to main content

Workflow Operator Nodes

Operator nodes are the workhorses of a workflow — they call APIs, transform data, run queries, send notifications, and execute custom code. You add them to the canvas from the Tools category of the node library in the task editor, configure their inputs in the right configuration panel, and connect them to other nodes with edges.

This page describes the operator categories the engine ships with, how data flows between nodes, and where to go for per-operator details.

Operator Node Basics​

Each operator node has:

  • Input ports — named inputs the node reads (for example a transform's data input).
  • Configuration / default inputs — values you set in the configuration panel that control the node's behavior.
  • Output — the result the node produces, which downstream nodes can read.

You wire nodes together with edges on the canvas. See How Data Flows Between Nodes below for the exact edge format.

Built-in Operator Categories​

The workflow engine includes the following built-in operator categories:

CategoryWhat it does
APICall external HTTP/REST APIs (generic API and REST operators)
CustomRun your own JavaScript in a sandbox (the js-executor operator)
Data SourceConnect to and inspect data sources (default data source, PostgreSQL/MySQL schema)
DatasetQuery and modify datasets (query, insert, update, delete, vector search, full-text search)
DocumentRead and process documents
EmbeddingGenerate embeddings (multimodal embedding)
Global VariableRead and write workflow-level global variables
NotificationSend notifications such as email
SQLRun parameterized SQL via templates (sql-template)
StorageStore and retrieve files
TransformReshape and convert data between nodes
WeChatPublish content to WeChat
note

The exact set of operators available to you depends on what is enabled in your space and deployment. Browse the Tools category in the node library (open it with Ctrl + K in the task editor) to see what you can add, and use the search box to find an operator by name.

Custom Code with js-executor​

For logic that no built-in operator covers, use the custom-code operator, whose identifier is js-executor. It runs your JavaScript inside a secure sandbox.

Your code receives:

  • parameters (also available as params) — the parameters you pass into the node.
  • context — a read-only snapshot of the workflow execution context (including context.env for environment variables, and the results of upstream nodes).
  • console.log / console.error / console.warn / console.info — write to the run logs.
  • utils — a set of helper functions (type checks, string and array helpers, hashing, formatting, and more).

Return a value to produce the node's output:

// parameters holds the inputs you wired into this node
const items = parameters.items || [];

const total = items.reduce((sum, it) => sum + it.price, 0);

return {
  count: items.length,
  total
};
warning

The context available to your code is a read-only snapshot. Assigning to it (for example context.someValue = ...) does not persist anywhere — to pass data onward, return it from your code and wire the output to the next node. To share state across a loop, see ForEach Loop Node.

For full details — available utils helpers, the sandbox restrictions, and examples — see the JavaScript Executor reference.

How Data Flows Between Nodes​

Data moves from one node to another along edges. An edge connects a source port on one node to a target port on another, using the string form nodeId:portName:

{
  "source": "fetch-data:result",
  "target": "transform-1:data"
}

This connects the result output of node fetch-data to the data input of node transform-1.

Selecting part of the source output with dataPath​

To pass only part of the source node's output, add a dataPath. The path is resolved against the source node's output using dot and bracket notation:

{
  "source": "fetch-user:result",
  "target": "send-email:to",
  "dataPath": "user.email"
}

Here dataPath: "user.email" reads user.email from the output of fetch-user and feeds it into the to input of send-email. Array indexing is supported too, e.g. items[0].id.

note

dataPath walks the source node's output object — it is not a JSONPath query language and does not use a $.input / $.context prefix. If you omit dataPath, the whole value at the source port is passed through.

Default input values​

A node can also carry default input values that you set directly in the configuration panel (these are used when no edge supplies that input). Default inputs and edge values both support the {{VARIABLE_NAME}} environment-variable template syntax — see Environment Variables.

Building with Operators​

  1. Open the task editor and open the node library (Ctrl + K).
  2. From the Tools category, drag an operator onto the canvas.
  3. Select the node and open the configuration panel (Ctrl + I) to set its inputs and default values.
  4. Draw edges from upstream node ports into this node's input ports.
  5. Use control nodes (If-Else, ForEach) to add branching and iteration.
  6. Save and run the task, then watch the per-node output in the bottom debug panel.

FAQ​

Details

How do I run custom logic that no operator covers? Use the custom-code operator (js-executor). It runs JavaScript in a sandbox with access to your parameters, a read-only context, console logging, and a utils helper library. Return a value to produce the node's output. See the JavaScript Executor reference.

Details

How do I pass just one field from one node to another? Add a dataPath to the edge. It is resolved against the source node's output using dot/bracket notation (for example user.email or items[0].id). Without a dataPath, the entire value at the source port is passed.

Details

Which operators are available to me? Open the node library in the task editor and browse the Tools category. The available operators depend on what is enabled in your space and deployment. Use the search box to find an operator by name or description.

Next Steps​