To validate JSON, parse the JSON text with a JSON parser or use a JSON validator. If parsing succeeds, the text is syntactically valid JSON. If you also need to confirm that the data contains specific properties, types, required fields, or allowed values, validate it against a JSON Schema. Syntax validation answers 'Is this valid JSON?' while schema validation answers 'Does this valid JSON have the structure my application expects?'

JSON.parse(jsonText)

How to Validate JSON Syntax and Data Structure

JSON validation is the process of checking whether JSON text can be parsed correctly and, when necessary, whether its data follows a required structure. These are separate checks. A parser can confirm that a document follows JSON syntax, but it cannot know whether an API requires a field such as `userId`, whether a value must be a number, or whether an array may contain only certain objects. For those requirements, use JSON Schema or application-level validation.

What Does JSON Validation Mean?

JSON validation can refer to two related checks. The first is syntax validation: determining whether the text is valid JSON and can be parsed. The second is structural or schema validation: checking whether valid JSON follows a defined set of rules. Keeping these meanings separate prevents a common debugging mistake where syntactically valid JSON is assumed to be valid for a particular API or application.

JSON Syntax Validation vs JSON Schema Validation

Syntax validation checks the JSON format itself. It catches problems such as missing commas, unmatched braces, malformed strings, invalid escape sequences, and unsupported values. JSON Schema validation operates one level higher. It can require properties, define data types, restrict values, specify array contents, and describe nested object structures.

/guides/json-schema

Syntax validation

Can this text be parsed as JSON?

Checks: JSON grammar and syntax

Missing comma between properties

Schema validation

Does this valid JSON follow the expected data model?

Checks: Properties, types, required fields, values, arrays, nested structures

The age field must be a number

Validate JSON Online

For a quick syntax check, paste JSON into a JSON validation or formatting tool. A validator should parse the input and report whether the document is valid. When the input is invalid, useful error information can identify the approximate location and nature of the problem. Do not use an external validator for confidential production data unless its data handling is appropriate.

Copy the JSON text.
Paste it into a JSON validator or formatter.
Run the validation operation.
Review the result or parser error.
Correct syntax problems if validation fails.
Run validation again.
Use JSON Schema when structural validation is also required.

Validate JSON with JavaScript

JavaScript provides a straightforward way to test whether a string contains valid JSON. JSON.parse() throws a SyntaxError when the input cannot be parsed.

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

A successful JSON.parse() call confirms that the input is syntactically valid JSON. It does not confirm that the resulting object satisfies an application's business rules or API schema.

Read the JSON Parsing Error

When JSON.parse() fails, the error usually points to a location where the parser could no longer continue. The reported position is useful, but the actual mistake may occur slightly earlier. Inspect the surrounding characters for missing commas, unmatched delimiters, malformed strings, or invalid values.

Unexpected token
Unexpected end of JSON input
Unexpected non-whitespace character after JSON data
Invalid escape sequence
Malformed JSON string

Validate JSON with Python

Python's standard json module can parse JSON strings and raise a JSONDecodeError when the input is invalid.

import json

try:
    data = json.loads(json_text)
    print("Valid JSON")
except json.JSONDecodeError as error:
    print(f"Invalid JSON: {error}")

json.loads() validates the JSON text as part of parsing. Once parsing succeeds, the resulting Python value can be checked against application-specific requirements.

Validate a JSON File

A JSON file can be validated by reading its contents and parsing them. This is useful for configuration files, fixtures, test data, exports, static datasets, and files committed to source control.

import json

with open("data.json", "r", encoding="utf-8") as file:
    data = json.load(file)

print("Valid JSON")

Run JSON validation in CI when invalid JSON files could break builds, deployments, configuration loading, or tests.

Validate JSON from an API Response

An HTTP response can have a successful status code and still contain a body that your application cannot use. Check the response status, Content-Type, body, JSON syntax, and expected structure separately. A 200 response does not automatically mean the body matches the API contract.

Check the HTTP status.
Inspect the Content-Type header.
Read the response body.
Parse the body as JSON.
Validate the expected structure or schema.
Handle missing, null, or unexpected values.

Validate JSON Request Payloads

Incoming API payloads should be validated before application logic relies on them. Syntax validation ensures the request body can be parsed, while schema or application validation checks fields, types, ranges, required values, and other endpoint-specific rules.

