Conditional Node

The Conditional node splits your workflow into two paths — True and False — based on rules you define. Data flows to one branch or the other depending on whether the conditions pass. It does not modify data; it is purely a router.

The node forwards all its inputs to whichever branch fires. Downstream nodes receive the data nested under the active edge label — for example, inputs['condition_output_false']['condition_input'] where condition_output_false is the edge label on the outgoing connection and condition_input is the edge label on the incoming connection.

How the Two Branches Work

The Conditional node always has two output handles on the right side:

• True (green handle, top) — data flows here when the conditions pass.
• False (red handle, bottom) — data flows here when the conditions fail.

You connect different downstream nodes to each handle. Only one branch fires per execution — the other is skipped entirely. This is how you build "if this, do that; otherwise, do something else" logic in your workflow.

In this example, the LLM analyzes market data and responds with text. The Conditional checks if the response contains "BUY". If it does, the True branch fires and places an order. If not, the False branch fires and sends an email alert instead.

You don't have to use both branches. If you only care about one outcome — for example, only place a trade when the signal is strong — you can leave the False handle unconnected. The workflow simply ends on that path.

Configuration

Operators

Field Paths

Field paths let you reach into nested data structures:

Click Show suggestions in the Field input to auto-discover all available paths from connected upstream nodes.

Data Nesting

The Conditional node forwards all its inputs to the active branch. The execution engine nests this output under the outgoing edge label, so downstream nodes receive data one level deeper:

inputs received by downstream Function node:
{
  "condition_output_false": {        ← label of the edge from Conditional → this node
    "condition_input": {             ← label of the edge from upstream node → Conditional
      "result": "value",
      ...
    }
  }
}

Access upstream data in a Function node as:

def main(inputs, workflow_variables=None, global_variables=None):
    # condition_output_false = outgoing edge label, condition_input = incoming edge label
    data = inputs['condition_output_false']['condition_input']
    return {'value': data['result']}

Use Case: Trade Only When RSI Is Oversold

Check if RSI is below 30 before placing a buy order. If RSI is healthy, send a Telegram alert instead.

Condition setup:

• Field: price_data.data.prices[0].indicators.rsi
• Operator: Less Than
• Value: 30
• Type: Number

When the RSI is 28, the True branch fires and buys BTC. When the RSI is 55, the False branch fires and sends the Telegram message.

Use Case: Route on LLM Recommendation

Check if an LLM's free-text response contains a specific keyword.

Condition setup:

• Field: llm.output
• Operator: Contains
• Value: BUY
• Type: Text

The Contains operator converts both sides to strings, so it works on the LLM's full text response. If the LLM says "ACTION: BUY", the True branch fires. If it says "ACTION: HOLD", the False branch fires.

Use Case: Multi-Condition Gate

Require multiple signals to align before acting. This prevents trades based on a single weak indicator.

Condition setup (Logic: AND):

1. Field: price_data.data.prices[0].indicators.rsi, Operator: Less Than, Value: 30, Type: Number
2. Field: price_data.data.prices[0].current, Operator: Less Than, Value: 60000, Type: Number

With AND logic, both conditions must be true. The True branch only fires when RSI is below 30 and price is under $60k. If either condition fails, the False branch fires.

Switch to OR logic if you want the True branch to fire when any condition passes.

Use Case: Compare Two Fields Dynamically

Instead of comparing against a hardcoded value, compare two fields from the same input data.

Example — current price vs. open price:

• Field: price_data.data.prices[0].current
• Compare Mode: Another Field
• Compare Field: price_data.data.prices[0].candles[0].open
• Operator: Greater Than
• Type: Number

This evaluates to True when the current price is above the candle's open price — no hardcoded values needed. Useful for detecting intraday trends.

Common Routing Examples

Output

The Conditional node forwards its inputs unchanged to the active branch. The execution engine wraps the output under the outgoing edge label, so downstream nodes see data nested as inputs['<outgoing_edge>']['<incoming_edge>'].

Next Steps

• LLM Node — Generate analysis text to route with the Conditional.
• Function Node — Parse or transform data before conditional evaluation.
• Exchange Node — Place trades on the True branch.
• Price Data Node — Fetch market data to evaluate conditions against.
• Email Node — Send alerts on either branch.