JSON Structure Explained: Examples, Schema, How to Open Files and Python (2026)

What Is JSON? Meaning, Full Form and Uses

The full form of JSON is JavaScript Object Notation. Although its name mentions JavaScript, JSON is language-independent as a data-interchange format. It is described in the Internet Engineering Task Force's RFC 8259 and used in many programming languages.

JSON is particularly common when a web browser requests data from a server, a mobile application saves settings, or a developer stores simple structured configuration. A JSON document consists of a single JSON value, which can be an object, array, string, number, boolean or null. Many practical API responses use a top-level object, but valid JSON does not require an object at the top.

A typical .json file contains human-readable text, not an executable program. Opening it in a text editor lets you inspect its contents. Parsing it converts that text into data structures usable by the application.

JSON Structure: Objects, Arrays and Six Kinds of Values

JSON has two main structural containers: objects and arrays. An object is enclosed in curly braces and contains names paired with values. An array is enclosed in square brackets and contains an ordered sequence of values.

An object member has the structure "key": value. Property names must be strings in double quotes, and commas separate members. Arrays use commas to separate elements. Objects and arrays may be nested to represent more complex information.

Strict JSON does not permit comments, trailing commas, single-quoted strings, JavaScript functions, or undefined. Unlike programming languages, it is a serialization format with deliberately narrow syntax rules.

A Complete, Valid JSON Example for Beginners

Here is an illustrative project record containing an object, nested object, array, string, number, boolean and null:

{
  "project": "PerkAbility Rewards",
  "version": 2,
  "published": true,
  "topics": ["JSON", "web tools", "tutorials"],
  "contact": {
    "method": "website",
    "enabled": true
  },
  "next_review": null
}

You can copy this example into the JSON Formatter to see how whitespace affects readability. The data is fictional and is not a production API response or a claim about the site's current database.

How to read the structure

1. { starts the top-level object, and } ends it.
2. "project" is a property name; the value is a string.
3. "version" stores a number, not the string "2".
4. "published" stores the boolean true, without quotes.
5. "topics" is an array of three strings.
6. "contact" is another object nested inside the first.
7. "next_review" is null, which is distinct from an empty string or a missing property.

How to Open a JSON File on Windows, Mac, Linux or Your Phone

A JSON file usually ends with .json. It can be opened with many text editors because its contents are plain text. You do not need to install a specialized JSON app just to inspect an ordinary small file.

Windows: Notepad, VS Code or another text editor

1. Locate the file in File Explorer.
2. Right-click and choose Open with, then select a text editor such as Notepad or Visual Studio Code.
3. Read the keys and values. In a code editor, use formatting or indentation tools to navigate nested objects.
4. If you intend to edit it, save a backup before making changes and validate the final file.

macOS: TextEdit or a development editor

Use Finder to locate the file, then open it with an editor that can display plain text. In TextEdit, avoid accidentally converting the document into rich-text format. Developers may prefer Visual Studio Code or another editor with JSON syntax highlighting and structural folding.

Linux and command-line workflows

Use a text editor, or examine small files in a terminal. When Python is available, a quick command can validate and pretty-print a valid file:

python -m json.tool sample.json

This command reports invalid syntax rather than silently repairing broken input. If you want to save the formatted result, redirect it to a different filename instead of overwriting your only copy before inspection.

Android and iPhone

Files apps and some code-viewing editors can preview text documents. If the device opens a JSON file as a download rather than displaying it, use a trusted text editor or move it to a development computer. Avoid uploading personal or confidential exports into unfamiliar online viewers.

What about manifest.json, package.json and localconfig.json?

Searches for manifest.json, package.json, and localconfig.json all point to configuration-related use cases, but their meaning depends on the application:

• manifest.json: commonly used as a manifest for web apps, browser extensions or other software. Required properties depend on the specific specification.
• package.json: holds metadata and scripts for Node.js or npm projects. It is structured as JSON but follows package-manager conventions.
• localconfig.json: may be an application-specific configuration filename; it is not a universal standard that implies one schema.

Always consult the product's documentation before editing a configuration file. A JSON formatter checks syntax, not whether a particular application accepts a field.

How to Format, View and Parse JSON Online

A JSON formatter, viewer, beautifier and parser can overlap in everyday terminology. But each word describes a different goal. Choosing the right operation saves time when debugging APIs or opening unfamiliar files.

