AI · Explain JSON

Explain JSON with AI

Paste an unfamiliar payload and get a field-by-field explanation of what every value means: its purpose, type, and relationships.

Try it in the Editor

1,000 free AI credits on signup · Core tools run locally

Explain JSON

Explain with AI in editor

Input

Result

AI CopilotExample output

What this payload means, field by field:

event"charge.succeeded" — a Stripe-style webhook event type: a payment completed successfully.

id"evt_1P9x" — unique id of this event object (the evt_ prefix marks an event).

created1712345678 — Unix timestamp in seconds; April 5, 2024 UTC.

data.object.amount2400 — the charge in the smallest currency unit: $24.00.

data.object.currency"usd" — ISO 4217 currency code, lowercase by convention.

data.object.capturedtrue — funds were captured immediately, not merely authorized.

data.object.payment_method"pm_1K" — id of the payment method used (pm_ prefix).

data.object.risk_score12 — fraud-risk score on a 0–100 scale; 12 is low risk.

livemodefalse — generated with test keys; no real money moved.

Pre-written example — continue with a free account to run it live (1,000 credits included).

Runs entirely in your browser — nothing is uploaded.

{"event":"charge.succeeded","id":"evt_1P9x","created":1712345678,"data":{"object":{"amount":2400,"currency":"usd","captured":true,"payment_method":"pm_1K","risk_score":12}},"livemode":false}

Explain JSON is an AI Copilot action that reads a payload and returns a plain-English summary plus a field-by-field breakdown: each key’s type, likely purpose, and how it relates to the rest of the document. It is built for JSON you did not write, like an unfamiliar API response or a config file. Unlike JSON Copilot’s browser-only tools, Explain sends your JSON to an AI model and uses credits; new accounts get 1,000 free credits on signup.

Example: a decoded token, explained

Input · unfamiliar JSON

{
  "sub": "usr_8f2a91",
  "iss": "https://auth.example.com",
  "aud": "api://billing",
  "iat": 1719763200,
  "exp": 1719766800,
  "scope": ["invoices:read", "invoices:write"],
  "email_verified": true
}

Output · field-by-field explanation

Summary: a decoded JWT access token issued for a
billing API session.

sub   string  Subject — the unique user ID the token
              was issued for (usr_8f2a91).
iss   string  Issuer — the auth server that signed
              the token.
aud   string  Audience — the API this token is
              allowed to call.
iat   number  Issued-at, a Unix epoch timestamp
              (2024-06-30 16:00 UTC).
exp   number  Expiry, Unix epoch — valid for one hour
              after iat (17:00 UTC).
scope array   Granted permissions: read and write
              invoices.
email_verified boolean  Whether the user's email was
              confirmed at sign-in.

Explain turns cryptic keys — iss, aud, iat — into readable notes, and flags the value types so you know what to map into your own code.

How to explain JSON with AI

1
Sign in and paste your JSON
Open the editor and sign in — new accounts get 1,000 free credits. Paste the payload you want explained; it can be a raw API response or a config file you inherited.
2
Open the AI Copilot panel
Switch to the AI Copilot sidebar next to the editor and choose the Explain JSON action from the list of AI modes.
3
Review the estimate and run
Explain shows an estimated credit cost based on the payload size before it sends anything. Confirm to run; the unused portion of the estimate is refunded.
4
Read the summary and field breakdown
You get a short overview of what the document represents, then a per-field explanation covering each value’s type, purpose, and relationships.
5
Jump to any field
Click a field in the explanation to highlight it in the Monaco editor and the mind map, so you can locate it inside a large payload.

What you get

Plain-English summary

A concise overview of what the whole document represents before you read the details.

Field-by-field detail

Each key gets its value type, likely purpose, and relationship to sibling and parent fields.

Understands nesting

Deeply nested objects and arrays are described in context rather than flattened into noise.

Two-way highlighting

Click a field in the result to focus it in the editor and the mind map view.

Upfront credit estimate

See the estimated cost before the action runs, and get the unused part of the estimate refunded.

Explicit, opt-in sending

Your JSON only leaves the browser when you run Explain — formatting and validation stay local.

What "explain JSON" actually does

JSON Copilot’s client-side tools describe structure. The formatter re-indents your document, the validator checks it against the JSON grammar (RFC 8259), and the tree viewer lays out nesting so you can collapse and expand branches. None of them tell you what a field means. Explain JSON fills that gap: it reads the document and returns an interpretation in plain English rather than a reshaped version of the same bytes.

The action produces two things. First, a short summary that names what the document as a whole represents — an access token, a user record, a webhook event, and so on. Second, a field-by-field breakdown where each key is annotated with its value type, its probable purpose, and how it connects to neighbouring fields. Arrays and nested objects are explained in context, so a value three levels deep is described in relation to its parent.

