Skip to content
FormatKit

Free online JSON tree viewer

JSON viewer for files that choke other viewers

This JSON viewer is free and needs no account: paste a payload of up to 5 MB and it becomes a collapsible tree you unfold one branch at a time, which is why a document of nearly 300,000 nodes opens without the tab going white. Search runs over the whole parsed file rather than the visible rows, so a value hidden inside a folded branch is found and revealed, and every row carries a type badge, a size count and a JSONPath you can copy straight into jq or your own code.

  • 100% free
  • No signup
  • Up to 5 MB
  • Unfolds on demand
  • JSONPath on every node

Nothing open yet. Paste a payload or hit Ctrl+V.

Drop a file on the box above, or press Ctrl+V while this page has focus.

How to view a JSON file

Three steps between a payload on the clipboard and the value you came for.

  1. Put the document in front of the viewer

    Paste it into the text box, send it in with ⌘V or Ctrl+V, drop a file on the box, or use Choose a file. Anything up to 5 MB opens, including .har captures and .geojson exports. Once it parses, the raw text folds away and the tree takes the whole pane.

  2. Unfold only the branch you are chasing

    Click the triangle beside a row to open that container and nothing else; a container longer than 200 children lists the first 200 and offers the rest in blocks of the same size. Unfold two levels gives you a quick overview, Fold everything puts you back at the root, and the breadcrumb above the tree names every step from $ down to the row you are on.

  3. Take the path, or the branch, with you

    Select a row and the bar underneath prints its JSONPath — $.shipments[0].events[1].code — beside a badge naming the type and the size. Copy path puts that string on the clipboard; Copy value hands you the selected branch re-printed as indented JSON, or the plain text of a string with its escapes already resolved.

Technical specifications

Documents it opensAny RFC 8259 value at the top level — object, array, string, number, true, false or null — from .json, .geojson, .har, .webmanifest, .map, .avsc or .txt
Size ceiling5 MB (5,242,880 bytes). A 5.00 MB payload measures 297,000 nodes and 217,800 keys and parses in under 0.2 seconds
Rows drawn at onceThe root plus its first 200 children on open; 3,000 rows maximum however many branches are unfolded; longer containers list 200 more per click
SearchKeys, values, or both, over the whole parsed document; about 15 ms for a full pass across 297,000 nodes, counted up to 500 hits
Path notationJSONPath (RFC 9535) — $.shipments[0].events[1].code, with bracket form for keys that are not identifiers: $["content-type"]
Row badgesType on every row, plus key count for objects, item count for arrays, character count for strings and digit count for numbers
Depth and fidelityReads 500 levels; number literals of any length, duplicate keys and the original key order are shown exactly as the file has them
Cost and processingFree, no account, no cap on how many documents you open; each one is read and parsed inside this browser tab

Frequently asked questions

How do I open a large JSON file without the browser freezing?

Use a viewer that draws only the branches you have opened, which is what this one does. A 5.00 MB document holds roughly 297,000 nodes; a viewer that mounts one element per node builds a third of a million DOM elements before you have read a single value, and that is the freeze. Here the first paint is the root plus its first 200 children — about 200 rows whatever the file weighs — and the pane never draws more than 3,000 rows at once. Parsing the same 5 MB takes under a fifth of a second, so the wait you notice is the file dialog, not the document.

Does the order of keys in a JSON object matter?

Not to the standard: RFC 8259 defines an object as an unordered collection of name/value pairs, so two documents whose keys appear in a different sequence carry the same data. It matters to everything built on top of the standard, though — line-based diffs, checksums, cache keys and detached signatures all change when the sequence does. This viewer lists members in the order they were written rather than the order JavaScript would store them in, so what you read is the file, not a reshuffled copy of it.

Why does the viewer show the same property name twice?

Because the file really does contain it twice and hiding one would be a lie about your data. RFC 8259 only says object names SHOULD be unique, then warns that behaviour is unpredictable when they are not: JavaScript, Python, Go and jq all keep the last occurrence and silently drop the earlier ones, while some validators reject the document outright. Seeing both rows in the tree is usually the first clue that a template or a merge step is emitting a field twice.

How deep can a JSON document nest?

There is no limit in the format itself — RFC 8259 lets every implementation set its own, and they differ wildly. This viewer reads 500 levels, .NET System.Text.Json defaults to 64, Go encoding/json stops at 10,000, and CPython json raises RecursionError somewhere under 1,000 because it recurses one stack frame at a time. If your document goes deeper than a handful of levels the breadcrumb above the tree is what keeps you oriented: it spells out the whole route from $ to the selected row and each step is clickable.

What is the $ path shown under the tree, and where can I paste it?

It is JSONPath, standardised as RFC 9535 in 2024, and it identifies the selected node inside the document. Identifier-shaped keys get dot form and everything else gets brackets, so a hyphenated header lands as $["content-type"] rather than an expression that would not parse. Drop the leading $ and it is a jq filter; keep the shape and it is close enough to paste into JavaScript or Python as an accessor chain.

Does the search look inside branches that are still closed?

Yes — it runs over the parsed document, not over the rows on screen, so a value buried in a folded branch is found and its ancestors are unfolded to show it. A complete pass over the 297,000 nodes of a 5 MB file takes about 15 milliseconds, and the tally stops counting at 500 hits so a one-letter query cannot stall the tab. Use the dropdown to limit the pass to keys or to values when the same word appears in both.

Does opening a file here upload it?

No. The file goes in through the browser's File API and is handled by code running inside this tab, so no part of it crosses the network — you can watch the network panel stay silent while a 5 MB document opens.

About reading JSON as a tree

The hard part of viewing a big document is not parsing it — it is drawing it. A 5 MB payload works out at roughly 297,000 nodes, and a viewer built the obvious way mounts one element per node, so the browser is asked for a third of a million elements before you have read anything. That is the spinning tab everyone has met. The way out is to treat folded branches as costing nothing: this page parses the whole file in one pass, then walks only the branches you have actually opened when it builds the row list. Opening a document draws about 200 rows, unfolding a container adds at most 200 more, and the pane refuses to exceed 3,000 rows in total — so the work stays proportional to what you are reading rather than to what you loaded.

What a viewer shows also has to match what the file says, and two details of RFC 8259 make that harder than it sounds. An object is defined as an unordered collection of name/value pairs, and names within it merely should be unique — the standard then warns that when they are not, receiving software behaves unpredictably, with most implementations reporting only the last pair. Load such a document through JSON.parse and half your data vanishes before it reaches the screen, and any key that looks like a non-negative integer jumps ahead of its neighbours because that is how JavaScript stores properties. Here the tree is the parse tree of the source text, so duplicates appear as two rows and members stay in the order you wrote them — which is also the order you need them in before you diff two payloads by path.

The address bar under the tree is JSONPath, the expression language finally standardised as RFC 9535 in 2024 after fifteen years as a de-facto convention. Selecting a row gives you $.shipments[0].events[1].code — drop the dollar and it is a jq filter, keep it and it is close enough to paste into most languages as an accessor chain. That is usually the point at which reading turns into changing something, and reading is all this page does: when you need to rewrite a value, rename a property or delete a branch, take the same document across to the JSON editor, which validates every keystroke and writes your edits back through the same source-faithful printer.

What happens to the file you open

Files opened here are read with the browser File API and handled entirely by code in this tab; nothing is posted to a server, cached in storage or logged. Close the tab and the document is gone with it, which is the practical reason a production dump can be inspected here at all.