The PerkAbility Rewards JSON Formatter is an entry point for formatting and reviewing example JSON. If you need schema-level validation, choose a dedicated JSON Schema validator that supports the dialect required by your project. Do not assume every formatter performs every operation listed in the table.

Why Does JSON Parsing Fail? Common Syntax Problems

Many searches for “json parse online,” “json parser,” and “json validator” begin when a piece of data looks correct but an application rejects it. The first step is to find out whether the problem is syntax or application requirements.

{
  "tool": "formatter",
  "active": true,
}

{
  "tool": "formatter",
  "active": true
}

The invalid example has an extra comma after its final property. In strict JSON, a comma separates members; it does not follow the last member. JavaScript may allow trailing commas in certain object literals, but JSON does not.

{ tool: "formatter" }

{ "tool": "formatter" }

Other common causes are unescaped double quotes in strings, truncated files, unmatched braces, comments, single-quoted keys or values, and invalid literals such as undefined. Error messages vary by parser.

For targeted troubleshooting, use our existing 12 Common JSON Errors and How to Fix Them guide. This article concentrates on understanding the structure before attempting the fix.

What Is JSON Schema and Why Is It Different from JSON Syntax?

A JSON file may be syntactically correct but still be unusable in a specific API. For example, an API might expect a field called version to be an integer, not a text string, or require an array of tags even when it is empty. A general JSON parser has no reason to reject the wrong type unless the application checks it.

JSON Schema is a declarative language for describing and validating constraints on JSON documents. It can specify which properties are required, what types are permitted, minimum or maximum values, and relationships among fields.

A beginner JSON Schema example

This small schema validates an object that has a project name, a positive version integer, and a published status:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "project": {
      "type": "string"
    },
    "version": {
      "type": "integer",
      "minimum": 1
    },
    "published": {
      "type": "boolean"
    }
  },
  "required": ["project", "version", "published"]
}

The example data from the opening section passes these particular rules. It may contain additional properties because this schema does not forbid them. If you need to disallow unspecified properties, explore the additionalProperties keyword and check the dialect's exact behavior.

{
  "project": "Example",
  "version": "2",
  "published": true
}

{
  "project": "Example",
  "version": 2,
  "published": true
}

Both objects are valid JSON text. Only the second matches the example schema because the first stores the version as a string instead of an integer. This is why searches for “json schema validator” should not lead only to a formatting button.

When should you use a JSON Schema validator?

• To validate API requests or responses against a documented contract.
• To enforce consistent field types in configuration files.
• To detect missing required properties before sending a request.
• To describe and document acceptable payload shapes.
• To test AI-assisted structured data against an expected schema, while verifying any factual content separately.

Schema support depends on the validator and dialect. The sample uses draft 2020-12; another application may rely on a different supported version. A schema does not prove that a URL is safe or that a payment record reflects a genuine transaction.

How to Read, Parse and Pretty-Print JSON in Python

Python includes a standard json library, so no extra package is required for common parsing and serialization tasks. Use json.loads() for a string and json.load() for a file. Use json.dumps() to create JSON text from an ordinary Python value.

import json

raw = '{"project": "PerkAbility Rewards", "version": 2}'
data = json.loads(raw)

print(data["project"])
print(data["version"])

formatted = json.dumps(data, indent=2)
print(formatted)

How to read an existing .json file

import json

with open("sample.json", "r", encoding="utf-8") as file:
    data = json.load(file)

print(data)

This assumes sample.json exists and contains valid JSON. For automated programs, handle json.JSONDecodeError, missing files and permission errors. Avoid loading unknown enormous files without limits.

How to save a JSON file

import json

data = {"name": "Example", "enabled": True}

with open("settings.json", "w", encoding="utf-8") as file:
    json.dump(data, file, indent=2)

Python's True becomes true when serialized into JSON. That distinction matters: Python literals and JSON literals are not identical. If you need predictable encoding of international text, review ensure_ascii and UTF-8 handling in the official Python json module documentation.

How to Parse JSON in JavaScript

JavaScript provides JSON.parse() and JSON.stringify(). The first converts a JSON string to a JavaScript value; the second serializes a compatible value to JSON text.

const raw = '{"items":["book","pen"],"ready":true}';
const data = JSON.parse(raw);

console.log(data.items[0]); // book
console.log(data.ready);    // true

