BackVishal Raut
AILLMData FormatCost Optimization

TOON: The Data Format That Cuts Your LLM Costs in Half

Introducing Token-Oriented Object Notation - A Revolutionary Format for the AI Era

15 Nov 202515 min read
TOON: The Data Format That Cuts Your LLM Costs in Half

Introduction: The Hidden Cost of AI Development

If you're building AI-powered applications in 2025, you've probably noticed something: your LLM API bills are getting expensive. Really expensive.

Every time you send data to ChatGPT, Claude, or any other Large Language Model, you're paying per token. And here's the problem: the data format we all use—JSON—is incredibly verbose. Those curly braces, repeated keys, and extra quotes? They're costing you money with every API call.

What if I told you there's a data format specifically designed to reduce token usage by 40-60% while maintaining full data integrity? Enter TOON (Token-Oriented Object Notation).

What is TOON?

TOON is a compact, human-readable serialization format designed specifically for passing structured data to Large Language Models. Think of it as JSON's token-efficient cousin—it conveys the same information but uses significantly fewer tokens.

Here's a simple comparison:

Standard JSON (58 tokens):

{
  "users": [
    {"id": 1, "name": "Alice", "role": "admin"},
    {"id": 2, "name": "Bob", "role": "user"},
    {"id": 3, "name": "Carol", "role": "user"}
  ]
}

TOON Format (28 tokens):

users[3]{id,name,role}:
  1,Alice,admin
  2,Bob,user
  3,Carol,user

That's 52% fewer tokens for the exact same data.

The Problem TOON Solves

As AI becomes more integrated into our applications, we're sending more data to LLMs than ever before. Whether it's for validation, analysis, transformation, or generation, every character counts.

Real-World Scenario

Imagine you're building an AI-powered customer support system. For each query, you need to send:

  • Customer profile data
  • Previous conversation history
  • Product catalog information
  • Company policies and FAQs

If you're handling 10,000 queries per day, and each query includes 500 tokens of structured data in JSON format, that's 5 million tokens daily just for data transmission.

With TOON, you could reduce that to 2.5 million tokens—saving $25-250 per day depending on your model.

How TOON Works: The Core Concepts

1. Explicit Structure Declaration

Instead of repeating field names for every object in an array, TOON declares the structure once:

users[3]{id,name,role}:

This tells you:

  • Array name: "users"
  • Length: 3 items
  • Fields: id, name, role

2. Tabular Format for Uniform Data

When you have multiple objects with the same structure, TOON uses a CSV-like tabular format:

users[3]{id,name,role}:
  1,Alice,admin
  2,Bob,user
  3,Carol,user

Each row is just the values—no repeated keys, no extra braces.

3. Indentation-Based Nesting

Like YAML, TOON uses indentation to show structure instead of braces:

database:
  host: localhost
  port: 5432
  credentials:
    username: admin
    password: secret123

4. Minimal Punctuation

TOON removes unnecessary syntax:

  • No curly braces for objects (uses indentation)
  • No square brackets for arrays (uses length markers)
  • Fewer quotes (only when necessary)
  • Inline arrays for simple lists: tags[3]: AI,LLM,TOON

TOON's Sweet Spot: Uniform Arrays

TOON excels when you have uniform arrays of objects—multiple items with the same structure. This is incredibly common in real-world applications:

  • User lists: Customer data, employee records, contact lists
  • Transaction logs: Orders, payments, activity feeds
  • API responses: Search results, product catalogs, data tables
  • Configuration files: Server configs, feature flags, environment variables
  • Time-series data: Analytics, metrics, sensor readings

Real-World Examples

Example 1: E-commerce Product Catalog

JSON (892 tokens):

{
  "products": [
    {
      "id": 101,
      "name": "Wireless Mouse",
      "price": 29.99,
      "stock": 150,
      "category": "Electronics"
    },
    {
      "id": 102,
      "name": "USB-C Cable",
      "price": 12.99,
      "stock": 300,
      "category": "Accessories"
    },
    {
      "id": 103,
      "name": "Laptop Stand",
      "price": 45.00,
      "stock": 75,
      "category": "Furniture"
    }
  ]
}

