Forge Json

JSON Validator Online (Syntax + Schema) - Free JSON Checker

Paste JSON below to validate syntax instantly. Check formatting issues first, then add a JSON Schema when you need the same validator in an API or backend workflow.

Paste your JSON → Get results instantly (no signup)

⚡ Instant resultsNo signupRuns in your browser
Try examples:

→ Validate this order payload against a small schema config.

{
"order_id": "ORD_1001",
"customer_email": null,
"total_amount": "42.50",
"currency": "USD",
"items": 2
}
Output✓
1{
2  "valid": false,
3  "errors": [
4    {
5      "field": "customer_email",
6      "message": "Expected string, received null"
7    },
8    {
9      "field": "total_amount",
10      "message": "Expected number, received string"
11    },
12    {
13      "field": "items",
14      "message": "Expected array, received number"
15    }
16  ]
17}

Love the result?

Use this exact pipeline in your app, backend, or LLM workflow.

No setup needed. Works with curl, Node, Python.

Uses example data. For edited input, copy from the playground.

Read integration guide

Works with:

  • Hand-edited JSON files
  • Config files (package.json, tsconfig.json)
  • API request and response bodies
  • Optional schema for structural checks

Example: input → output

What is a JSON validator?

A JSON validator checks whether a document is valid JSON before it moves into an API request, config file, pipeline step, or backend job. The first job is syntax: can the text be parsed by a standard JSON parser? If the answer is no, the validator should point at the line and column where the parser stopped so you can fix the exact character that broke the document.

This page is built for that fast "is this JSON valid?" moment. Paste JSON below to validate syntax instantly. The free JSON checker catches parse errors, formatting issues, trailing commas, unquoted keys, single-quoted strings, comments, and other non-standard JSON patterns. When syntax is clean, you can keep going with optional schema validation and use the same validator in your API or backend workflow.

How to validate JSON online

  1. Paste your JSON text into the input panel.
  2. Run the validator. If the input parses, you get a valid JSON result and a formatted version of the document.
  3. If validation fails, read the line and column from the error report.
  4. Fix the invalid character, then run the JSON validator again.
  5. Add a schema only when you need structural checks such as required fields, expected types, or allowed enum values.

Most quick checks stop at step four. That is intentional: invalid syntax must be fixed before schema validation, cleanup, conversion, or diffing can produce trustworthy output.

JSON syntax vs JSON schema

JSON syntax validation answers "does this parse?" A trailing comma, a raw comment, a single-quoted string, or an unquoted key fails before the document has any meaningful structure.

JSON schema validation answers "does this match my contract?" That comes after syntax. Use the JSON Schema Validator when a payload must contain required fields, match expected types, or satisfy API rules before downstream code consumes it.

For provider-specific contracts such as webhook payloads, REST responses, and sandbox-vs-production drift, the API/Webhook Payload Validator is a better fit because it is framed around integration payloads rather than one-off syntax checks.

Common JSON errors

  • Trailing commas - JSON forbids a comma after the last array or object item.
  • Single quotes - strings and keys must use double quotes.
  • Unquoted keys - {name: "Ada"} is JavaScript object syntax, not JSON.
  • Comments - // and / ... / are not part of standard JSON.
  • Bare control characters - raw newlines and tabs inside strings must be escaped.
  • Invalid numbers - leading zeros, NaN, Infinity, and trailing decimals are not legal JSON numbers.
  • Mismatched brackets - copied snippets often lose a closing } or ].

These errors are small, but they break parsers completely. A JSON validator should make them obvious before you spend time debugging the code that tried to read the file.

JSON validator example

Invalid input:

{
  "name": "Ada",
  "roles": ["admin", "editor",]
}

The trailing comma after "editor" makes this invalid JSON. Remove the comma and the same document parses cleanly:

{
  "name": "Ada",
  "roles": ["admin", "editor"]
}

Once the JSON is valid, common next steps are to Clean JSON (remove nulls, trim strings, sort keys), Extract Fields from JSON, Convert JSON to CSV, or use the JSON Diff tool to compare two versions.

When to use this free JSON checker

Use this JSON validator online when you are checking hand-edited configuration files, payloads pasted into curl, API request bodies, webhook samples, LLM-generated JSON, or snippets copied out of logs. It is especially useful before sharing JSON with another person because it catches the boring parser problems first.

For repeated jobs, the same validation step can sit inside a pipeline or API flow. Validate the JSON at the boundary, then pass only clean, parseable data into cleanup, extraction, conversion, or schema checks.

Example pipeline on GitHub

The ForgeJSON Pipeline Spec repo includes a portable JSON validation pipeline you can inspect, copy, or version with your own tooling:

