How to View JSON as a Table (Online, Free, No Signup)

JSON is everywhere — APIs, configs, database exports — but reading it raw is painful. A 50-row response with nested objects becomes a 500-line indented blob you can't actually scan. The fix: view it as a table. This guide shows you how, in under a minute, in your browser.

A practical guide · Updated 24 May 2026

Why table view beats pretty-printing

When your JSON looks like this:

[
  { "id": 1, "name": "Alice", "role": "admin", "active": true  },
  { "id": 2, "name": "Bob",   "role": "user",  "active": true  },
  { "id": 3, "name": "Carol", "role": "user",  "active": false },
  { "id": 4, "name": "Dave",  "role": "admin", "active": true  }
]

Pretty-printing (re-indenting it nicely) helps a bit. But you still scan it top-to-bottom, line by line. You can't say "show me only admins" without re-reading every record.

Table view gives you the same data, but each object becomes a row and the shared fields become sortable columns:

┌────┬───────┬───────┬────────┐
│ ID │ NAME  │ ROLE  │ ACTIVE │
├────┼───────┼───────┼────────┤
│ 1  │ Alice │ admin │ ● Yes  │
│ 2  │ Bob   │ user  │ ● Yes  │
│ 3  │ Carol │ user  │ ● No   │
│ 4  │ Dave  │ admin │ ● Yes  │
└────┴───────┴───────┴────────┘

Now you can sort by role to group admins, click a row to see the full nested detail, type "admin" in the search box to filter. The same data — but you can scan it instead of read it.

The three-step workflow

1 Paste or upload your JSON

Go to prettyjsonxml.com. The editor in the middle of the page is where your JSON goes. You have two options:

Paste — click into the editor and press Ctrl+V (or Cmd+V on Mac). The editor handles up to ~5 MB inline with live syntax highlighting; bigger pastes work but the editor goes read-only for performance.
Upload — click the big "Upload a file" button. Pick any .json file from your computer. The viewer parses it client-side; nothing is sent to a server.

2 Click "View as Table"

Once your JSON is loaded, the two blue buttons at the top of the editor are View as Table and View as Tree. Click View as Table. The viewer:

Walks your JSON looking for arrays of objects (the most common "tabular" shape)
Picks the most useful fields as columns based on how often they appear and a built-in priority list (name, id, code, status, dates, money fields)
Renders the table with a sticky header and an expand button on each row

For arrays under 100 rows, the whole table renders at once. For arrays over that, a virtual scroller kicks in — only the visible rows live in the DOM, even if there are 50,000 records.

3 Sort, search, expand

Now the table is yours to drive:

Click any column header to sort ascending; click again to sort descending. Numeric columns sort numerically; text columns alphabetically.
Type in the search box (top of the page) to filter. The match is full-text — it covers cell values AND the nested data hidden inside row details. Search runs as you type, no Enter needed.
Click any row to expand its full detail. You'll see every field of that object including nested arrays, base64 images decoded as thumbnails, and long text in a collapsible block.

Open the viewer →

How the column picker works

The viewer doesn't show every field as a column — that would be unreadable for objects with 20+ fields. It picks up to 6 of the most useful ones based on three signals:

Frequency. A field that appears in at least 50% of rows is column-worthy. A field that appears in 1 of 20 rows is not — it's a sparse outlier, available on expand.
Semantic priority. Fields named name, title, id, code, status, amount, dates, etc. get bumped to the front of the column order. These are usually what humans want to scan first.
Pattern detection. If your data looks like a rule expression (field, operator, value), the viewer lays those out in natural reading order even if frequency would put them elsewhere.

Hidden fields aren't lost — they show up when you click the row to expand it. The detail view is always the complete object.

What happens to nested data

Real-world JSON rarely has flat objects. You might have:

{
  "id": 1,
  "name": "Alice",
  "address": { "city": "Tbilisi", "zip": "0102" },
  "tags": ["admin", "active"]
}

The viewer handles this two ways:

