JSON Validator Online

Ready to validate your JSON?

Free, instant, 100% private. No account needed.

The 10 Most Common JSON Errors (and How to Fix Them)

JSON syntax is strict. Even a single misplaced character will cause a parse failure. Here are the 10 errors that account for the vast majority of invalid JSON in the wild — each with a before-and-after example.

1. Trailing comma — {"a":1,} → {"a":1} — Remove the comma after the last element
2. Single quotes — {'key':'val'} → {"key":"val"} — JSON requires double quotes everywhere
3. Unquoted key — {name:"Alice"} → {"name":"Alice"} — All keys must be quoted strings
4. undefined value — {"x":undefined} → {"x":null} — undefined is a JavaScript concept; use null
5. Missing comma between pairs — {"a":1 "b":2} → {"a":1,"b":2} — Each key-value pair must be comma-separated
6. Comments in JSON — {"a":1 // note} → {"a":1} — Comments are not valid JSON; remove them entirely
7. NaN or Infinity — {"x":NaN} → {"x":null} — Use null or a numeric string instead
8. Unescaped special character — {"msg":"say "hi""} → {"msg":"say \"hi\""} — Escape double quotes inside strings with \"
9. Control character in string — A raw tab or newline inside a string value is invalid. Use \t or \n escape sequences instead
10. Trailing text after root — {"a":1} extra → {"a":1} — JSON must have exactly one root value with nothing after it

JSON Validation in Different Languages

Every major language has a built-in or standard-library way to validate JSON. Here is the idiomatic pattern in each:

JavaScript

function isValidJSON(str) {
  try {
    JSON.parse(str);
    return true;
  } catch (e) {
    return false;
  }
}

// With error detail
function validateJSON(str) {
  try {
    const parsed = JSON.parse(str);
    return { valid: true, data: parsed };
  } catch (e) {
    return { valid: false, error: e.message };
  }
}

Python

import json

def validate_json(text):
    try:
        data = json.loads(text)
        return True, data, None
    except json.JSONDecodeError as e:
        return False, None, str(e)

valid, data, err = validate_json('{"name": "Alice"}')
print(valid)   # True

PHP

<?php
function isValidJSON(string $str): bool {
    json_decode($str);
    return json_last_error() === JSON_ERROR_NONE;
}

// PHP 8.3+: json_validate() built-in
$valid = json_validate('{"name": "Alice"}'); // true

Bash (jq)

# Returns exit code 0 for valid, non-zero for invalid
echo '{"name":"Alice"}' | jq . > /dev/null 2>&1
if [ $? -eq 0 ]; then echo "Valid JSON"; else echo "Invalid JSON"; fi

# Validate a file
jq . myfile.json > /dev/null 2>&1 && echo "Valid" || echo "Invalid"

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
    fmt.Println(isValidJSON(`{name:"Alice"}`))   // false
}

JSON Validator vs JSON Schema Validator

There are two distinct types of JSON validation. A basic JSON validator checks syntax — is this valid JSON? A JSON Schema validator checks structure and semantics — does this JSON match a defined shape? Understanding the difference helps you choose the right tool for the job.

In practice, you need both: run a JSON validator first to ensure parseable JSON, then run a schema validator to ensure the data matches your application's expected shape. This tool handles the first step — see our JSON Schema Tutorial for the second.