# Condition (/docs/nodes/utility/condition)

Multi-path branching based on rules and named routes.



The Condition node evaluates one expression against a list of rules, then sends the run down the matching route. Unlike Filter, which only passes or blocks execution, Condition can create multiple named output handles such as `high`, `low`, `buy`, `sell`, or `other`.

Configuration [#configuration]

| Field          | Type           | Required | Description                                                            |
| -------------- | -------------- | -------- | ---------------------------------------------------------------------- |
| Node Label     | text           | No       | Display name shown on the canvas                                       |
| Response Name  | text           | Yes      | Name used by downstream nodes, such as `{conditionResponse.route}`     |
| Expression     | template       | Yes      | The upstream value to evaluate, such as `{birdeyeResponse.data.value}` |
| Rules          | visual builder | Yes      | One or more operator, value, and route rows                            |
| Fallback Route | text           | No       | Route to use when no rule matches                                      |

Rule format [#rule-format]

Each rule compares the node's Expression to a value and directs the run to a route:

```json
[
  { "operator": "greater_than", "value": "150", "route": "high" },
  { "operator": "less_than", "value": "100", "route": "low" }
]
```

If the Expression is above 150, the `high` route executes. If it is below 100, the `low` route executes. If no rule matches, the Fallback Route executes. If no fallback route is set, unmatched runs use `default`.

The rule value can also use a variable, such as `{settingsResponse.maxPrice}`, if you want to compare one upstream value against another upstream value.

Operators [#operators]

| Operator                | Use it for                                        |
| ----------------------- | ------------------------------------------------- |
| `equals`                | Exact matches                                     |
| `not_equals`            | Anything except one exact value                   |
| `contains`              | Text or list-like values that include a substring |
| `greater_than`          | Numeric value is higher than the rule value       |
| `less_than`             | Numeric value is lower than the rule value        |
| `greater_than_or_equal` | Numeric value is at least the rule value          |
| `less_than_or_equal`    | Numeric value is at most the rule value           |

Connecting routes [#connecting-routes]

Each complete rule creates a named output handle on the node. The fallback route also creates a handle when you enter one. Connect each handle to the downstream node that should run for that branch.

For example:

* Connect `high` to a Telegram alert.
* Connect `low` to a buy workflow.
* Connect `other` to a Log node.

Output [#output]

When a rule matches:

```json
{
  "route": "high",
  "value": "175.32",
  "matchedRule": {
    "route": "high",
    "operator": "greater_than",
    "value": "150"
  },
  "evaluatedAt": "2026-05-14T10:00:00.000Z"
}
```

If the rule value itself was a template (for example `{settingsResponse.maxPrice}`), the resolved comparison value also appears under `matchedRule.resolvedValue`.

When no rule matches, `matchedRule` is omitted and `route` is the Fallback Route (or `"default"` if no fallback is set):

```json
{
  "route": "default",
  "value": "120.5",
  "evaluatedAt": "2026-05-14T10:00:00.000Z"
}
```

Downstream nodes read the Condition result with the response name:

```text
{conditionResponse.route}
{conditionResponse.value}
{conditionResponse.matchedRule.operator}
```

Common use cases [#common-use-cases]

* Route different price ranges to different actions
* Branch based on AI sentiment analysis results
* Handle success vs. error paths from upstream nodes

Next steps [#next-steps]

* [Filter](/docs/nodes/utility/filter) - simple pass/block filtering
* [Edges](/docs/concepts/edges) - how branching connections work