> ## Documentation Index
> Fetch the complete documentation index at: https://docs.noclick.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Filter, split, and merge

> Shape lists with the Filter node, fan them out with Split Out, and combine branches with the Merge node.

## Filter

The Filter node transforms a list or object. Pick an operation; the config shows only the fields that operation needs. The result lands in the output's `filtered` field, with a `count`.

| Operation             | What it does                     | Key fields                                                                                      |
| --------------------- | -------------------------------- | ----------------------------------------------------------------------------------------------- |
| **Filter Array**      | Keep items matching a condition  | **Field to Filter** (for arrays of objects), **Operator**, **Filter Value**, **Case Sensitive** |
| **Remove Duplicates** | Drop repeated items              | **Deduplication Field** (optional, compares whole items if empty)                               |
| **Limit**             | Keep the first N items           | **Limit**, **Offset** (skip before limiting)                                                    |
| **Sort**              | Order items                      | **Sort Field**, **Sort Order** (ascending/descending)                                           |
| **Filter Object**     | Keep or remove keys on an object | **Keys to Keep**, **Keys to Remove** (comma-separated)                                          |
| **Group by Field**    | Bucket items by a field value    | **Group By Field**                                                                              |
| **Split String**      | Turn a string into a list        | **Delimiter**, **Trim Whitespace**                                                              |

Filter Array operators include equals, contains, starts/ends with, greater/less than (and or-equal), is empty / not empty, regex match, and in list / not in list (comma-separated values).

**Example:** Filter Array on `{{rss-1.items}}` with **Field to Filter** `title`, **Operator** contains, **Filter Value** `AI`.

## Split Out

The Split Out node turns a list into one item per element, so a downstream loop or node can handle each entry on its own. It outputs the elements in `items`, with a `count`.

| Field                      | What it does                                                                                                                                                                                 |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Input Data**             | The data to split: an array, or an object that holds the array field. Reference it like `{{node-id.items}}`.                                                                                 |
| **Fields To Split Out**    | The field holding the array. Use dot notation for nested fields, and comma-separate to split several fields at once (they zip by index). Leave empty when **Input Data** is itself an array. |
| **Include**                | Which of the input's other fields to keep on each output item: **No Other Fields**, **All Other Fields**, or **Selected Other Fields**.                                                      |
| **Fields To Include**      | When **Include** is **Selected Other Fields**, the comma-separated field names to keep.                                                                                                      |
| **Destination Field Name** | Rename the split field on each output item (single field only).                                                                                                                              |

**Example:** Split Out with **Input Data** `{{http-1.response.results}}` and **Fields To Split Out** empty turns a results array into one item per result, ready to feed a [loop](/logic/loops).

## Merge

The Merge node combines data from multiple input branches into one list. It waits for all connected branches, pulls the list out of each input (it looks for common fields like `data`, `items`, `filtered`, `collected_results`), and outputs the result as `merged`.

| Operation               | What it does                                   | Key fields                                                                  |
| ----------------------- | ---------------------------------------------- | --------------------------------------------------------------------------- |
| **Append**              | Concatenate all inputs into one list           | none                                                                        |
| **Combine by Position** | Zip inputs together by index                   | none                                                                        |
| **Combine by Field**    | Join inputs on a shared field, like a SQL join | **Match Field**, **Conflict Resolution** (prefer first, prefer last, merge) |
| **Keep Matches**        | Keep only items present in every input         | **Match Field** (optional)                                                  |
| **Remove Duplicates**   | Union of all inputs, deduplicated              | **Deduplication Field** (optional)                                          |

**Example:** two API branches fetch users and subscriptions; Combine by Field on `email` joins them into one enriched list.

## Next steps

* [Loops](/logic/loops)
* [Branching](/logic/branching)