Filter

The Filter step checks every item in a list on its own. Matching items continue on the KEPT route, and non-matching items go to DISCARDED.

At a glanceVerified in app · Oct 29, 2026

Use it to: Keep or discard items in a list using typed or AI rules
Find it: Tools → Flow → Filter
Cost: Free for typed rules · AI Filter rules use Glow AI tokens
Limits: Up to 100,000 items · Splits a list into Kept and Discarded outputs
Output: {{ N.kept }}, {{ N.discarded }}, {{ N.keptCount }}, {{ N.discardedCount }}
Instead: Conditions (to branch a run) or inline {{ 1.items | where:"status":"paid" }}

Use Filter to trim a list before running downstream Steps. Each route carries its share of the list, and an empty route does not run. See Choosing a Flow Step.

A list arrives:

12 leads · 5 over £10,000

5 itemsKEPT — matched “deal size is over 10,000”Notify sales
7 itemsDISCARDED — the restLog for review

Both routes run, each carrying its own share. That is what makes Filter different from the other two.

Setting it up

Connect the source step and select data

Connect the upstream Step that returns the list (or choose Enter it myself), then click Select data on the first rule to bind FILTERING.

Choose the type and operator

Pick Text, Number, Yes/no, Record, List, or Date & Time, then select an operator from the shared Conditions catalogue.

Add rules and logic

Click Rule to add checks. Under Kept, set Rules to All rules must match (AND), Any rule may match (OR), or custom AND/OR groups.

Point the routes at steps

Select a target Step under KEPT. Assign DISCARDED to handle rejected items, or leave it blank to drop them.

With no rules configured, every item is kept. An unfinished Filter is not a closed gate.

Item tokens, inputs, and edge behavior

Inside Filter rulesFilter Uses $item

{{ $item }} reads the whole current item.
{{ $item.field }} reads a property on that item.
{{ $itemIndex }} reads the 0-based position in the list.

Inside loop StepsLoops Use item (No Dollar Sign)

Run for each item and Repeater use {{ item.field }}.
The two tokens are separate and not interchangeable.
Downstream Steps read {{ N.kept }} after Filter finishes.

Supported inputs

Input	Result
A list	Each item is tested on its own.
A single record	Treated as a 1-item list and output in `kept` or `discarded`.
Valid JSON text	Parsed as a list or record automatically.
Blank, number, or plain text	Fails: “Filter needs a list or record. Connect a step that returns a list, or pick a field that holds one.”

Behavior	How Filter Handles It
Case sensitivity	Ignore capitalisation is off by default (`Active` does not match `active`). Enable it for the whole Step or per rule.
Invalid item values	Unparseable values (such as `"N/A"` in a number rule) count as false, log to `errors` / `totalErrors`, and route to DISCARDED unless an OR group matches.
Empty output routes	If KEPT or DISCARDED receives `0` items, Steps on that route are skipped and the run succeeds.

Describing a rule in words

Set a rule’s type to Plain words (AI Condition) to test items with a natural-language prompt such as "the message sounds like a complaint" (Prompt Examples provides templates). Also available in Conditions; Switch is typed-only.

100 item-rule pair cap: Each AI evaluation makes one model call. Filter allows at most 100 item-rule pairs (list length × AI rules, e.g., 100 items with 1 AI rule or 50 items with 2). Trim larger lists with typed rules first.

What it passes on

Reference	Returns
`{{ N.kept }}`	Matching items (not `results` or `items`).
`{{ N.discarded }}`	Non-matching items, even when DISCARDED is unwired.
`{{ N.keptCount }}`	Count of kept items.
`{{ N.discardedCount }}`	Count of discarded items.
`{{ N.errors }}` / `{{ N.totalErrors }}`	Rule evaluation errors (up to 25 detailed in `errors`, total in `totalErrors`).

Outputs also include keptEdgeId, discardedEdgeId, firedEdgeIds, failedEdgeCount, and error.

Limits

List size: A single Filter step processes up to 100,000 items. Larger lists fail the Step.
Regex budget: 5 seconds cumulative across the list and 250 ms per item. A single-item timeout counts as a rule error; exceeding 5 seconds fails the Step.

Examples to copy

Keep only active users

Setting	Value
Property	`status` (from the user list)
Type	Text
Operator	`is equal to`
Value	`active`

Downstream Steps read {{ N.kept }}.

Drop consumer email domains

Rule	Property	Type	Operator	Value
Rule 1	`email`	Text	`does not end with`	`@gmail.com`
AND	`email`	Text	`does not end with`	`@yahoo.com`

Enable Ignore capitalisation to catch @Gmail.com.

Keep products that are in stock

Setting	Value
Property	`stock_count`
Type	Number
Operator	`is greater than`
Value	`0`

Wire DISCARDED or read {{ N.discarded }} downstream to log out-of-stock items.

Verify it works

Run: Test the Filter Step against a sample list containing both matching and non-matching items.
You should see: The Step outputs {{ N.kept }}, {{ N.discarded }}, {{ N.keptCount }}, and {{ N.discardedCount }} in the Execution log.

What’s Next?

Process each kept item individually with Loops & Iteration.
Route the whole run instead of a list with the Conditions Step.