View JSON as a table: making arrays of objects readable
How to turn a JSON array of objects into rows and columns, what to do with nested values and missing keys, and when not to use a table.
An array of objects is the most common shape of API data: a list of users, orders, log entries, or search hits. Reading one record at a time is slow, and reading fifty of them as raw text is worse. A table view puts each object on its own row and each key in its own column, so patterns and oddities show up quickly. This guide explains when the conversion works cleanly, how nested values and missing keys behave, and what to check once the table is on screen.
The shape that suits a table
A table works when the data is a JSON array whose elements are objects with mostly the same keys. Each element becomes a row, and the union of the keys becomes the column headings. The sample below is a typical case: three users with the same four fields.
Each key carries the same meaning from row to row, so reading down a column is a meaningful operation. You can see at a glance that the roles are admin, editor, and viewer, that one account is inactive, and that the ids run in sequence.
[
{ "id": 101, "name": "Ana Silva", "role": "admin", "active": true },
{ "id": 102, "name": "Tom Okafor", "role": "editor", "active": true },
{ "id": 103, "name": "Mei Chen", "role": "viewer", "active": false }
]When the array is not at the top level
Real responses rarely hand you a bare array. More often the array sits inside an envelope: an object with a status, pagination info, and a key like data, items, or results that holds the list. In that case you want the table for the inner array, not the wrapper.
Some viewers put the whole document in one row, with the wrapper object squeezed into a single cell. In that case, select the array or paste only the array. View My JSON's Table view is one of the free views alongside Cards and Tree, and it looks for arrays of records inside the document and shows each as its own Records section, with the remaining values listed by path. The Tree is still handy for seeing where each array lives.
{
"status": "ok",
"page": 2,
"perPage": 2,
"data": [
{ "id": 3, "sku": "TS-M-BLK", "price": 19.5 },
{ "id": 4, "sku": "TS-L-BLK", "price": 19.5 }
]
}Missing keys and nulls look different
JSON has no concept of a column, so objects in the same array are free to have different keys. When one record lacks a key that the others have, a table shows an empty cell. That is not the same as a key that is present with the value null, even though the two can look alike in a grid.
The distinction matters in code. Looking up a missing key typically gives undefined or an exception depending on the language, while a null is a value you can read. Some APIs omit empty fields to save space; others include them as null. In the example below, the second record has no phone key at all, and the third has it set to null. In a table, the missing key usually appears as an empty cell, while an explicit null may be printed as the word null, depending on the viewer. View My JSON prints null as text. If the difference matters, confirm it in the raw text or the Tree.
[
{ "id": 1, "name": "Ana", "phone": "+351 912 345 678" },
{ "id": 2, "name": "Tom" },
{ "id": 3, "name": "Mei", "phone": null }
]Nested objects and arrays inside cells
Nested values are where table views have to make a choice. A cell can show a summary, a compact JSON string, or an expandable value. View My JSON shows nested values as a compact JSON string, shortened in the cell, with the full value on hover and a click to copy. Either way, a table is two-dimensional and JSON is not, so deep structures are partly flattened.
For example, an order with a customer object and a lines array does not fit naturally into one row. A practical approach is to look at the table for the top-level fields, then open the nested value in a Tree or Cards view when you need the details. If you need a flat spreadsheet-style extract of a deeply nested document, you will probably want to write a short script that picks the fields you care about.
[
{
"orderId": "A-1001",
"customer": { "id": 17, "country": "PT" },
"lines": [
{ "sku": "TS-M-BLK", "qty": 2 },
{ "sku": "MUG-01", "qty": 1 }
]
}
]Finding problems by scanning columns
Once the data is in rows and columns, a few quick checks pay off. Scan each column for mixed types: a quantity column in which most values are numbers and one is a string is a bug waiting to happen. Look for unexpected nulls and blank cells. Check that identifiers are unique, and that enumerated values like status or role come from the set you expect, with no stray capitalisation or whitespace.
Dates deserve special attention. JSON has no date type, so dates travel as strings, usually in ISO 8601 form like 2026-03-14T09:30:00Z. A column that mixes that format with something like 14/03/2026 or a Unix timestamp as a number points to inconsistent producers, and it is far easier to see in a table than in a page of braces.
Sorting and checking by eye
Even without sorting controls, a table lets you do useful manual audits. Read the id column top to bottom and look for gaps or repeats. Look at the price column and check that nothing is negative or suspiciously large. Compare two rows that you expect to be identical apart from one field.
This is the kind of job where a table pays for itself during real debugging. Imagine a paginated endpoint that returns two pages with a duplicated record at the boundary. In raw text you would have to compare ids by memory. In rows, the repeated id sits in adjacent lines and is obvious. The same applies to checking that a filter you applied, such as active equals true, actually produced only matching rows.
When not to use a table
A table is a poor fit for a single object, for configuration files whose keys are all different, and for documents nested more than a level or two. In those cases a tree or card view is clearer. A table is also not a good way to understand the relationship between parent and child values, because it hides the hierarchy.
Tables are for comparison across similar records. If what you want to understand is how a document is put together, use another view. Because switching in View My JSON does not alter the data, you can pick the one that answers the question you actually have, and move on when it stops helping.