Forge Json

JSON Schema Validator (Free & Fast)

Validate JSON against a schema instantly. Detect missing fields, wrong types, and structural mismatches — paste your data, get a field-level error report.

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:

  • REST and GraphQL API responses
  • Webhook event payloads
  • Pre-pipeline payload sanity checks

Example: input → output

What is a JSON Schema Validator?

A JSON Schema Validator checks that your JSON data matches a defined structure: required fields, expected types, allowed values. The tool walks the document, compares each field against the schema, and returns a per-field report listing every mismatch with its path and reason.

This matters when working with API responses, webhook payloads, configuration files, and LLM-generated JSON — anywhere data must conform to a contract before downstream code consumes it. Without a validation step, contract drift surfaces as cryptic stack traces deep inside the consumer instead of clear errors at the boundary.

How to Validate JSON Online

  1. Paste your JSON data into the input panel.
  2. Provide a small schema describing required keys, types, and allowed enum values.
  3. Run the validator.
  4. Review the per-field report — each entry shows the path, the expected constraint, and the actual value.

The result is a structured list of violations you can fix one by one, instead of scanning the whole document by hand.

Common JSON Validation Errors

  • Missing required fields
  • Wrong types (a string where a number was expected, or vice versa)
  • null values where a non-nullable field was declared
  • Arrays where an object was expected, or the inverse
  • Out-of-range enum values

Catching these at the boundary keeps the rest of the pipeline simple, because everything downstream can assume the contract holds.

JSON Validator vs JSON Schema Validator

ToolWhat it checks
JSON ValidatorSyntax only — is the input valid JSON?
JSON Schema ValidatorStructure, types, and required fields against a schema

Use a syntax validator when you only need to know whether a file parses. Use a schema validator when the data must match a contract — almost always the case for API payloads, webhooks, and pipeline inputs.

If all you need is to validate plain JSON syntax (the "is this a valid JSON document?" question), the gateway syntax-checker page is a faster stop than this one. For alternate syntax-first workflows, use validate JSON in your browser, check JSON formatting issues, repair invalid JSON syntax, or lint JSON before handoff before returning to schema checks.

When to Use JSON Validation

Validate JSON before sending it into a downstream pipeline step to prevent late-stage failures. Common workflows:

  • Debugging an unexpected API response.
  • Verifying a webhook body before storing or processing it.
  • Sanity-checking LLM-generated JSON; pair with normalize-json to handle variable record shapes first.
  • Gating generated payloads before clean-json or extract-fields-from-json takes them downstream.

Validating webhook events or vendor REST responses specifically? See the API/Webhook Payload Validator, which focuses on contract drift, retry semantics, and provider-specific payload shape.

For full JSON Schema (Draft 7 / 2020-12) features — $ref, conditional schemas, format validators, AJV-compatible options — use a dedicated library such as Ajv. This tool is intentionally smaller and faster: a structural sanity check, not a complete spec implementation.

Frequently asked questions

How does this JSON schema validator work?+

Paste your JSON on one side and a small schema config on the other. The tool walks the JSON, compares each field against the schema's expected type and presence, and returns a per-field report with the path and the reason for every mismatch.

Is this a full JSON Schema (Draft 7 / 2020-12) validator?+

No. This tool runs a lightweight structural check — required keys, types per field, allowed enum values. For full JSON Schema features like $ref, conditional schemas, or format validators, use a dedicated library such as Ajv. This tool is intentionally smaller and faster for sanity-check use cases.

Is the validation done locally?+

Yes. The validator runs entirely in your browser. Your JSON and your schema config are never uploaded to a server, and there is no signup or rate limit.

What does the field-level report look like?+

Each entry has the JSON path of the offending field, the expected constraint from the schema, and the actual value or violation. Missing required keys, wrong types, and out-of-range enum values are flagged separately so you can scan the report top to bottom.

When should I use this versus running validation in code?+

Use this tool when you want to sanity-check a payload by hand — debugging an API response, verifying a webhook body, or testing a generated payload before piping it downstream. For automated pre-pipeline guardrails, embed a validator in your code path; this tool is the manual equivalent of that gate.

Common next steps

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}