JSON Tree Viewer

1. 1

   Open your JSON

   Drag a .json, .jsonl, .geojson, .har or .map file onto the drop area, browse for one, or paste JSON straight into the text box. Nothing is uploaded — the file is read on your device.

2. 2

   Explore the tree

   Objects and arrays open and close with the arrow beside them, and each one shows how many children it holds. Use Expand to depth or Collapse all to change the whole shape at once.

3. 3

   Find what you need

   Search any key or value, with regular expressions if you want them, and step through the matches. For a precise slice, filter with a JSONPath expression such as $..author or $.items[0:10].

4. 4

   Switch to the table

   When the document is an array of records, the table view lays it out in columns instead of repeating the same branch hundreds of times.

5. 5

   Copy or export

   Copy any node's path, key or value, or download the whole document — or just the selected subtree — formatted, minified, unchanged, or as NDJSON.

Open a JSON file and read it — that is the whole job, and doing it well on a file of any size or shape turns out to take more than a collapsible list. This viewer indexes the file rather than converting it into objects, so it opens quickly, shows exactly what the file contains, and stays responsive whether the document is two lines or two million nodes.

• A tree that scales. Objects and arrays expand and collapse at any depth, and only the rows on screen are ever drawn — so a 200,000-record export scrolls as smoothly as a small config file.
• A table when the data is tabular. An array of records becomes rows and columns, with the columns worked out from the data.
• Search and filter. Match keys, values or both, with regular expressions; or take a precise slice with a JSONPath expression.
• Exactly what the file says. Large numbers keep every digit, duplicate keys are kept and flagged, and the file's own escape sequences survive.
• Tolerant reading. Comments, trailing commas, single quotes and unquoted keys can be read, with every change reported.
• Copy and export. Any path, key, value or subtree to the clipboard; the whole document or one branch to a file.

Size is where most browser-based JSON viewers stop being useful. The usual approach parses the document into JavaScript objects and then renders one element per node, which costs memory proportional to the file and lays out the entire document before showing any of it. Past a few megabytes that becomes a frozen tab.

What this viewer does instead

• Indexes rather than parses. The file is scanned once into a compact table of positions. No JavaScript object is created for any part of the document.
• Works away from the page. Scanning, searching, filtering and exporting all happen off the thread that draws the screen, so the page never freezes and scrolling never stutters.
• Draws only what you can see. About forty rows exist at a time, no matter how many the document has.
• Decodes text on demand. A key or value is turned into readable text when it appears on screen and not before.
• Handles depth without failing. Nesting is followed iteratively, so a deeply nested document is read like any other instead of exhausting the stack.

Finding one field in a large document is the task a viewer exists for, and there are two different questions behind it: where does this text appear, and what is at this path? Both are answered here, and both run over the index rather than over the rendered rows, so a match at the bottom of a huge file is found as quickly as one at the top.

The two ways to look

• Search. Type any text to match keys, values or both. Case sensitivity is optional and regular expressions are supported, with ^ and $ matching at line boundaries as they do in an editor.
• Step through matches. Matches are listed in document order; moving to one opens every branch above it and highlights the text inside the row.
• JSONPath filter. Expressions such as $.store.book[*].author, $..price, $.rows[0:100] and $['odd key'] narrow the view to exactly the nodes you asked for, each shown with its own structure.
• Filter and search together. Search inside a filtered view to narrow twice — useful when a path selects a thousand records and you want the three that mention a name.

Most JSON in the wild is a list of records: an API response, an export, a log file. Drawn as a tree that is hundreds of identical branches, and reading it means opening them one at a time. The table view shows the same data as rows and columns, which is how a list of records is meant to be read.

How it behaves

• Columns come from the data. Field names are collected across the records rather than assumed from the first one, so a field that only some records carry still gets a column.
• Irregular records are visible, not hidden. A record missing a field shows an empty cell, and an entry that is not an object at all is still listed rather than skipped.
• Nested values stay navigable. A cell holding an object or array shows what it is and how much it holds; selecting it takes you to that node in the tree.
• It finds the records for you. Whether the array is the whole document or one field inside it, the table offers the nearest list of records to whatever you have selected.

Two things happen inside almost every JSON viewer that are never mentioned and change what you are shown. Both come from the same decision — parsing the document into JavaScript values — and both are avoided here by reading the file's own text instead.

What gets lost elsewhere