The example is a plain JSON pipeline document that validates an order payload against an expected schema after the JSON has parsed cleanly.

Frequently asked questions

What does this JSON validator check?+

It checks JSON syntax first: whether the input parses according to the standard JSON spec. After syntax is valid, you can add an optional JSON Schema when you need required-field, type, or structure checks.

Does it accept JSON5 or JavaScript object literals?+

No. This JSON checker validates standard JSON only: no trailing commas, no unquoted keys, no single quotes, and no comments. The error message points to the non-standard syntax that tripped the parser.

Can I paste a payload that contains a comment?+

Comments are not part of the JSON spec. Strip them before pasting, or run the input through a JSONC-aware tool first. The parser will fail on the first `//` or `/* */` it sees.

What happens with very large files?+

Anything that fits in browser memory parses without uploading. Multi-megabyte files work; the parse runs in a Web Worker so it doesn't block the UI.

How do I validate JSON programmatically?+

Most languages ship a JSON parser in the standard library — `JSON.parse` in JavaScript, `json.loads` in Python, `encoding/json` in Go. For API or backend workflows, validate at the boundary first, then run schema checks or cleanup steps only after the payload parses.

Related tools

Read more on the blog

Advanced usage (optional)

Schema Validation

v1.0.0
Validation
objectarraystringreversible

Description

Schema Validation

Validate JSON against a JSON Schema-style subset and return a field-level report.

This utility is a report-producing transformer. It does not block, skip, warn, or otherwise control pipeline execution. Use validation.contract when a pipeline needs guardrail behavior.

Supported V1 Schema Fields

  • type: object, array, string, number, boolean, or null
  • required: array of required object keys
  • properties: object field rules
  • items: array item rule
  • enum: primitive values only, using strings, numbers, booleans, or null

Unknown fields are ignored in V1.

Invalid schema config returns:

{
  "valid": false,
  "errors": [
    { "field": "$schema", "message": "Missing or invalid schema config" }
  ]
}

Configuration

NameTypeDefaultDescription
Schema Configjson{"type":"object","required":[],"properties":{}}JSON Schema-style subset. Supports type, required, properties, items, and primitive enum values. Unknown fields are ignored in V1.

Examples

AI Prompt
Validate this order payload against a small schema config.
{
"order_id": "ORD_1001",
"customer_email": null,
"total_amount": "42.50",
"currency": "USD",
"items": 2
}
Output✓
1{
2  "valid": false,
3  "errors": [
4    {
5      "field": "customer_email",
6      "message": "Expected string, received null"
7    },
8    {
9      "field": "total_amount",
10      "message": "Expected number, received string"
11    },
12    {
13      "field": "items",
14      "message": "Expected array, received number"
15    }
16  ]
17}
Config
Schema Config
1{
2  "type": "object",
3  "required": [
4    "order_id",
5    "customer_email",
6    "total_amount",
7    "currency",
8    "items"
9  ],
10  "properties": {
11    "order_id": {
12      "type": "string"
13    },
14    "customer_email": {
15      "type": "string"
16    },
17    "total_amount": {
18      "type": "number"
19    },
20    "currency": {
21      "type": "string",
22      "enum": [
23        "USD",
24        "EUR",
25        "GBP"
26      ]
27    },
28    "items": {
29      "type": "array",
30      "items": {
31        "type": "object",
32        "required": [
33          "sku",
34          "qty"
35        ],
36        "properties": {
37          "sku": {
38            "type": "string"
39          },
40          "qty": {
41            "type": "number"
42          }
43        }
44      }
45    }
46  }
47}

API Usage

POST /api/v1/utilities/validation.schema
Example:
curl -X POST https://your-domain.com/api/v1/utilities/validation.schema \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"inputs":{"primary":{"order_id":"ORD_1001","customer_email":null,"total_amount":"42.50","currency":"USD","items":2}},"config":{"schema":{"type":"object","required":["order_id","customer_email","total_amount","currency","items"],"properties":{"order_id":{"type":"string"},"customer_email":{"type":"string"},"total_amount":{"type":"number"},"currency":{"type":"string","enum":["USD","EUR","GBP"]},"items":{"type":"array","items":{"type":"object","required":["sku","qty"],"properties":{"sku":{"type":"string"},"qty":{"type":"number"}}}}}}}}'
Response
1{
2  "valid": false,
3  "errors": [
4    {
5      "field": "customer_email",
6      "message": "Expected string, received null"
7    },
8    {
9      "field": "total_amount",
10      "message": "Expected number, received string"
11    },
12    {
13      "field": "items",
14      "message": "Expected array, received number"
15    }
16  ]
17}