Why TOON Beats JSON for LLM Data Exchange: Token Savings and Accuracy Gains

Why JSON Falls Short in the LLM Era

JSON, introduced in 2001, is concise for deterministic parsers but becomes token‑heavy when communicating with token‑based LLMs; a simple three‑user example consumes 123 tokens because keys, brackets, and quotes are repeated.

Introducing TOON

TOON (Token‑Oriented Object Notation) is a data‑serialization format designed for AI workloads. Its core principle is to eliminate redundancy by declaring structure once and streaming only raw values.

users[3]{id,name,email}:
  1,Alice,[email protected]
  2,Bob,[email protected]
  3,Charlie,[email protected]

More compact : removes repeated keys and most punctuation.

More readable : tabular layout is easier for humans.

Token‑efficient : same data uses 30‑60% fewer tokens.

Built‑in validation : length marker (e.g., [3]) helps LLM verify completeness.

TOON Syntax Rules

Object representation uses indentation instead of braces:

user:
  id: 1
  name: Alex
  active: true

Basic arrays declare length and values: tags[3]: admin,ops,dev Unified object arrays combine structure and rows:

products[3]{sku,name,price}:
  A1,Widget,9.99
  B2,Gadget,14.5
  C3,Doohickey,4.25

Nested objects and non‑unified arrays follow YAML‑style conventions.

Benchmark Results

Accuracy : TOON reaches 100% on gemini‑2.5‑flash versus 72.2% for JSON.

Token consumption : both prompt and completion tokens drop significantly.

Overall performance : average accuracy advantage of 33% and token reduction over 30% across five major AI models.

Python Code Example

Using the ptoon library:

import ptoon

data = {"users": [{"id": 1, "name": "Alice", "role": "Engineer"},
                 {"id": 2, "name": "Bob", "role": "Designer"}]}

toon_str = ptoon.encode(data)
print(toon_str)
# users[2]{id,name,role}:
#   1,Alice,Engineer
#   2,Bob,Designer

decoded = ptoon.decode(toon_str)
assert decoded == data

result = ptoon.estimate_savings(data)
print(f"Savings: {result['savings_percent']:.1f}%")  # 35.7%

Real‑World Scenario

When asking GPT to analyze an employee table and compute average salaries, the token counts were:

+-----------+----------------+-------------------+-------------------+
| Type      | Prompt Tokens  | Completion Tokens | Duration          |
+-----------+----------------+-------------------+-------------------+
| JSON      | 1344           | 3475              | 00:00:28.3932721  |
| TOON      | 589            | 2928              | 00:00:23.4953152  |
+-----------+----------------+-------------------+-------------------+

This reflects a ~56% reduction in prompt tokens and a noticeable 5‑second speed gain while preserving output quality.

Compound Token‑Saving Effect

Token savings grow non‑linearly: 3 rows save ~57%, 50 rows ~64.7%, 100 rows even more, because TOON’s structural cost is fixed per block ( {id,name,email}) while JSON repeats structure per row.

Cost example: 1,000 batches of 50‑row tables each month.

JSON: ~2,159,000 tokens → $5.40/month

TOON: ~762,000 tokens → $1.91/month

Monthly saving: $3.49 (annual $41.88)

When to Use TOON vs. JSON

Use TOON for structured data exchange with LLMs, token‑cost reduction, reliable structured output, and tabular datasets.

Stick with JSON for deeply nested or highly irregular objects, strict API contracts, or very small payloads (< 100 tokens) where overhead outweighs benefits.

Ecosystem and Getting Started

Python: ptoon (install via pip install ptoon)

.NET: ToonSharp

Go: gotoon

Install the language‑specific package.

Replace JSON serialization with TOON encoding.

Measure token savings and accuracy changes.

Gradually expand to other data‑transfer scenarios.

Looking Ahead

TOON illustrates a shift from "machine‑parseable" to "model‑friendly" data formats, a trend likely to produce more specialized serialization schemes as AI becomes deeper in applications.