const pretty = JSON.stringify(data, null, 2);
console.log(pretty);

Parsing untrusted input can throw a syntax error, so catch errors where appropriate. Avoid using eval() to interpret JSON; JSON is data and should be handled by a JSON parser, not executed as code. For more examples, consult MDN's JSON reference.

JSON in APIs, GitHub, Web Apps and Data Workflows

JSON is popular because browsers, backend services, scripts and development tools can exchange structured values without agreeing on one programming language. A weather API, for example, might return a JSON object containing an observation time, temperature and location. A front-end application can then display those values in a user interface.

GitHub repositories commonly contain JSON configuration files and test fixtures. You may also encounter JSON in Node.js packages, application manifests, website deployment settings, and API testing tools. These uses share a syntax, but the expected fields and security requirements come from the surrounding application.

For example, a Node.js project may use package.json for scripts and dependencies, whereas an API may use a JSON request body to create a customer record. Valid syntax does not guarantee either one has the correct application-specific content.

JSON vs JSONL vs CSV vs XML: Which Format Should You Use?

Some of the top searches in your dataset involved JSONL, CSV, XML, and file conversion. These related terms are worth understanding, but they solve somewhat different problems.

JSONL is not simply a JSON array split across lines. A file containing multiple JSON objects on separate lines is often valid JSON Lines, but it is not valid as one JSON document unless those objects are arranged into a proper JSON array. Keep that distinction in mind when using a formatter expecting a single JSON value.

How to convert JSON to CSV or Excel

Start by checking whether the JSON data is naturally tabular. An array of simple objects with consistent fields can map to rows and columns. Nested arrays or inconsistent fields require decisions about flattening, repeating rows, or retaining nested data. Those transformations may lose structural information if handled carelessly.

A JSON formatter alone does not necessarily convert JSON to CSV, Excel, PDF or XML. Use a purpose-built converter, script, spreadsheet import workflow or programming library designed for the output format. Check whether field types, Unicode text and null values survive conversion accurately.

What is JSONPath?

JSONPath is a query language used in some tools to select values from JSON documents. For example, a path resembling $.contact.method can identify a nested property in our example object. Support and syntax details vary by tool, so consult its implementation. JSONPath queries are not a replacement for validating the whole document.

What is JSON-LD?

JSON-LD stands for JSON for Linked Data. It is a way to express linked data using JSON syntax and is widely encountered in structured website metadata. When adding schema markup to a site, use accurate types and properties appropriate to the actual page. Merely inserting a JSON-LD block does not guarantee enhanced search appearance or indexing.

A Practical Checklist Before Publishing or Sending JSON

1. Inspect the source. Confirm the file or API response belongs to a source you trust and contains the expected type of data.
2. Verify that it is one valid JSON value. Don't combine multiple independent top-level objects into an invalid document.
3. Run a syntax check. Use an appropriate parser or a formatter for non-sensitive samples.
4. Check nested structure. Verify braces, brackets, key names, arrays and null values.
5. Apply the application's schema. Make sure required fields and value types match the receiving system.
6. Test the actual workflow. Try a staging or development request rather than assuming formatted text will work in production.
7. Protect confidential information. Do not upload API keys, passwords, private business documents, or customer records into an unapproved online tool.

Frequently Asked Questions About JSON

Conclusion: Start with JSON Structure, Then Validate the Real Use Case

The most useful skill for working with JSON is understanding its structure. Once you know how objects, arrays, property names and values fit together, it becomes easier to open files, read API examples, catch syntax errors, and apply JSON Schema checks. Python and JavaScript offer built-in parsing tools, while browser-based formatters can support small, practical learning tasks.

Our short-window search snapshot showed growing interest in JSON structure, JSON examples and JSON Schema. These are related learning needs, not instructions to repeat the same keywords throughout every paragraph. The best next step is to try a sample, verify it, and understand why it works.

Standards and Reference Documentation

• IETF RFC 8259: JSON Data Interchange Format
• MDN: Working with JSON
• MDN: JavaScript JSON object
• JSON Schema: Getting Started
• Python standard library: json module

Research note: Keyword observations are drawn from two worldwide top/rising-query CSV exports covering October 30–31, 2026. Normalized search interest is not absolute volume. This educational article was prepared with AI assistance and reviewed for example consistency. PerkAbility Rewards is an independent developer-tools website. Advertisements are separate from the editorial content.