• Large numbers are rounded. A JavaScript number holds about 15 significant digits. An identifier such as 12345678901234567890 becomes 12345678901234567000, and nothing on screen says so. Here every number is shown from the file's own characters, and any number that could not survive a round trip is marked.
• Duplicate keys disappear. JSON permits an object to repeat a key. A parser that builds an object keeps only the last one, so a document that is quietly wrong looks correct. Here both members are shown, both are flagged, and the count appears in the summary.
• Escape sequences get rewritten. Formatting a document elsewhere can turn every \u00e9 into a literal character. Exporting here changes whitespace and nothing else, so the difference against your original stays readable.
• High-precision decimals are truncated. The same 15-digit ceiling applies to fractions, so a value carrying more precision than a double can hold is silently shortened. It is shown here in full.

Strict JSON has no comments, no trailing commas, no single quotes and no unquoted keys — and real configuration files have all four. A viewer that simply refuses them is not much help when the file in front of you is the one you need to read.

Tolerant mode, and its limits

• Offered, never automatic. The file is read strictly first. Tolerant mode appears only when the strict reading failed and a repair would actually change something.
• Everything it changes is reported. Comments removed, trailing commas dropped, quotes converted, bare keys quoted, NaN and Infinity replaced — each named, counted, with the line of the first occurrence.
• It never invents structure. A missing bracket, a missing comma or a truncated file is corruption rather than dialect. Those are reported as errors, because guessing would put data on screen that is not in your file.
• Errors say where. When a file cannot be read at all, the message gives the line and column and shows the text around the problem, rather than a byte offset no editor will take you to.

JSON arrives under several extensions and occasionally in an encoding it should not be in. All of them are read here, and what was detected is shown rather than assumed silently.

What opens

• JSON. .json, and plain .txt containing JSON.
• JSON Lines and NDJSON. .jsonl and .ndjson, where each line is its own document. They are presented as one array so the whole stream can be browsed, searched and exported together.
• GeoJSON, HAR and source maps. .geojson, .har and .map are ordinary JSON with particular shapes, and all three open normally.
• UTF-8, UTF-16 and Windows-1252. A byte order mark is honoured and removed rather than reported as a syntax error, and a file that is not valid UTF-8 is decoded rather than filled with replacement characters.

Reading a document usually ends with taking something out of it — a path for a test, a value for a bug report, a branch for a colleague. Every one of those is one click, and none of them changes what your data says.

What you can take

• The path. $.store.book[0].author, in the form you can paste into another tool. Keys that need quoting get it.
• The key or the value. A string copies its text without the surrounding quotes; every other value copies exactly what the file contains.
• A subtree. Any object or array, formatted, without exporting the rest of the document.
• The whole file, four ways. Formatted with indentation, minified, the original bytes unchanged, or NDJSON with one array element per line.

Nothing is uploaded. The file is opened, indexed, searched and exported entirely on your own machine, which is both the privacy answer and the speed answer — there is no round trip to wait for, so a large file is limited by your device rather than by a network.

What that means in practice

• Works offline. Once the page has loaded, the viewer keeps working with no connection at all.
• Nothing is stored. Closing the tab is the end of it. There is no history and no cache of your documents.
• Safe for sensitive data. Production exports, access logs and anything under an agreement that forbids third-party processing can be opened here, because no third party ever receives them.
• Your device sets the ceiling. The free plan opens files up to 100 MB. Pro removes that number in favour of whatever your machine can actually manage.

A few habits make a large or unfamiliar document much faster to get through, whichever viewer you use.

Tips

• Collapse first, then descend. Collapse everything and open one branch at a time; the shape of a document is easier to see with ten rows on screen than with ten thousand.
• Filter before you search. A JSONPath expression that narrows to the records you care about makes a subsequent text search far easier to read.
• Use the table for lists. If the document is an array of records, the table answers questions the tree cannot — such as which records are missing a field.
• Check the summary. Node count, maximum depth, duplicate keys and unusual numbers are shown when the file opens, and they often explain a bug before you go looking for it.
• Export the branch, not the file. When sharing a problem, a subtree is easier for someone else to read than a link to a 40 MB document.

Common uses

• Debugging an API. Paste a response, find the field that is wrong, and copy its path straight into a test.
• Checking an export. Open a database or analytics export, confirm the record count, and look for records that do not match the rest.
• Reading a HAR file. A network capture is JSON with a very deep shape, which is exactly what search and filtering are for.
• Auditing configuration. Duplicate keys and unexpected nulls in a config file are visible here rather than silently applied.
• Inspecting logs. NDJSON log files open as one browsable list instead of thousands of separate documents.

• JSON Formatter
• JSON Validator
• JSON Minifier
• JSON Diff
• JSON to YAML
• JSON to XML