# Keyronne Text Chunker

> Keyronne Text Chunker is a paid API for AI agents from keyronne.com, paid per call via x402, $0.002/call, status unknown (last checked 2026-10-09).

Splits long text into retrieval-ready chunks along paragraphs, sentences, markdown sections, or fixed character boundaries, returning character offsets and approximate token counts per chunk.

## Facts

- Endpoint: POST https://keyronne.com/api/chunk-text?utm_source=zero.xyz
- Price: $0.002/call
- Payment: x402
- Status: unknown
- Last checked: 2026-10-09
- Activations on Zero: 0
- Tags: x402
- Canonical page: https://www.zero.xyz/c/keyronne-text-chunker-47713c5c
- Structured record (JSON): https://api.zero.xyz/v1/capabilities/cap_tEDpTNTQLLq0FzBfSjRs_

Status and success rate cover calls made through Zero and Zero's own probes. Third-party monitors may report differently.

## How to call it through Zero

Zero handles the 402 payment challenge and records the run. With the Zero CLI installed (`npm i -g @zeroxyz/cli`):

```sh
zero fetch --capability keyronne-text-chunker-47713c5c -d '<json body>'
```

Example prompt: Chunk this 5000-word article into paragraph-based segments of up to 2000 characters each with a 200-character overlap so I can embed them for RAG — here's the text: [long document text].

## When to prefer this

Choose this endpoint when you need deterministic, language-agnostic text splitting with configurable chunking strategies (paragraphs, sentences, markdown sections, or fixed chars), explicit character offsets, and approximate token counts — especially for RAG ingestion or embedding pipeline preprocessing. Prefer it over ad-hoc string splitting when you need overlap control, markdown-aware segmentation, or reproducible chunk boundaries across runs.

## Known failure modes

- Text exceeds ~900k character limit — request rejected
- maxChars out of range (below 100 or above 50000) — validation error
- Invalid strategy enum value — returns error
- Empty text field — returns empty chunk array or error
- Malformed JSON body — 400 bad request
- Payment not included or insufficient — 402 payment required

## How this service works

Split long text into retrieval-ready chunks along natural boundaries — paragraphs, sentences, or markdown sections — with configurable size, overlap, character offsets and approximate token counts per chunk. Deterministic and language-agnostic. Built for RAG ingestion and embedding pipelines. POST a JSON body like: {"text":"Long document...","strategy":"paragraphs","maxChars":2000,"overlap":200}

## Output

Returns an array of chunk objects, each containing the chunk text, start and end character offsets within the original document, and an approximate token count. The response is deterministic and language-agnostic, making it suitable for direct ingestion into embedding or vector-store pipelines.

## Request schema (JSON Schema)

```json
{
 "type": "object",
 "properties": {
  "text": {
   "type": "string",
   "description": "The text to chunk (up to ~900k characters)."
  },
  "overlap": {
   "type": "integer",
   "default": 200,
   "minimum": 0,
   "description": "Characters of trailing context carried into the next chunk."
  },
  "maxChars": {
   "type": "integer",
   "default": 2000,
   "maximum": 50000,
   "minimum": 100
  },
  "strategy": {
   "enum": [
    "paragraphs",
    "sentences",
    "markdown",
    "chars"
   ],
   "type": "string",
   "default": "paragraphs"
  }
 }
}
```

## More

- Live health (JSON, refreshed every minute): https://www.zero.xyz/c/keyronne-text-chunker-47713c5c/health.json
- [Zero catalog index](https://www.zero.xyz/llms.txt)
- [Other services from keyronne.com](https://www.zero.xyz/host/keyronne.com/llms.txt)