Split a list into items

Split text into one-item-per-line output using the Split on separator. Default separator is `,`. Empty Split on falls back to default regex `/[\s,;|]+/` which handles whitespace, commas, semicolons, and pipes in one pass. Leading/trailing whitespace inside each item is NOT trimmed - chain trim after if needed.

Input
Ready
Output
Live

Separator-based tokenization

When Split on contains text, it is treated as a literal string (regex-escaped). `apple, banana` split on `,` produces `apple` and ` banana` - note the leading space on the second item. Chain trim to remove it.

When Split on is empty, the op falls back to a default regex `/[\s,;|]+/` that matches any run of whitespace, commas, semicolons, or pipes. Good for ambiguous mixed-delimiter input. Empty tokens (from consecutive separators) are automatically filtered out.

The inverse is Join. To collapse a comma-separated one-liner into a clean one-item-per-line list, use this tool with separator `,` then chain trim for per-item whitespace cleanup.

How to use split a list into items

  1. 1Paste your text into the input panel
  2. 2Set Split on to a literal separator (default `,`)
  3. 3Leave Split on empty to fall back to the multi-delimiter regex `/[\s,;|]+/`
  4. 4Output is one item per line - leading/trailing whitespace is NOT trimmed
  5. 5Chain trim if item-level whitespace matters

Keyboard shortcuts

Drive ListShift without touching the mouse.

Shortcut Action
Ctrl ZUndo last input change
Ctrl Shift ZRedo
Ctrl Shift EnterToggle fullscreen focus on the editor
EscExit fullscreen
Ctrl KOpen the command palette to jump to any tool
Ctrl SSave current pipeline draft Plus
Ctrl PRun a saved pipeline Plus

What this tool actually does

String-split with a sensible multi-delimiter fallback.

Literal separator by default

Split on `,` splits at every literal comma. No regex interpretation of the separator string - `.`, `*`, `+` are matched literally.

Multi-delimiter fallback via empty Split on

Leave Split on empty and the op uses regex `/[\s,;|]+/` - handles whitespace, commas, semicolons, pipes, and any combination. Run lengths collapse, so `a, , b` becomes `a` and `b`.

Empty tokens dropped

`a,,b` with separator `,` produces `a` and `b` (the empty middle token is filtered).

No trimming

Items keep surrounding whitespace. `a, b, c` split on `,` gives `a`, ` b`, ` c`. Chain trim to remove.

Inverse of Join

Join combines items with a separator; this tool splits them back out. Round-trip works if the same separator is used both ways.

Worked example

Split on `,`. Note: output items keep leading space (no trim). Chain trim to get cleaner items.

Input
apple, banana, cherry, date
Output
apple
 banana
 cherry
 date

Settings reference

How each option shapes the output using the sample above.

Setting What it does Effect on the sample
Split on: `,` (default) Literal comma match `apple` / ` banana` / ` cherry` / ` date` (leading spaces kept)
Split on: `, ` (comma + space) Literal match consumes both `apple` / `banana` / `cherry` / `date`
Split on: empty Fallback to regex `/[\s,;|]+/` `apple` / `banana` / `cherry` / `date` (handles any mix of the delimiters)
Split on: ` ` (space only) Splits at each space `apple,` / `banana,` / `cherry,` / `date` (comma stays with token)
Empty tokens (automatic) Filtered from output Consecutive separators do not produce blank lines

FAQ

How do I split on whitespace?
Leave Split on empty for the built-in multi-delimiter regex (handles whitespace + common delimiters). Or put a single space / tab in Split on for literal whitespace matching.
Are leading spaces in items trimmed?
No. `a, b` split on `,` gives `a` and ` b` (with leading space). Chain trim after to strip per-item whitespace.
Does Split on interpret regex metacharacters?
No - the separator is regex-escaped before splitting. `.` splits at literal dots, not "any character". For regex-based splitting, use Replace to convert your regex pattern to a simple separator first, then split.
Why are consecutive separators not producing empty lines?
Empty tokens are filtered via `.filter(Boolean)` - `a,,b` becomes `a` and `b` in a single step.
How do I reverse a split?
Use Join with the same separator.