JSON Validator

What is JSON Validation?

JSON (JavaScript Object Notation) validation is the process of checking whether a string of text conforms to the JSON specification defined in RFC 8259. A valid JSON document must follow strict syntax rules — unlike JavaScript object literals, JSON does not allow comments, trailing commas, single-quoted strings, or unquoted property names. Validation catches these issues before they cause runtime errors in your applications.

Our validator parses your input, reports the exact line and column where an error occurs, and suggests fixes for the most common mistakes. All processing happens locally in your browser — your data is never sent to a server.

JSON Syntax Rules

Every valid JSON document must follow these rules:

• Strings must use double quotes ("hello"). Single quotes, backticks, and unquoted text are invalid.
• Property names must also be double-quoted: {"name": "value"} is valid, {name: "value"} is not.
• Numbers cannot have leading zeros (0.5 is valid, 05 is not) and must use a decimal point, not a comma.
• Booleans are lowercase only: true and false. True, TRUE, and yes are invalid.
• Null is lowercase: null. None, nil, and undefined are invalid.
• No trailing commas after the last element in an object or array.
• No comments — neither // nor /* */ are allowed in JSON.
• Special characters in strings must be escaped: \n for newlines, \t for tabs, \" for quotes, \\ for backslashes.

Common JSON Errors and How to Fix Them

These are the errors developers encounter most often when working with JSON:

1. Unquoted Property Names

Property names in JSON must always be wrapped in double quotes. This is one of the most frequent mistakes, especially for developers coming from JavaScript.

// ❌ Invalid — unquoted keys
{name: "Alice", age: 30}

// ✅ Valid — double-quoted keys
{"name": "Alice", "age": 30}

2. Trailing Commas

JSON does not allow a comma after the last element in an object or array. Many programming languages and config formats (like JavaScript and JSON5) allow this, but strict JSON does not.

// ❌ Invalid — trailing comma after "React"
{"skills": ["JavaScript", "React",]}

// ✅ Valid — no trailing comma
{"skills": ["JavaScript", "React"]}

3. Single Quotes Instead of Double Quotes

JSON strictly requires double quotes for both property names and string values. Single quotes are a syntax error.

// ❌ Invalid — single quotes
{'name': 'Alice'}

// ✅ Valid — double quotes
{"name": "Alice"}

4. Missing or Extra Brackets

Every opening brace or bracket must have a matching closing one. Deeply nested structures make this error easy to miss.

// ❌ Invalid — missing closing brace
{"user": {"name": "Alice"}

// ✅ Valid — all brackets matched
{"user": {"name": "Alice"}}

5. Using JavaScript Values

JSON is not JavaScript. Values like undefined, NaN, Infinity, and functions are not valid JSON.

// ❌ Invalid — undefined is not a JSON value
{"status": undefined}

// ✅ Valid — use null instead
{"status": null}

How to Validate JSON in Your Code

While our online tool is great for quick checks, you often need to validate JSON programmatically. Here is how to do it in popular programming languages:

JavaScript / Node.js

function isValidJSON(str) {
  try {
    JSON.parse(str);
    return true;
  } catch (e) {
    console.error("Invalid JSON:", e.message);
    return false;
  }
}

Python

import json

def is_valid_json(text):
    try:
        json.loads(text)
        return True
    except json.JSONDecodeError as e:
        print(f"Invalid JSON: {e}")
        return False

Java

import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;

public static boolean isValidJson(String json) {
    try {
        JsonParser.parseString(json);
        return true;
    } catch (JsonSyntaxException e) {
        System.err.println("Invalid JSON: " + e.getMessage());
        return false;
    }
}

When to Validate JSON

You should validate JSON in these situations to prevent bugs, crashes, and security issues:

• API responses: Always validate data received from external APIs before processing. Malformed responses can crash your application or lead to unexpected behavior.
• User input: Any JSON submitted by users (form data, file uploads, webhook payloads) must be validated and sanitized before use.
• Configuration files: Validate config files at application startup to catch typos and syntax errors early, before they cause runtime failures.
• Data pipelines: Validate JSON at each stage of ETL pipelines to prevent corrupted data from propagating downstream.
• Before storage: Validate JSON before writing to databases or files to maintain data integrity.

JSON Validation Best Practices

• Validate early, validate often — catch errors at the system boundary (API entry point, file read, user input) rather than deep in your business logic.
• Use schema validation — syntax validation only checks structure. Use JSON Schema to validate that values meet your business rules (required fields, value ranges, string patterns).
• Provide clear error messages — when validation fails, tell the user exactly what is wrong and where. Line numbers and column positions help users fix issues quickly.
• Handle encoding correctly — JSON must be UTF-8 encoded. Watch for BOM (Byte Order Mark) characters at the start of files, which can cause parse failures.
• Set size limits — protect your application from denial-of-service attacks by limiting the maximum size of JSON input you accept.
• Test with edge cases — validate against empty objects {}, empty arrays [], deeply nested structures, and very large numbers to ensure your parser handles them correctly.