How to Validate JSON: Tools and Best Practices

JSON validation is the process of checking that a JSON document is correctly formatted and, optionally, that it conforms to a specific structure. There are two distinct levels of validation, and understanding the difference helps you choose the right tool for the job.

Syntax Validation vs Schema Validation

Most day-to-day issues are syntax errors. Schema validation is used in production systems where the shape of the data matters — for example, ensuring an API response always includes a required userId field of type string.

The Most Common JSON Syntax Errors

1. Trailing Commas

This is the single most common JSON mistake, especially among people who write JavaScript regularly where trailing commas are allowed:

// Invalid JSON
{
  "name": "Alice",
  "age": 30,   ← trailing comma
}

// Valid JSON
{
  "name": "Alice",
  "age": 30
}

2. Single Quotes Instead of Double Quotes

// Invalid JSON
{ 'name': 'Alice' }

// Valid JSON
{ "name": "Alice" }

3. Unquoted Keys

// Invalid JSON
{ name: "Alice" }

// Valid JSON
{ "name": "Alice" }

4. Mismatched Brackets

Every opening { needs a closing }, and every [ needs a ]. In large JSON files this is easy to miss.

// Invalid — missing closing bracket
{
  "users": [
    { "name": "Alice" },
    { "name": "Bob" }
  // ← missing ]
}

5. Comments in JSON

JSON does not support comments. This surprises many developers coming from JavaScript:

// Invalid JSON — comments not allowed
{
  // This is the user's name
  "name": "Alice"
}

6. Incorrect Number Formats

JSON numbers cannot have leading zeros, and infinity/NaN are not valid:

// Invalid
{ "count": 007 }         // leading zeros
{ "ratio": Infinity }    // Infinity not supported
{ "value": NaN }         // NaN not supported

// Valid
{ "count": 7 }
{ "ratio": 1.7e308 }

Best Free JSON Validators

JSONLint

The most widely used online JSON validator. Paste your JSON, click Validate, and it highlights the exact line and character of any error with a clear explanation. Handles large files well.

Browser Developer Console

Every browser has a JavaScript console (press F12). You can validate JSON instantly by typing:

JSON.parse('{ "name": "Alice" }')

If the JSON is valid, it returns the parsed object. If not, it throws a SyntaxError with the position of the error. This is the fastest method when you are already in a browser.

VS Code with Built-in JSON Language Server

VS Code automatically validates JSON files as you type. Red underlines indicate syntax errors, and hovering over them shows a description of the problem. This is the best option when editing JSON files locally.

Command Line with Python

Python ships with a built-in JSON validator accessible from the terminal:

python -m json.tool data.json

This prints the formatted JSON if it is valid, or a clear error message if not. Useful for validating files in scripts or CI pipelines.

Node.js

node -e "JSON.parse(require('fs').readFileSync('data.json', 'utf8'))"

Returns exit code 0 on success, non-zero on error — ideal for shell scripts.

Schema Validation with JSON Schema

Syntax validation only checks that the JSON is well-formed. Schema validation goes further by checking that the data has the right structure — correct field names, types, and required properties.

A JSON Schema is itself a JSON document that describes the expected shape of your data:

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

This schema requires a name string and a non-negative integer age. Any JSON document that does not match these constraints will fail validation.

Tools for Schema Validation

• Ajv — the fastest JavaScript JSON Schema validator, widely used in Node.js
• jsonschema — Python library for JSON Schema validation
• Postman — validates API response bodies against schemas in automated test collections
• JSON Schema Faker — generates sample data from a schema, useful for testing

Validating JSON Before Converting to Excel

When you are converting JSON to Excel, validating the file first saves a lot of trouble. Invalid JSON will cause converters to fail or produce incomplete output. The main things to check before conversion are:

1. Is it syntactically valid? Run it through a validator before uploading.
2. Is it an array at the top level? Most converters expect an array of objects, not a single object.
3. Are the keys consistent across objects? Inconsistent keys create sparse columns with many empty cells.
4. Are there deeply nested objects? These will be flattened — decide in advance whether that output is what you need.

Fixing Malformed JSON Automatically

If you are receiving JSON from an external source that occasionally has minor formatting issues (like trailing commas), you have a few options:

• JSON5 — a superset of JSON that allows comments, trailing commas, and unquoted keys. Parse with the json5 library and re-serialize as standard JSON.
• HJSON — a human-friendly JSON format with similar relaxed rules.
• Python's demjson3 — a Python library that can parse and repair some malformed JSON.

For critical production data pipelines, always enforce strict validation and reject malformed input rather than trying to auto-repair it. Silent data corruption is worse than a visible error.