The model infers meaning from field names, value patterns, and widespread conventions. Cryptic JWT claims such as iss, sub, and aud, Unix epoch timestamps, ISO 8601 dates, and enum-like strings are the kinds of things it recognises reliably. For custom or opaque keys it makes a reasoned guess, which is why Explain is best treated as fast orientation rather than an authoritative spec.

When to reach for Explain JSON

The most common use is an unfamiliar third-party API response. When you integrate a new service, the payload often arrives before you have read the docs — or the docs are thin. Pasting the response and running Explain gives you a working mental model of the fields in seconds, so you know which ones to map into your own types and which to ignore.

It is also useful for onboarding and handoffs. A config file, a serverless event, or an application-state dump written by someone else can be opaque to a new team member. Explain turns it into annotated prose that reads like inline documentation, which is faster than tracing each key back through the codebase.

Debugging is the third case. When a webhook fires an event you did not expect, or an error object carries fields you have never seen, Explain helps you separate signal from noise. Pair it with the tree viewer to navigate structure and the mind map to see relationships, then use Explain to interpret the values that actually matter.

How AI credits work

Most of JSON Copilot is free and needs no account: formatting, minifying, syntax validation, the tree viewer, and the mind-map preview all run in your browser. Flatten and JSON Schema generation are deterministic Copilot actions that run on JSON Copilot's own server (no AI model involved) and cost a small number of credits with a free account. Explain JSON and JSON-to-documentation are different because they call an AI model, and model calls cost credits. New accounts receive 1,000 free credits on signup to try the AI actions.

Credit cost scales with the size of the payload you send rather than being a flat per-run fee, so a small object is cheap and a large, deeply nested document costs more. Before anything is sent, the editor shows an estimate based on the payload; when the action finishes, the unused portion of that estimate is refunded, so you are charged only for what the model actually processed.

A few habits stretch credits further. Validate and fix syntax first so the model is not working on a broken document. Minify or trim boilerplate you do not need explained. And for very large files, explaining a representative slice — one array element rather than a thousand — is usually both cheaper and clearer than sending the whole thing.

Privacy: what Explain sends, and what stays local

Explain JSON is an AI feature, and running it transmits your JSON to an AI model for analysis — a real network request that carries your data off your machine. That is the opposite of JSON Copilot’s core tools: format, minify, validate, tree view, and the mind-map preview all execute entirely in your browser and never upload anything.

Nothing is sent until you explicitly run the action, and you see the credit estimate first, so there is no background transmission while you type or paste. Still, treat the boundary seriously: if a payload contains secrets, access tokens, or personal data, redact or replace those values before running Explain, or stay on the client-side tools, which keep the document local by design.

A practical pattern is to use the browser-only tools for sensitive production data and reserve Explain for sample payloads, fixtures, and documentation examples where transmission is not a concern. That way you get AI interpretation where it helps without sending anything you would not want to leave the browser.

Frequently asked questions

Is Explain JSON free to use?

The action uses AI credits rather than being unlimited. New accounts get 1,000 free credits on signup, and each explanation shows an estimated cost before it runs, so there are no surprises.

Is my JSON private when I use Explain?

Explain is an AI action, so when you run it your JSON is sent to our servers for the model to read — but sensitive values are masked on your device first. Detected passwords, API keys, tokens, emails, and card numbers are replaced with placeholders like [MASKED_PASSWORD_1] before anything is sent, so detected values reach the AI only as placeholders. The originals stay in your browser and are put back into the result locally. Detection is pattern-based, so double-check samples that hold secrets under unusual field names. Masking is on by default; manage it in Settings → Privacy & Data.

How is Explain JSON different from formatting or a tree view?

Formatting and the tree viewer show structure — indentation, nesting, and syntax — but not meaning. Explain JSON adds interpretation: it tells you what a field like iss or aud probably represents and why it is there, which structure alone cannot.

What does the field-by-field breakdown include?

For each key you get its value type (string, number, boolean, object, array, or null), a plain-English description of its likely purpose, and notes on how it relates to parent and sibling fields. Nested structures are explained in context.

Can I explain large files or use it offline?

Explain calls an AI model, so it needs an internet connection and does not work offline. Very large payloads cost more and tend to get a higher-level summary, so trimming to the fields or records you actually care about usually gives a sharper result.

How many credits does one explanation cost?

There is no flat fee — cost tracks how much JSON the model has to read, so a small object is cheap and a long, deeply nested document costs more. You always see the estimate before confirming, so nothing runs without your approval.

What kinds of JSON can it explain?

It works on any valid JSON: REST and GraphQL responses, JWT payloads, webhook bodies, package manifests, CI configs, and application state. If the JSON has syntax errors, validate and fix it first so the model reads the intended structure.

Can the AI be wrong about a field?

Yes. Explain infers purpose from field names, values, and common conventions, so for opaque or custom keys its description is a best guess. Treat it as a fast first read and confirm anything critical against the API’s own documentation.

Understand your JSON now

Open the Editor