const payload = JSON.parse(requestBody);

// Schema or application validation happens after parsing.

/guides/format-json-payload

Validate JSON Webhook Payloads

Webhook processing commonly requires several independent checks. The request may need signature verification, JSON parsing, event-type validation, and schema or field validation. Do not treat successful JSON parsing as proof that a webhook request is authentic or represents a supported event.

If a webhook signature is calculated from the raw request body, verify the signature using the original bytes before replacing or normalizing the body for processing.

/guides/format-webhook-json

Validate JSON with JSON Schema

JSON Schema provides a declarative way to describe the expected structure of JSON data. A schema can specify required properties, data types, string constraints, numeric limits, array rules, nested objects, enumerated values, and other structural requirements.

JSON Schema

{
  "type": "object",
  "required": ["name", "age"],
  "properties": {
    "name": {
      "type": "string"
    },
    "age": {
      "type": "integer",
      "minimum": 0
    }
  }
}

/guides/json-schema

Required Fields and Optional Fields

A JSON object can contain any set of properties unless additional rules are imposed by an application or schema. JSON syntax alone does not know which properties are required. If an API requires `email` and `userId`, that requirement belongs to the API contract or validation layer, not to basic JSON syntax.

Validate JSON Data Types

JSON supports strings, numbers, objects, arrays, booleans, and null. Schema validation can require a particular property to use one of these types. This matters because a value such as `"42"` is a JSON string, while `42` is a JSON number. Both are valid JSON, but an application may accept only one of them.

{
  "id": 42,
  "name": "Ramesh",
  "active": true,
  "roles": ["developer"],
  "profile": null
}

Validate JSON Arrays

Arrays are valid JSON values and can contain objects, strings, numbers, booleans, null, or nested arrays. Syntax validation only checks that the array is correctly written. Schema validation can specify the type of each item, minimum or maximum item counts, uniqueness requirements, or more detailed item structures.

Validate Nested JSON Objects

Nested structures are common in API responses and application payloads. A top-level object can be syntactically valid even when a nested property contains the wrong type for the application's contract. Schema validation is useful when several levels of nested data must follow known rules.

Valid JSON Can Still Be Invalid for an API

Consider `{ "age": "unknown" }`. It is valid JSON because the value is a string. It may still fail an API contract that requires `age` to be an integer. This distinction is central to JSON validation: parser validity and application validity are not the same thing.

Formatting vs Validation

Formatting and validation are different operations. Formatting changes whitespace and presentation. Validation checks whether JSON can be parsed or whether it satisfies additional rules. A formatted document can still be invalid if the formatter is displaying JSON-like text rather than successfully parsing it.

Validation vs JSON Repair

Validation identifies whether the input is valid and often reports an error. Repair means changing malformed input so that it becomes valid. A validator should not silently rewrite data because that can hide the original problem or change the intended value. When JSON is invalid, inspect the reported location and repair the source deliberately.

/guides/fix-invalid-json

Validate JSON in Node.js

Node.js uses the JavaScript JSON implementation, so JSON.parse() can be used for syntax validation. For production applications, parsed values should then pass through the application's schema or request validation layer.

function parseJSON(text) {
  try {
    return { valid: true, data: JSON.parse(text) };
  } catch (error) {
    return { valid: false, error };
  }
}

Validate JSON with Command-Line Tools

Command-line JSON tools are useful in development and CI pipelines. jq can parse JSON and return a non-success status when the input cannot be parsed, making it practical for shell scripts and automated checks.

jq empty data.json

cat response.json | jq empty

Validate JSON in CI

If JSON files are part of a repository, validating them automatically can catch syntax errors before deployment. CI checks are especially useful for configuration files, generated JSON, fixtures, localization data, and static API definitions.

Identify JSON files that must remain valid.
Run a parser or validator in CI.
Fail the build when parsing fails.
Use schema validation for files with defined structures.
Review the failing file and correct the source.

Validate JSON Before Sending an API Request

Client-side validation can catch malformed or incomplete data before a request is sent, but server-side validation is still required because clients cannot be trusted as the sole validation boundary. The server should parse and validate incoming data according to its API contract.

Validate JSON After Receiving Data

External data should be treated as untrusted input even when it comes from an API that normally returns predictable JSON. Parse the response, validate its expected structure, handle missing fields, and avoid assuming that optional values are always present.