Singleton wrapper lift. If address appears as an object inside every row, its fields (city, zip) get "lifted" to first-class columns. So you might see NAME · CITY · ZIP at the table level even though they came from nested paths.
Array-of-scalars collapse. A field like tags: ["admin", "active"] becomes a single cell showing admin, active rather than a sub-array. If you click to expand the row, you'll see the array structure clearly.

For deeply nested structures (a subarray inside each row), the viewer renders that subarray as its own collapsible mini-table inside the expanded detail view. The same logic works on XML — see this worked RSS feed example, where each <item> becomes a row and its nested tags become columns.

Tips for large files (9 MB+)

The viewer is built to handle big files without freezing your browser:

Editor goes read-only above 5 MB. Assigning a 9 MB string to a <textarea> blocks the main thread for 300–500 ms — we skip it and show a placeholder. The data still loads into the viewer; you just can't hand-edit a 9 MB blob (and you wouldn't want to anyway).
JSON.parse runs in a Web Worker for files over a few hundred KB, so the UI stays responsive while parsing happens off the main thread.
Virtual scrolling kicks in for tables with 100+ rows — the table can have 30,000 rows but only ~50 live in the DOM at any moment. Memory stays low; scroll stays smooth.
Lazy tree expansion beyond depth 2 for large documents — the Tree view only builds nodes as you expand them.

Tip: For files over 50 MB, expect ~1 second of busy cursor while DOMParser / JSON.parse does its initial work. Native parsing is the floor — even Chrome can't make 50 MB of structured data appear instantly. (A real-world stress test: this multi-megabyte RSS feed loads as a clean table of episodes.)

Sort, search, expand — power tips

Search across nested content

The search box filters on more than what's visible in columns. It scans each row's full text — including fields hidden in the detail view. So if a row's nestedNotes field contains "urgent", typing "urgent" finds that row even though nestedNotes isn't a column.

Multiple sort levels

Right now the table sorts by one column at a time. Click another column to switch. Click the same column twice to flip direction. (Multi-column sort is on the roadmap.)

Switch to Tree view for ground truth

The table is a curated projection of your data. If you want to see everything, switch to Tree view — that renders your JSON as raw foldable structure ({ }, [ ], key-value pairs) preserving every field, every nesting level, every null.

What if your JSON isn't an array?

A lot of JSON is a single object at the root, like a config file or an API response wrapping data:

{
  "user": { "id": 1, "name": "Alice" },
  "permissions": ["read", "write"],
  "lastLogin": "2026-05-22T10:00:00Z"
}

The viewer handles this too. Scalar fields at the root become a single "Details" card showing all of them. Nested objects (like user) become their own card sections with a heading and field list. Arrays-of-objects nested inside become their own mini-tables.

You get all the same powers (search, expand, switch to tree) but on a single-record layout instead of a multi-row table.

Is my data uploaded anywhere?

No. The viewer is a single HTML file. There is no backend, no API, no upload endpoint. Your JSON is parsed and rendered by your browser's built-in JavaScript engine — we (the people running the site) cannot see what you paste even if we wanted to.

The site does load three analytics scripts (Google Analytics, Microsoft Clarity, Cloudflare Web Analytics) but those record aggregate behavior (clicks, page views), never the content of your data. The editor and viewer are explicitly masked from session recording. Full details in the privacy policy.

Quick FAQ

Does it work offline?

Once the page is loaded, yes — parsing and rendering happen entirely client-side. If you bookmark the page and have a reasonably fresh browser cache, refreshing without a network is fine. There's no Service Worker / PWA support yet.

What if my JSON has comments (JSONC)?

Standard JSON.parse doesn't accept comments, so files with // like this currently fail. JSONC / JSON5 support is on the roadmap.

Can I export the table to CSV?

Not yet — it's a frequent ask. For now you can copy the visible cells, or use Format + select-all + copy to get the original JSON back.

Does it work on mobile?

Yes, but tables of 10+ columns get horizontal-scrolly on phones. Tree view is more mobile-friendly for wide records.

Open the viewer and try it →