TOON (487 tokens):

products[3]{id,name,price,stock,category}:
  101,Wireless Mouse,29.99,150,Electronics
  102,USB-C Cable,12.99,300,Accessories
  103,Laptop Stand,45.00,75,Furniture

Savings: 45.4% (405 tokens)

Example 2: API Response with Nested Data

JSON (1,247 tokens):

{
  "status": "success",
  "data": {
    "users": [
      {
        "id": 1,
        "username": "alice_dev",
        "email": "alice@example.com",
        "profile": {
          "firstName": "Alice",
          "lastName": "Johnson",
          "age": 28
        },
        "active": true
      },
      {
        "id": 2,
        "username": "bob_admin",
        "email": "bob@example.com",
        "profile": {
          "firstName": "Bob",
          "lastName": "Smith",
          "age": 35
        },
        "active": true
      }
    ]
  },
  "pagination": {
    "page": 1,
    "pageSize": 10,
    "totalPages": 5,
    "totalItems": 47
  }
}

TOON (687 tokens):

status: success
data:
  users[2]:
    - id: 1
      username: alice_dev
      email: alice@example.com
      profile:
        firstName: Alice
        lastName: Johnson
        age: 28
      active: true
    - id: 2
      username: bob_admin
      email: bob@example.com
      profile:
        firstName: Bob
        lastName: Smith
        age: 35
      active: true
pagination:
  page: 1
  pageSize: 10
  totalPages: 5
  totalItems: 47

Savings: 44.9% (560 tokens)

Token Efficiency Benchmarks

Extensive benchmarks across different data structures show consistent savings:

Dataset JSON Tokens TOON Tokens Savings
Employee Records (100 items) 126,860 49,831 60.7%
E-commerce Orders (50 items) 108,806 72,771 33.1%
Time-series Analytics (60 days) 22,250 9,120 59.0%
GitHub Repositories (100 items) 15,145 8,745 42.3%

Average savings: 40-60% across typical use cases

When to Use TOON (And When Not To)

✅ Use TOON When:

  • Sending data to LLMs: Reduce token costs in prompts
  • Uniform arrays: Multiple objects with identical structure
  • High-volume API calls: Savings compound with scale
  • Configuration files: More readable than JSON
  • Data documentation: Easier to scan and understand

❌ Don't Use TOON When:

  • Browser APIs: Stick with JSON for web standards
  • Deeply nested structures: JSON might be more efficient
  • Non-uniform data: Token savings diminish
  • Pure CSV use-cases: CSV is even more compact for flat tables
  • Legacy systems: If JSON is required by existing infrastructure

TOON in Practice: Use Cases

1. LLM Prompt Engineering

Include more context in your prompts without hitting token limits:

Analyze this customer data and provide insights:

customers[5]{id,name,purchases,totalSpent,lastActive}:
  1,Alice Johnson,23,1247.50,2025-11-10
  2,Bob Smith,8,432.00,2025-11-12
  3,Carol White,45,3891.25,2025-11-14
  4,David Brown,12,678.90,2025-11-09
  5,Eve Davis,31,2156.75,2025-11-13

What patterns do you see?

2. AI-Powered Data Validation

Send schemas and data to LLMs for validation with fewer tokens:

Validate this data against the schema:

schema:
  type: object
  required[3]: username,email,age
  properties:
    username:
      type: string
      minLength: 3
    email:
      type: string
      format: email
    age:
      type: integer
      minimum: 13

data:
  username: alice123
  email: alice@example.com
  age: 28

3. Configuration Management

More readable config files that are also LLM-friendly:

app:
  name: Smart Campus System
  version: 2.3.1
  environment: production

database:
  type: PostgreSQL
  host: db.example.com
  port: 5432
  pool:
    min: 2
    max: 10

