Transform - JSON → TOON

TOON (Token-Oriented Object Notation) is a text format for representing the same data as a JSON, designed to use fewer tokens when that text is sent inside a prompt to a language model (LLM). Tokens are the unit services like ChatGPT or Claude bill and cap — the fewer tokens a prompt uses, the cheaper it is and the more room is left for the rest of the conversation.

JSON spends a good chunk of those tokens on punctuation that repeats: braces, brackets, quotes around every piece of text and, in a list of similar objects, each field's name copied in every item. TOON removes that repetition.

The core idea: when a list has several objects with the same fields, TOON writes the field names once, in a header, and each item becomes a single line with just the values, separated by commas, like a CSV table. For nested objects, it uses indentation, YAML-style.

{
  "users": [
    { "id": 1, "name": "Ana", "role": "admin" },
    { "id": 2, "name": "Beto", "role": "user" },
    { "id": 3, "name": "Cátia", "role": "user" }
  ]
}

users[3]{id,name,role}:
  1,Ana,admin
  2,Beto,user
  3,Cátia,user

In this example, the JSON is 167 characters and the TOON is 66 — about 60% smaller (this page's character count, computed with the real converter; the token savings for an LLM usually range between 30% and 60%, per the format's spec, varying with the size and shape of the data).

• users[3] says the list has 3 items — the model (and whoever's reading) knows upfront how many rows to expect, which helps catch a missing item.
• {id,name,role} is the header: each field's name appears once, not in every item.
• Every line after that is one item, in the same order as the header's fields.

Not every JSON fits that table shape. When a list's items have different fields from each other, TOON falls back to a plain list form (one line per item, no table) — still a valid, lossless conversion, just with much less token savings:

{
  "events": [
    { "type": "login", "userId": 1 },
    { "type": "purchase", "userId": 2, "amount": 49.9, "coupon": "PROMO10" },
    { "type": "logout", "userId": 1, "durationMin": 12 }
  ]
}

events[3]:
  - type: login
    userId: 1
  - type: purchase
    userId: 2
    amount: 49.9
    coupon: PROMO10
  - type: logout
    userId: 1
    durationMin: 12

• Worth it: large, uniform lists (same fields in every item) inside a prompt for an LLM — search results, spreadsheet rows, database records, a history of similar events.
• Small gain: deeply nested data, lists with few items, or items with an irregular shape.
• Don't use it: to talk to an API, save to a database, or anywhere that expects real JSON — TOON is meant for the text inside the prompt, not as a replacement for JSON as an integration format.

Here is the list of active users:

users[3]{id,name,role}:
  1,Ana,admin
  2,Beto,user
  3,Cátia,user

List the users with the "user" role.

1. Choose JSON → TOON to compress a JSON before pasting it into a prompt, or TOON → JSON for the reverse (for example, if a model replied in TOON and you want the JSON back).
2. Paste the content into the input field and click Transform.
3. Under Options, you can switch the column delimiter (comma, tab or pipe) — useful if your data already uses commas inside the values.

Transform converts data and code from one format to another without leaving your browser. Paste a JSON and get back the matching TypeScript interfaces, Zod schema or JSON Schema; convert config files between YAML, JSON and TOML; turn CSS into Tailwind classes. Everything is processed locally, without sending your content to any server.

1. Click the Transformation picker and choose the conversion. You can search by name, and your recently used and favorited ones stay within reach.
2. Paste the content into the Input field (or use the Paste button). For JSON, the Format button indents the text.
3. If the conversion has options, like the root type's name, adjust them in the panel above the editors.
4. Click Transform. The result appears in Output, where you can copy it or download the file.

The JSON → TypeScript conversion reads the JSON's structure and generates an interface for each object, including nested ones. This is the tool's real output for the JSON below:

{
  "id": 1,
  "name": "Ana Souza",
  "email": "ana@example.com",
  "active": true,
  "tags": ["admin", "beta"],
  "address": { "city": "São Paulo", "zip": "01310-100" }
}

interface Address {
  city: string;
  zip: string;
}

interface User {
  id: number;
  name: string;
  email: string;
  active: boolean;
  tags: string[];
  address: Address;
}

Need to validate the data at runtime, not just type it? The same input can become a Zod schema by choosing JSON → Zod in the picker.