JSON Content-Type and Validation

An HTTP response commonly uses `application/json` when its body contains JSON. The Content-Type header is useful metadata, but it does not prove that the body is valid JSON. The actual body still needs to be parsed before an application treats it as JSON data.

Validate Empty or Null JSON

An empty HTTP response body is not the same as the JSON value `null`. The JSON text `null` is valid JSON and parses successfully, while an empty string contains no JSON value. Applications should distinguish an absent body, an empty body, the JSON value null, and an invalid response.

Validate JSON with Duplicate Keys

JSON object member names are expected to follow the rules of the applicable JSON specification, while parser behavior around duplicate names can vary. Some parsers keep the last occurrence, which can make duplicate keys dangerous in application data. If duplicate keys matter to your system, use a validation strategy that explicitly detects them rather than relying only on ordinary parsing.

Validate JSON Containing Unicode

JSON supports Unicode text. Validating JSON should not require ASCII-only content. Strings can contain characters from many writing systems, and JSON also provides escape sequences for representing characters. Encoding problems can still occur when JSON is transported or stored, so applications should use appropriate character encoding such as UTF-8.

Validate Large JSON Documents

Parsing a large JSON document normally requires memory proportional to the parsed data structure. For very large inputs, consider streaming parsers, incremental processing, or tools designed for large datasets. Do not assume that a successful syntax check means the document is inexpensive or safe to process.

Validate JSON Containing Sensitive Data

JSON can contain credentials, access tokens, personal information, internal identifiers, and other confidential values. Avoid sending sensitive production payloads to third-party online validators unless their data handling is acceptable. Redaction or local validation is safer for confidential data.

Common JSON Validation Problems

Most validation failures come from a small set of recurring syntax mistakes or from confusing syntax validity with application requirements.

Missing commas between object properties or array elements.
Unmatched `{}`, `[]`, or quotation marks.
Using single quotes instead of JSON double quotes.
Leaving property names unquoted.
Adding trailing commas.
Using comments in standard JSON.
Including JavaScript-only values such as undefined or NaN.
Malformed escape sequences.
Truncated JSON from an incomplete response.
Valid JSON with an unexpected data type.
Missing required fields.
Unexpected API response structures.

A Practical JSON Validation Workflow

Start with syntax and only move to schema or application validation after parsing succeeds. This keeps errors easier to diagnose and avoids mixing parser failures with business-rule failures.

Identify the source of the JSON.
Preserve the original input when debugging production data.
Check whether the body is empty or contains JSON text.
Parse the JSON.
Read and locate any syntax error.
Correct malformed JSON at its source.
Validate the parsed value against JSON Schema or application rules.
Handle missing, null, unexpected, or incorrectly typed fields.
Log validation failures without exposing secrets.
Test the validation path with valid and intentionally invalid examples.

Best Practices for JSON Validation

Use syntax parsing as the first validation boundary and schema or application validation for domain requirements. Keep validation close to the point where untrusted data enters the system. Return useful errors to developers without leaking credentials or sensitive payloads, and test both valid and invalid cases.

Parse JSON before using its fields.
Separate syntax validation from schema validation.
Validate untrusted external input on the server.
Use JSON Schema when the data contract is substantial.
Keep validation rules close to the API or data boundary.
Test malformed JSON as well as valid JSON.
Test missing, null, and incorrectly typed fields.
Avoid silently repairing malformed input.
Avoid logging sensitive JSON without redaction.
Use CI validation for important repository JSON files.

JSON Formatting Examples

Check whether JSON is syntactically valid

JavaScript

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

Parse JSON and keep the error

JavaScript

try {
  const data = JSON.parse(jsonText);
  console.log(data);
} catch (error) {
  console.error("Invalid JSON:", error.message);
}

Validate JSON with Python

Python

import json

try:
    data = json.loads(json_text)
    print("Valid JSON")
except json.JSONDecodeError as error:
    print(f"Invalid JSON: {error}")

Validate a JSON file

Python

import json

with open("data.json", encoding="utf-8") as file:
    data = json.load(file)

Check JSON with jq

Shell

jq empty data.json

Validate an API response with jq

Shell

curl -s https://example.com/api/data | jq empty

Example schema for validating an object

JSON Schema

