The best way to read JSON from APIs and config files
A practical order for reading unfamiliar JSON: confirm it parses, learn its shape, pick a view, check types and nulls, and format last. With examples.
Most of the time you read JSON because something is wrong. A request failed, a feature flag is not taking effect, a number on a dashboard looks off. You are not trying to admire the document, you are looking for the one field that explains the problem. People who are quick at this tend to follow the same order of operations without thinking about it. This post writes that order down, with examples from the kinds of documents you actually open at work.
Start with the question, not the document
Before you scroll, decide what you are looking for. "Why did this request return a 400?" points you at an error object. "Which users have no email?" is a question about a field across many records. "What is the timeout in this environment?" is a path lookup in a config. Each one wants a different approach, and knowing which saves you from reading the whole thing top to bottom.
Confirm it parses, then learn the shape
First make sure the text is valid JSON. A truncated response, a stray log prefix or a trailing comma will send you down the wrong path if you try to read around it. Once it parses, look at the top level. Is it an object or an array? A top-level array usually means a list of records. A top-level object with keys like data, meta, errors or pagination is an envelope, and the part you want is probably inside one of those keys.
Envelopes are worth a moment because they change what "empty" means. A response with "data": [] and a 200 status is a successful query that found nothing. A response with "errors": [...] and a null data field is a failure that happened to return a body. Reading the keys at depth one tells you which situation you are in. It also tells you where to look for the request ID, which is the thing support or a backend teammate will ask for first.
{
"data": null,
"errors": [
{
"code": "VALIDATION_FAILED",
"path": ["user", "email"],
"message": "must be a valid email address"
}
],
"meta": { "requestId": "req_5f2a" }
}Match the view to the shape
Arrays of similar objects belong in a table. Columns let you compare one field across every row, spot nulls and see outliers. A single record with many fields is easiest as cards or key-value blocks, where each group of related fields sits together. Deeply nested configuration is best explored as a tree, where you expand one branch at a time and keep the rest out of the way.
View My JSON offers Cards, Table and Tree views for free, and you can switch between them on the same pasted data, which is handy because the right choice sometimes only becomes clear after a first look. Reading a flat list of 200 users as raw text is slow. The same list as a table takes seconds.
[
{ "id": 1, "name": "Ada", "email": "ada@example.com", "active": true },
{ "id": 2, "name": "Linus", "email": null, "active": true },
{ "id": 3, "name": "Grace", "email": "grace@example.com", "active": false }
]Check types, nulls and missing keys
Many bugs hide in a field that is not the type you assumed. A numeric ID may arrive as a string in one record and a number in the next. A boolean may be the string "false", which is truthy in many languages. A date may be an ISO 8601 string in one place and an epoch number in another, and epoch values may be seconds or milliseconds, which differ by a factor of 1,000.
Get used to checking three things on any suspicious field: its type, whether it can be null, and whether it can be absent. In a table view, null cells and mixed values in a column are easy to see. In a config, a key that is simply missing often explains a default behavior you did not expect, and you will only notice if you look for it.
Follow identifiers across the document
Real documents reference themselves. An order has a customerId, and the customers are elsewhere in the response. A config has an environment name, and the matching overrides sit in a sibling object. When you are trying to understand a record, take its ID and look for other places that ID appears.
Logs add another wrinkle. A line often contains JSON embedded in text, such as 2026-03-14T09:12:55Z WARN payload={"orderId":"A-1001","retry":3}. Copy only the braces and everything inside, not the prefix. And if a field contains a string that itself looks like JSON, with escaped quotes everywhere, parse that inner string separately to read it properly.
Format last, and only when you need the text
Formatting is mostly for output: you want clean text to paste into a bug report, a test fixture or a pull request. For reading, it is the least helpful step because it only adds whitespace. Do it at the end, when you have found what you were looking for and want to share a readable snippet.
When you share, trim the document to the relevant part. A bug report that shows the failing record and its two neighbors is more useful than the full 5,000-line response, and it keeps unrelated data out of tickets. Remove tokens, emails and anything personal before it leaves your machine.
A short habit list
The order, in one breath: decide the question, make sure it parses, read the top-level shape, pick the view that fits, check the suspicious fields for type and null, then format only to share. It sounds like a lot, but once it is habit it takes under a minute, and it is faster than the alternative of scrolling and guessing.
If you want somewhere to do this, app.viewmyjson.com is a free web app where you paste or drop a .json file, and the parsing happens in the browser. Any tool that gives you validation and a few different views will do the same job. The order of operations matters more than the tool.