How to Validate JSON: A Complete Guide for Developers

Invalid JSON is one of the most common causes of API failures and config errors. Here's how to catch problems before they cause outages.

What Does "Valid JSON" Actually Mean?

JSON (JavaScript Object Notation) follows a strict syntax defined by RFC 8259. Unlike JavaScript objects, JSON has no room for flexibility — a single misplaced comma or unquoted key will make the entire document invalid.

Valid JSON must follow these rules:

• Data is organized in key-value pairs within curly braces {} for objects
• Ordered lists use square brackets [] for arrays
• Keys must be double-quoted strings — single quotes are not allowed
• Values can be strings, numbers, booleans (true/false), null, objects, or arrays
• No trailing commas after the last element
• No comments (unlike JavaScript)
• Strings must use double quotes, not single quotes

The 7 Most Common JSON Validation Errors

1. Trailing Commas

This is the #1 mistake developers make. JavaScript allows trailing commas, but JSON does not:

// ❌ Invalid — trailing comma after "admin"
{
  "name": "Alice",
  "role": "admin",
}

// ✅ Valid
{
  "name": "Alice",
  "role": "admin"
}

2. Single Quotes Instead of Double Quotes

Python developers frequently hit this when converting dictionaries to JSON:

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

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

3. Unquoted Keys

JavaScript object literals allow unquoted keys, but JSON requires them:

// ❌ Invalid
{name: "Alice"}

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

4. Comments in JSON

There are no comments in JSON. Period. If you see // or /* */ in a JSON file, it's technically invalid (though some parsers like JSON5 allow them):

// ❌ Invalid
{
  // user's name
  "name": "Alice"
}

// ✅ Valid — use a descriptive key instead
{
  "userName": "Alice"
}

5. Missing or Extra Brackets

Deeply nested JSON makes it easy to lose track of opening and closing brackets:

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

// ✅ Valid
{
  "users": [
    {"name": "Alice"},
    {"name": "Bob"}
  ]
}

6. Using undefined or NaN

These are JavaScript values that have no equivalent in JSON:

// ❌ Invalid
{"value": undefined, "count": NaN}

// ✅ Valid
{"value": null, "count": 0}

7. Improper String Escaping

Strings containing special characters need proper escaping:

// ❌ Invalid — unescaped newline and quote
{"message": "Hello "world"
next line"}

// ✅ Valid
{"message": "Hello \"world\"\nnext line"}

How to Validate JSON in Different Languages

JavaScript / Node.js

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

// Usage
isValidJSON('{"name": "Alice"}');  // true
isValidJSON("{'name': 'Alice'}");  // false

Python

import json

def is_valid_json(text):
    try:
        json.loads(text)
        return True
    except json.JSONDecodeError as e:
        print(f"Invalid JSON at line {e.lineno}, col {e.colno}: {e.msg}")
        return False

# Usage
is_valid_json('{"name": "Alice"}')  # True
is_valid_json("{'name': 'Alice'}")  # False

Command Line (jq)

# Validate a JSON file
jq empty myfile.json

# Validate a string
echo '{"name": "Alice"}' | jq empty

# If invalid, jq will print the error and exit with code 1

Go

package main

import (
    "encoding/json"
    "fmt"
)

func isValidJSON(s string) bool {
    var js json.RawMessage
    return json.Unmarshal([]byte(s), &js) == nil
}

func main() {
    fmt.Println(isValidJSON(`{"name": "Alice"}`))  // true
}

Validation vs. Schema Validation

There's an important distinction between syntax validation and schema validation:

• Syntax validation checks if the JSON is well-formed — proper brackets, quotes, and data types. This is what JSON.parse() does.
• Schema validation checks if the JSON matches a specific structure — required fields, value types, string patterns, etc. This requires tools like JSON Schema.

For example, this JSON is syntactically valid but might fail schema validation if "email" is a required field:

// Syntactically valid, but missing required "email"
{
  "name": "Alice",
  "age": 30
}

For most debugging scenarios, syntax validation is what you need first. Schema validation comes into play when you're building APIs and want to enforce specific data contracts.

Online JSON Validation: The Fastest Approach

When you're debugging a quick API response or config file, the fastest approach is an online validator. No setup, no dependencies — just paste and check.

Our JSON Formatter & Validator provides:

• Real-time validation — errors appear as you type
• Pinpointed errors — see exactly which line and character caused the issue
• Auto-formatting — once validated, pretty-print with one click
• Privacy — everything runs in your browser, no data sent to any server

Best Practices for Avoiding JSON Errors

1. Never hand-write JSON — use your language's built-in serializer (JSON.stringify(), json.dumps(), etc.)
2. Use a linter in your editor — VS Code, Try Neon Postgres, and others flag JSON errors in real-time
3. Validate before deploying — add JSON validation to your CI/CD pipeline
4. Use JSON Schema for APIs — enforce structure beyond just syntax
5. Test with edge cases — empty objects, deeply nested data, Unicode characters, large numbers

Frequently Asked Questions

Can JSON have comments?

No. Standard JSON (RFC 8259) does not support comments. If you need comments in config files, consider JSON5 or JSONC formats, which some tools support.

Why does my JSON work in JavaScript but fail in a validator?

JavaScript object literals are more permissive than JSON — they allow unquoted keys, trailing commas, single quotes, and comments. JSON is a stricter subset.

How do I validate a large JSON file?

For files under 10MB, an online validator works fine. For larger files, use command-line tools like jq empty largefile.json or python -m json.tool largefile.json.

What's the difference between JSON.parse() and a JSON validator?

JSON.parse() validates syntax and returns a JavaScript object. A dedicated validator may also check schema compliance, format the output, and provide detailed error messages with line numbers.

Related reading: JSON Formatter Online Free · How to Fix JSON Errors