How to validate JSON online: a developer guide with practical examples

JSON (JavaScript Object Notation) is the most widely used data interchange format in modern web development. Virtually every REST API returns data in JSON, tool configurations like package.json and tsconfig.json use this format, and databases like MongoDB store documents in JSON format.

The problem is that a single misplaced character (an extra comma, a missing quote, an unclosed bracket) makes the entire JSON invalid and causes errors in your application. Invalid JSON in an API response can break your frontend. A tsconfig.json with a syntax error prevents TypeScript from compiling.

Validating JSON before using it prevents hours of debugging. With the NexTools JSON validator, you can paste any JSON, see errors with the exact line number where they occur, and get the prettified format automatically.

JSON has strict syntax rules. Breaking any of them produces invalid JSON:

• Keys must be in double quotes: {"name": "Ana"} is valid. {name: "Ana"} is NOT.
• Strings use double quotes, never single: "value" is valid. 'value' is NOT.
• No trailing commas: {"a": 1, "b": 2} is valid. {"a": 1, "b": 2,} is NOT.
• No comments: You cannot use // or /* */ inside JSON. For configs that need comments, use JSONC or JSON5.
• Numbers are not quoted: {"age": 25} is valid. {"age": "25"} works but the value is a string, not a number.

Allowed data types in JSON:

Type	Example	Notes
String	"hello world"	Always double quotes
Number	42, 3.14, -7	Integers or decimals, no quotes
Boolean	true, false	Lowercase, no quotes
Null	null	Lowercase, no quotes
Array	[1, 2, 3]	Comma-separated values
Object	{"key": "value"}	Key-value pairs

These are the errors you will encounter most frequently when working with JSON:

1. Trailing comma on the last element:
   {"items": [1, 2, 3,]} — The comma after 3 is invalid.
2. Single quotes instead of double:
   {'name': 'John'} — Must be {"name": "John"}.
3. Unquoted keys:
   {age: 30} — Must be {"age": 30}.
4. Unescaped control characters:
   Literal tabs and newlines inside strings must be written as \t and \n.
5. Unescaped quotes inside strings:
   {"text": "he said "hello""} — Must be {"text": "he said \"hello\""}.
6. Comments:
   JSON does not support comments of any kind.
7. NaN, Infinity, or undefined:
   These JavaScript values are NOT valid in JSON. Use null instead.
8. Hexadecimal values:
   {"color": 0xFF0000} is not valid. Use {"color": "#FF0000"} or {"color": 16711680}.
9. Mixed types in typed arrays:
   [1, "two", true] is valid JSON, but many APIs expect homogeneous arrays.
10. BOM (Byte Order Mark):
    Some editors add invisible bytes at the start of the file that invalidate JSON. Always save as UTF-8 without BOM.

All of these errors are detected automatically by the JSON validator, which shows you the exact line and position of each error.

JSON can be presented in two ways: pretty-printed for human readability, and minified for efficient transmission.

Pretty-printed JSON:

{
  "user": {
    "name": "Maria",
    "age": 28,
    "active": true
  }
}

Minified JSON (same data, fewer bytes):

{"user":{"name":"Maria","age":28,"active":true}}

The minified version takes up less space (ideal for APIs and storage), while the pretty-printed version is much easier to read and debug. In the example above, minified JSON is 48 bytes vs 75 bytes prettified — a 36% reduction.

In JavaScript, you can format JSON with:

JSON.stringify(data, null, 2)  // pretty with 2 spaces
JSON.stringify(data)           // minified

For minifying large JSON files, use the code minifier which handles JSON, CSS, and JavaScript.

Before JSON, XML was the dominant data interchange format. Both are still in use, but for different purposes:

Feature	JSON	XML
Readability	More concise	More verbose
Size	30-50% smaller	Larger
Data types	String, number, boolean, null, array, object	Everything is text
Comments	Not supported	Supported
Schemas	JSON Schema	XSD, DTD
Primary use	REST APIs, configuration	SOAP, documents, RSS
Parsing	Native JSON.parse()	Requires XML parser

In 2026, JSON dominates in web development, APIs, and mobile applications. XML remains in legacy enterprise systems, RSS/Atom feeds, and document formats like DOCX (which is internally compressed XML).

Besides validating JSON, these complementary tools make your workflow easier:

• JSON Validator: Checks syntax, shows errors with line numbers, and auto-formats.
• Code Minifier: Compresses JSON by removing whitespace and line breaks.
• Base64 Encoder: Encodes JSON to Base64 for transmission in URLs or HTTP headers.
• Text Comparator: Compare two JSON versions to find differences.

In the browser:

• JSON.parse(jsonString) — Converts a JSON string to a JavaScript object. Throws an error if the JSON is invalid.
• JSON.stringify(obj, null, 2) — Converts an object to formatted JSON.
• console.dir(JSON.parse(json)) — Displays the JSON structure interactively in the console.

Syntax validation only checks that JSON is well-formed. But in real applications, you also need to verify that data has the correct structure (required fields exist, types are correct, values fall within expected ranges).

This is what JSON Schema is for — a standard for describing the structure of JSON documents:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["name", "age", "email"],
  "properties": {
    "name": { "type": "string", "minLength": 1 },
    "age": { "type": "integer", "minimum": 0, "maximum": 150 },
    "email": { "type": "string", "format": "email" }
  }
}

With this schema, you can automatically validate that any user JSON has a name (non-empty string), age (integer between 0 and 150), and email (valid format). Libraries like Ajv (JavaScript), jsonschema (Python), and Newtonsoft (.NET) implement JSON Schema validation.

In professional development, defining JSON Schemas for your APIs is one of the best practices for preventing errors and automatically documenting your API.

These practices will help you avoid common issues in real projects:

• Always validate JSON from external sources: Any JSON you receive from an API, user-uploaded file, or webhook should go through JSON.parse() inside a try-catch before processing.
• Use camelCase for keys: This is the standard convention in JavaScript/TypeScript. userName instead of user_name or UserName.
• Avoid nesting more than 3-4 levels: Deeply nested JSON is hard to read, traverse, and maintain. Flatten the structure when possible.
• Never store sensitive data in unencrypted JSON: Tokens, passwords, and private keys should never appear in plain JSON in logs or API responses.
• Use null instead of omitting optional fields: {"middleName": null} is better than omitting the field, because the API consumer knows explicitly that the field exists but has no value.
• Handle parse errors gracefully: Do not show the raw JSON.parse error to end users. Log it internally and display a friendly message.