How to Open a JSON File

You downloaded a file ending in .json — a data export, an API response, a config file, a backup from an app you're leaving — and double-clicking it either did nothing, opened a browser tab full of unreadable text, or asked you which program to use. Nothing is broken. JSON is a plain-text format with no default app attached to it on most systems.

The fastest fix is a viewer that shows the structure rather than the raw text. Paste it into FileNaut's JSON Viewer and you get a collapsible, colour-coded tree you expand one branch at a time — in your browser, with the file never leaving your device. This guide covers that, the desktop options, how to read what you're looking at, what to do when the file is too big for a text editor, and how to decode the error when it won't open at all.

JSON stands for JavaScript Object Notation. Despite the name it isn't a program, it isn't compiled, and it has nothing to do with running JavaScript. A .json file is plain text — the same kind of content as a .txt file, just arranged in a structure that software can read reliably.

It's become the default way applications hand data to each other — request your data from a social network, export an app's settings, or call almost any modern web API, and what comes back is JSON. That's why you keep meeting it.

Everything in a JSON file is built from six things:

That's the whole language — no dates, no comments, no formulas. A date in JSON is just a string that looks like one.

This works on Windows, macOS, Linux, ChromeOS, iPhone and Android, because it only needs a browser:

1. Open FileNaut's JSON Viewer.
2. Click Upload and pick your .json file — or open the file in any text editor, select all, and paste it into the left-hand box.
3. The tree appears on the right, colour-coded by type: strings green, numbers amber, true/false purple, null grey.
4. Click any { or [ row to collapse that branch, or use Collapse to close everything and reopen just the part you want. A collapsed branch tells you how many keys or items it holds.
5. Hover a row and click the copy icon to copy that value's path — e.g. owner.email — ready to paste into code.

Nothing is uploaded — your browser reads and parses the file locally. That matters more than it sounds: data exports and API responses routinely contain email addresses, tokens and account IDs, and most "online JSON viewer" sites post your text to a server to render it.

If you'd rather have tidy indented text to paste back into your editor, use the JSON Formatter instead — formatter for cleaning up, viewer for exploring. The JSON formatter guide covers the difference.

Because JSON is plain text, every text editor already opens it. The trick is choosing one that doesn't mangle it.

If you're comfortable in a terminal, two commands pretty-print a file in place. Both are verified output, not approximations:

# Built into macOS and Linux, no install needed
python3 -m json.tool data.json

# If you have jq installed — also lets you pull out one field
jq . data.json
jq 'keys' data.json

python3 -m json.tool doubles as a validity check — it prints the file if the JSON is valid, an error if not.

Nothing on your computer "owns" the .json extension by default, so whichever program most recently claimed text files gets it — often a browser, sometimes an app you installed years ago. To fix it permanently:

• Windows: right-click → Open with → Choose another app → pick your editor → tick Always use this app.
• macOS: right-click → Get Info → under Open with choose your editor → click Change All….

One warning worth repeating: if the file opens in Word or TextEdit's rich-text mode, do not save from there. Those apps substitute curly quotes for straight ", which makes the file invalid while looking identical.

Once the tree is open, reading it is mostly recognising two shapes.

An object is one thing with labelled parts:

{
  "name": "Ada",
  "active": true,
  "score": 91.5
}

An array of objects is a list of those things — the JSON equivalent of a spreadsheet, and by far the most common shape in a data export:

[
  { "name": "Ada",  "score": 91.5 },
  { "name": "Alan", "score": 88.0 }
]

When you see that shape, the outer [ ] is your rows and the keys inside are your columns — which is exactly the file you can turn into a spreadsheet in one step with JSON to CSV.

Nesting is what makes real files hard to read — an object inside an object inside an array, five levels deep. That's the whole reason to use a tree: collapse everything, then open only the branch you need. A copied path like owner.roles[0] is that value's address, and a number in brackets means "item at that position", counting from zero.

This is where most advice quietly fails. A "large" JSON file is not a 500 MB monster — problems start far earlier, and the reason is not the parsing.

Reading the file is almost free. Drawing every row of it on screen is not. Measured in Chrome on a modern laptop, using the same tree structure a viewer builds:

Parsing 3.8 MB takes seven milliseconds. Rendering it takes about three seconds — four hundred times longer. Every browser-based JSON viewer, including ours, has this shape, and slower machines will be worse.

So for anything past roughly a megabyte:

• Collapse first, expand second. If the viewer opens everything by default, hit Collapse immediately, then walk down only the branch you need.
• Don't use a plain text editor. Notepad and TextEdit become unusable on a large single-line JSON file. VS Code copes better but still slows.
• Extract before you view. jq '.users[0]' big.json pulls out one record, so you inspect kilobytes instead of megabytes.
• Convert instead of reading. For a long list of records, JSON to CSV gives you a spreadsheet — a far better tool for 50,000 rows than any tree.

Multi-gigabyte files — server logs, database dumps — need a streaming parser. No browser tab will open those, whatever a site promises.

If a viewer rejects your file, it will usually show the raw parser message. Those messages are precise once you know the translation. Every message below is the verbatim output of the JSON parser browsers actually use:

Two deserve a note. JSON Lines — one complete object per line, no wrapping brackets — is a real format used for logs and exports; it isn't broken, it just isn't a single JSON document. Wrap the lines in [ ] with commas between them and it becomes one. A byte-order mark is invisible in every editor, making it the most infuriating of the set: if a file looks perfect and still won't parse, re-save it as UTF-8 without BOM.

Use the position number in the message with the JSON Formatter, which flags syntax errors as you type. Comparing a file that works against one that doesn't? Text Compare shows the difference directly.

A file can open perfectly and still not mean what you think. These are the cases worth knowing before you trust what you read — each one verified, not assumed:

• Very large numbers lose accuracy. {"id": 12345678901234567890} reads back as 12345678901234567000. Beyond about 9 quadrillion, values can't be held exactly, so long IDs get silently rounded. This is why well-built APIs send big IDs as strings.
• Duplicate keys silently win. {"a": 1, "a": 2} is legal JSON and gives you 2. The first value vanishes with no warning.
• Leading zeros only survive in strings. "07030" stays a ZIP code; unquoted 07030 isn't valid JSON at all, and a tool that "helpfully" converts it gives you 7030.
• Order is not guaranteed. Object keys have no meaningful order and some tools re-sort them on save. Arrays are ordered — that difference matters.
• Escapes are already decoded. "café" displays as café, so the file on disk and the value on screen legitimately differ.

Often "open this JSON file" really means "get this data somewhere useful":

• Into a spreadsheet — JSON to CSV, then open the CSV. Works cleanly when the file is an array of flat objects.
• Back the other way — CSV to JSON, with the pitfalls covered in the CSV to JSON guide.
• Into a config file — YAML ↔ JSON; YAML vs JSON explains which to use.
• From an older system — XML ↔ JSON.
• Just tidier — JSON Formatter re-indents it for any editor.

• Keep a copy before you edit. One missing brace makes the entire file unreadable — there's no partial recovery.
• Format first, read second. Most JSON arrives minified as one long line — indent it before trying to read it.
• Treat exports as sensitive. "Download my data" files hold addresses, message history and tokens — use a viewer that runs locally.
• Check the file really is JSON. On macOS or Linux, file data.json prints JSON data when it parses as JSON.
• Note the shape before the contents. Is the top level { or [? Object means one record; array means a list — that single character determines everything else.