features[5]: authentication,notifications,analytics,reporting,api

The TOON Ecosystem

Official Tools

  • TOON CLI: Convert between JSON and TOON formats
  • JavaScript/TypeScript Library: Encode and decode in your applications
  • Interactive Playground: Test TOON with your own data
  • Full Specification: Complete format documentation

Community Tools

  • VS Code Extension: Syntax highlighting, validation, and conversion
  • TOON Schema: JSON Schema rewritten in TOON format
  • Online Converters: Web-based JSON ↔ TOON tools

Getting Started with TOON

Installation

# Install TOON CLI
npm install -g @toon-format/toon

# Or use in your project
npm install @toon-format/toon

Basic Usage

// JavaScript/TypeScript
import { encode, decode } from '@toon-format/toon'

const data = {
  users: [
    { id: 1, name: 'Alice', role: 'admin' },
    { id: 2, name: 'Bob', role: 'user' }
  ]
}

// Convert to TOON
const toonString = encode(data)
console.log(toonString)
// users[2]{id,name,role}:
//   1,Alice,admin
//   2,Bob,user

// Convert back to JSON
const jsonData = decode(toonString)
console.log(jsonData) // Original data structure

CLI Usage

# Convert JSON to TOON
toon encode data.json > data.toon

# Convert TOON to JSON
toon decode data.toon > data.json

# Show token statistics
toon encode data.json --stats

Cost Savings Calculator

Let's calculate real-world savings for a typical application:

Scenario: Customer Support AI

  • Daily queries: 10,000
  • Data per query: 500 tokens (JSON)
  • Model: GPT-4 ($0.01 per 1K tokens)

Monthly Costs:

Format Tokens/Month Cost/Month Annual Cost
JSON 150M tokens $1,500 $18,000
TOON (50% savings) 75M tokens $750 $9,000
Savings 75M tokens $750/month $9,000/year

For a medium-sized application, TOON could save $9,000+ annually just on data transmission costs.

TOON vs Other Formats

TOON vs JSON

  • Token efficiency: TOON wins (40-60% savings)
  • Readability: TOON is cleaner for uniform data
  • Ecosystem: JSON has wider support
  • Use case: TOON for LLMs, JSON for APIs

TOON vs YAML

  • Token efficiency: TOON wins (tabular arrays)
  • Readability: Similar (both use indentation)
  • Complexity: TOON is simpler
  • Use case: TOON for LLMs, YAML for configs

TOON vs CSV

  • Token efficiency: CSV wins for pure tables
  • Structure: TOON supports nesting, CSV doesn't
  • Validation: TOON has explicit structure
  • Use case: CSV for flat data, TOON for structured data

The Future of TOON

As AI becomes more integrated into our applications, token efficiency will become increasingly important. TOON represents a shift in how we think about data formats—optimizing not just for machines or humans, but specifically for Large Language Models.

What's Next?

  • Native LLM Support: Future models may understand TOON natively
  • Schema Validation: TOON Schema for type-safe data
  • More Language Support: Libraries for Python, Go, Rust, etc.
  • IDE Integration: Better tooling across all editors
  • Community Growth: More examples, patterns, and best practices

Conclusion: The Token-Efficient Future

TOON isn't trying to replace JSON—it's solving a specific problem: reducing token costs when working with Large Language Models.

If you're building AI-powered applications, dealing with high-volume LLM API calls, or simply want more readable configuration files, TOON offers a compelling alternative that can save you significant money and improve your workflow.

The format is open source, well-documented, and ready to use today. With growing community support and tooling, now is the perfect time to explore how TOON can optimize your LLM workflows.

Resources

Try It Yourself

The best way to understand TOON is to try it. Take some JSON data you're currently sending to LLMs, convert it to TOON, and see the token savings for yourself.

# Quick test
npm install -g @toon-format/cli
toon encode your-data.json --stats

You might be surprised at how much you can save.

Welcome to the token-efficient future. Welcome to TOON.

Share This Article

More Articles