JSON — JavaScript Object Notation — is the standard text format that software uses to exchange structured data. When a weather app asks a server for today's forecast, when a shop's app loads its product list, when your code reads a configuration file, the data almost certainly travels as JSON: human-readable text built from objects, arrays, strings, numbers, booleans and null. This guide explains JSON properly but plainly — what it is, where you will meet it, the rules that trip everyone up, and how to format and fix it with confidence.
Key takeaways
- JSON (JavaScript Object Notation) is a text format for structured data: objects with key–value pairs, arrays, strings, numbers, booleans and null — nothing else.
- It is the default language of web APIs: when an app fetches weather, products or messages, the answer almost always arrives as JSON.
- JSON is strict: keys need double quotes, strings need double quotes, and one trailing comma makes the whole document invalid.
- A formatter like the JSON Formatter & Validator validates JSON, shows the exact error position, and lets you read it as formatted text, a tree or a table.
What does JSON look like?
Here is a complete, valid JSON document: an object describing a product. { "name": "Wireless Mouse", "price": 1299, "inStock": true, "tags": ["computer", "accessories"], "offer": null }. Everything in JSON is built from just six ingredients: objects in curly braces, arrays in square brackets, strings in double quotes, numbers, the booleans true and false, and null. There are no other data types — no dates, no comments, no functions.
That smallness is the point. Because the format is tiny and strict, every programming language can read and write it identically, which is why JSON quietly became the default data format of the web, displacing the heavier XML in most APIs. If you can read the mouse example above, you already understand 90% of the JSON you will ever meet.
What is JSON used for?
APIs are the biggest use: servers answer requests with JSON, and apps render it. Configuration is the second: settings for editors, build tools, apps and servers live in .json files because they are easy to edit and hard to misunderstand. Third, data exchange between systems — exports, imports, feeds and backups — frequently travels as JSON because it is self-describing: every value arrives with its key attached.
You will also meet JSON inside databases (many store JSON columns), in log files, in the local storage of web apps, and embedded in QR codes and tokens. Our guide to Base64 Encoding Explained: What It Is and When You Should Use It covers the related skill of reading encoded data, and the CSV to JSON converter shows how spreadsheet data becomes JSON for these systems.
The five syntax rules that break JSON most often
Rule one: keys must be double-quoted. { name: "Ali" } is a JavaScript object, not JSON. Rule two: strings use double quotes only — single quotes are invalid. Rule three: no trailing commas; JSON is stricter than JavaScript here, and this single comma is probably responsible for more broken config files than everything else combined.
Rule four: no comments — JSON has no comment syntax at all. Rule five: control the commas between items, not after them, and match every opening bracket with its closing twin. When JSON breaks, it is almost always one of these five. The JSON Validator checks a document against all of them and tells you, in plain English, the exact position of the first problem.
How do you format JSON so humans can read it?
Raw JSON from an API usually arrives as one enormous line — valid, but unreadable. Formatting (also called pretty-printing or beautifying) inserts line breaks and indentation that mirror the nesting: each level of objects and arrays indents a step further, and suddenly the structure is visible at a glance. Paste any JSON into the JSON Formatter & Validator and you get the formatted result instantly, with key counts and nesting depth measured for you.
The same tool offers two other ways of reading data. The tree view shows the document as an expandable outline — ideal for exploring a response you have never seen. The table view turns an array of objects into rows and columns — ideal when the JSON is really spreadsheet data in disguise, and a natural stepping stone to the JSON to CSV converter.
JSON vs JavaScript objects: why are they different?
They look like twins and are constantly confused, but a JSON document is text — a string — while a JavaScript object is a living structure in a program's memory. JSON is the photograph; the object is the person. JSON's strictness (quoted keys, no trailing commas, no comments, no undefined) exists precisely because it must be read identically by every language, not just JavaScript.
In practice: JSON.parse turns JSON text into a JavaScript object, and JSON.stringify turns an object back into JSON text. If you have a JavaScript object literal that strict parsers reject — unquoted keys, single quotes, a trailing comma — the JavaScript Object to JSON converter repairs it into valid JSON automatically.
What is minified JSON, and when is it used?
Minification is formatting in reverse: all unnecessary whitespace removed, the whole document on one line. Machines do not need indentation, so production data transfers, embedded configuration and stored payloads are often minified to save space and bandwidth. The JSON Formatter & Validator minifies in one click and beautifies just as fast, so the same file can serve both audiences.
The working rule professionals follow: store and edit the formatted version, ship the minified version. Editing minified JSON by hand is how trailing commas and missing brackets sneak in — which is why validation after any manual edit is a habit worth building.
How do you fix invalid JSON?
Start by validating, not by staring. The JSON Validator names the first error and its position; fix that one and re-validate, because parsers stop at the first problem and later errors often vanish once the first is repaired. Nine times out of ten the culprit is a trailing comma, an unquoted key, a single-quoted string, or a bracket closed in the wrong order.
For stubborn cases, format a small piece at a time. Paste half the document, validate, then add the rest — the half that fails contains the problem. And keep the formatted view open while you work: broken structure is obvious in an indented document in a way it never is in a single line.
JSON and security: what to know
JSON itself is just text, but two habits keep it safe. First, never treat data from an unknown source as code: a JSON payload should be parsed with a real parser — JSON.parse and its equivalents — never executed. The moment data is parsed rather than run, the classic injection tricks lose their power. Second, remember that JSON carries whatever is put into it, visibly: tokens and API responses routinely contain names, emails and internal IDs in plain sight.
That visibility is a gift when debugging — and a responsibility when sharing. Before pasting a JSON sample into a forum post, a screenshot or a bug report, scan it for tokens, keys and personal data. The same self-describing clarity that makes JSON pleasant to work with makes it equally pleasant to leak.
Learning to read JSON like a native
Fluency comes from pattern recognition, and it arrives faster than people expect. Learn to see the skeleton first — where the top-level object opens, which keys hold arrays, how deep the nesting goes — before reading any values. The tree view in the JSON Formatter & Validator trains exactly this skill: collapse everything, expand one branch at a time, and the structure of any API response becomes a map you can navigate.
After a week of this, minified one-line JSON stops being intimidating — you know it is the same skeleton wearing tighter clothes, and formatting it is a ten-second reflex rather than a task. That reflex, more than any single fact in this guide, is what 'knowing JSON' actually means in daily development work.
Try the free tool
This guide is easier with the tool open in another tab — free, no sign up, and everything runs privately in your browser.
Frequently asked questions
What does JSON stand for?
JavaScript Object Notation. It was derived from JavaScript's object syntax in the early 2000s but is now completely language-independent — Python, PHP, Java, Go and every other mainstream language read and write it.
Is JSON a programming language?
No. JSON is a data format, not a language: it describes values and structure only. It cannot contain functions, logic or comments — which is exactly why it is safe and predictable for exchanging data.
Why is my JSON invalid?
The most common causes are a trailing comma after the last item, unquoted keys, single-quoted strings, or mismatched brackets. A validator will point at the exact position of the first error.
What is the difference between JSON and XML?
Both describe structured data, but JSON is lighter: no closing tags, less repetition, and a structure that maps directly onto the objects and arrays programs use. XML survives in documents and older enterprise systems; JSON dominates APIs.
Can JSON contain dates?
Not natively — JSON has no date type. Dates are stored as strings (usually in ISO format, like 2026-11-01) or as Unix timestamp numbers, and the receiving program interprets them.
