# Chunk list into batches

Split pasted lines or comma-separated items into fixed-size chunks for batching APIs, imports, prompts, and review queues.

## Run it

- **CLI:** `gizza tool chunk-list "alpha
beta
gamma
delta
epsilon"`
- **Web:** https://gizza.ai/tools/chunk-list/
- **Agents:** machine-readable descriptor (parameters JSON Schema) at https://gizza.ai/tools/chunk-list/tool.json

## Inputs

- `items` — Items _(field)_
- `input_separator` — Input separator _(field)_
- `custom_separator` — Custom separator _(field)_
- `chunk_size` — Chunk size _(field)_
- `output` — Output _(field)_
- `label_chunks` — Label chunks _(field)_

## Output

- Chunks (text)

## Query parameters

Open the tool pre-filled and auto-run via URL:

- `items` — Items
- `input_separator` — Input separator
- `custom_separator` — Custom separator
- `chunk_size` — Chunk size
- `output` — Output
- `label_chunks` — Label chunks

Example: `https://gizza.ai/tools/chunk-list/?items=alpha%0Abeta%0Agamma%0Adelta%0Aepsilon&input_separator=auto&custom_separator=%20%3A%3A%20&chunk_size=10&output=plain&label_chunks=true`

---

## About this tool

Chunk a list into fixed-size batches when a service, import job, prompt, or review
workflow has a practical limit. Paste one item per line, a comma-separated list,
a tab-separated spreadsheet column, or pipe/semicolon/custom-separated text. The
tool trims whitespace, drops blank entries, keeps the original order, and puts
any remainder in the final chunk.

Plain text output is useful for copying batches into tickets or prompts. CSV puts
one chunk on each row for spreadsheets. JSON is convenient for scripts, and
Markdown turns each chunk into a small checklist.

Worked example:

1. Paste `alpha`, `beta`, `gamma`, `delta`, and `epsilon` on separate lines.
2. Set chunk size to `2`.
3. Choose plain text output with labels on.
4. Copy the three batches: two pairs plus the final single item.

Limits and edge cases: chunk size must be at least 1 and at most 1,000,000. A run
can split up to 200,000 items. Auto-detect splits on newlines, commas,
semicolons, tabs, and pipes, so choose an explicit separator when an item itself
contains one of those characters.

## FAQ

<details>
<summary>Does auto-detect preserve commas inside an item?</summary>

No. Auto-detect treats commas as separators. If your items can contain commas,
choose newline, tab, pipe, or custom separator and paste the list in that form.

</details>

<details>
<summary>What happens when the list length is not divisible by the chunk size?</summary>

The final chunk contains the remainder. For example, five items with chunk size
`2` become chunks of `2`, `2`, and `1` item.

</details>

<details>
<summary>Can I output chunks for a spreadsheet?</summary>

Yes. Choose CSV output. Each chunk becomes one CSV row; fields containing commas,
quotes, or newlines are quoted using standard CSV escaping.

</details>

<details>
<summary>How do custom separators handle typed escapes?</summary>

The custom separator field understands `\n`, `\t`, `\r`, and `\\`, so you can type
`\n---\n` for a multi-line divider or `\t` for a tab.

</details>

## Related tools

- [Extract Action Items from Meeting Notes](https://gizza.ai/tools/action-item-extractor/): Extract action items, owners, and decisions from meeting notes or daily notes with deterministic rules. Markdown checklist or JSON, private in-browser.
- [Add Line Numbers](https://gizza.ai/tools/add-line-numbers/): Add line numbers to every line of text online, like nl or cat -n — custom start, step, separator, and alignment. Free and private, runs in your browser.
- [ANSI Log Renderer](https://gizza.ai/tools/ansi-log-renderer/): Paste ANSI-colored terminal output or CI logs and render them as HTML, or strip escape codes to plain text. Handles 16-color, 256-color, and truecolor SGR codes.
- [API response diff](https://gizza.ai/tools/api-response-diff/): Compare two JSON API responses and see only the meaningful changes: ignore request ids, timestamps and UUIDs, match arrays by key or as sets, export a JSON Patch.
- [Rust AST Diff](https://gizza.ai/tools/ast-diff/): Compare two Rust source snippets structurally. The tool parses both files, canonicalizes their ASTs, and ignores formatting, whitespace, and comments.