{
  "type": "object",
  "required": ["name", "age"],
  "properties": {
    "name": {
      "type": "string"
    },
    "age": {
      "type": "integer",
      "minimum": 0
    }
  }
}

Formatting Checklist

Confirm that the input is supposed to be JSON.
Check whether the input is empty before parsing.
Parse the JSON with a standards-compliant parser.
Read the parser error when syntax validation fails.
Check commas, brackets, quotes, escapes, and values.
Do not confuse JavaScript object syntax with JSON syntax.
Use schema validation when a specific structure is required.
Check required properties and expected data types.
Validate external input on the server.
Handle null and missing fields explicitly.
Test invalid JSON as well as valid JSON.
Avoid silently repairing malformed data.
Redact sensitive information from validation logs.
Use CI validation for important JSON files.
Preserve raw webhook bodies when signature verification requires them.

Frequently Asked Questions

Q:How do I validate JSON?

Parse the JSON with a JSON parser or use a JSON validator. If parsing succeeds, the text is syntactically valid JSON. Use JSON Schema or application validation when you also need to check the expected data structure.

Q:How can I validate JSON online?

Paste JSON into a JSON validator or formatter that performs syntax parsing. Review the validation result or parser error. Do not submit confidential production data to an external service without checking its data handling.

Q:How do I know if JSON is valid?

A JSON parser can determine whether the text follows JSON syntax. In JavaScript, JSON.parse() succeeds for valid JSON and throws an error for malformed JSON.

Q:What is the difference between JSON validation and JSON Schema validation?

Basic JSON validation checks syntax. JSON Schema validation checks whether already-valid JSON follows a defined structure, including required properties, data types, arrays, values, and nested objects.

Q:Can a JSON formatter validate JSON?

A formatter normally needs to parse JSON before it can reliably format it, so many formatters implicitly perform syntax validation. However, formatting does not replace schema or application-level validation.

Q:Can valid JSON still be wrong?

Yes. JSON can be syntactically valid while containing the wrong data type, missing required fields, unexpected values, or a structure that does not match an API contract.

Q:How do I validate JSON in JavaScript?

Use JSON.parse() inside a try/catch block. A successful parse confirms valid JSON syntax. Additional validation should be performed against the application's expected structure.

Q:How do I validate JSON in Python?

Use json.loads() for JSON text or json.load() for a file. Invalid JSON raises json.JSONDecodeError.

Q:How do I validate a JSON file?

Read the file and parse it with a JSON parser. For important repositories, run the check automatically in CI so invalid files are caught before deployment.

Q:How do I validate an API JSON response?

Check the HTTP response, inspect Content-Type, parse the body as JSON, and then validate its expected structure. A successful HTTP status does not guarantee that the response body matches the API contract.

Q:How do I validate a JSON request payload?

Parse the request body first, then validate required fields, data types, allowed values, and other endpoint-specific rules. Server-side validation should remain the authoritative boundary.

Q:What should I do when JSON validation fails?

Read the parser error, inspect the surrounding input, and check for missing commas, unmatched brackets, malformed strings, invalid escapes, and invalid values. Fix the source data rather than silently changing it.

Q:Is null valid JSON?

Yes. The JSON literal null is valid JSON. An empty string, however, is not a JSON value and will not parse as JSON.

Q:Are empty JSON objects and arrays valid?

Yes. Both {} and [] are valid JSON values.

Q:Does JSON validation check API business rules?

Basic syntax validation does not. Business rules such as required fields, allowed values, authentication requirements, numeric ranges, or relationships between fields require application-level or schema validation.

Q:Can JSON validation be automated?

Yes. JSON parsing and schema validation can be integrated into applications, tests, CI pipelines, API gateways, and data-processing workflows.

Explore More Resources

JSON Formatter

JSON Schema guide

how to format JSON

fix invalid JSON

understand JSON parsing errors

Read more about understand JSON parsing errors

format JSON API responses

Read more about format JSON API responses

format REST API responses

Read more about format REST API responses

format JSON payloads

format webhook JSON

pretty print JSON

JSON Schema

JSON minifier

How to Validate JSON

Check JSON syntax, find parsing errors, verify data structure, and validate API payloads before your application uses them.

Validate JSON Online Learn JSON Schema

How do you validate JSON?

JSON.parse(jsonText)