How to Validate JSON Against a Schema

Valid JSON can still be wrong JSON.

A payload may parse correctly but still be missing required fields, using the wrong data types, or sending values your workflow does not expect.

This guide shows how to validate JSON against a schema so you can catch bad payloads before they move into storage, automation, analytics, or another API.

In Forge Json, a schema acts as a lightweight contract — a set of rules your JSON must follow.

This is a common pattern when you need to validate API responses, check webhook payloads, or make sure AI-generated JSON follows the structure your app expects.

This guide is for developers, data analysts, and operators working with API payloads, webhooks, integrations, or AI-generated JSON.

Before and After

Before: the JSON is syntactically valid, but it has missing and inconsistent fields.

{
  "order_id": "ORD_1001",
  "customer_email": null,
  "total_amount": "42.50",
  "currency": "USD",
  "items": 2
}

After: the validation step reports the problems before this payload breaks the next workflow.

{
  "valid": false,
  "errors": [
    {
      "field": "customer_email",
      "message": "Expected string, received null"
    },
    {
      "field": "total_amount",
      "message": "Expected number, received string"
    },
    {
      "field": "items",
      "message": "Expected array, received number"
    }
  ]
}

If you also need to clean messy API responses or normalize e-commerce orders with AI Draft, validation is a useful guardrail before or after the transformation step.

Why JSON Validation Matters

JSON syntax only tells you whether the data is formatted correctly. It does not tell you whether the data is useful, complete, or safe to pass into the next system.

That becomes painful when you need:

• required fields like order_id, customer_email, or created_at
• numbers to stay numbers instead of strings
• arrays to contain the expected item shape
• predictable payloads before storing, comparing, or exporting data

Without a repeatable validation workflow, these checks often end up scattered across one-off scripts, API handlers, or spreadsheet cleanup steps.

The raw JSON example below shows a common order payload that looks usable at first but fails the schema rules your downstream system expects.

How to Validate It with Forge Json

The validation step produces a contract-style report you can use before any pipeline step.

You can copy this setup directly:

{
  "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"
            }
          }
        }
      }
    }
  }
}

For this example, the workflow produces a short set of useful checks:

1. Confirm the payload is an object with the required top-level fields.
2. Check that each field has the expected type.
3. Report invalid fields before the payload moves into the next pipeline step.

Result

You end up with:

• a clear valid result
• field-level errors that explain what failed
• a reusable validation step you can run before cleanup, transformation, or export

If the validation rules are too strict, start smaller. First require the fields your workflow truly needs, then add enum checks, nested array checks, and stricter field rules once the core schema is stable.

The support material below shows the sample input, schema config, and validation result.

This pattern works well for API payloads, webhook events, AI-generated JSON, and any workflow where the next step expects a predictable structure.

Related JSON workflows:

• clean JSON
• AI Draft for e-commerce orders
• JSON pipelines

Use the example panel below to open this sample input and validation workflow directly in the editor.

FAQ

What does it mean to validate JSON against a schema?

It means checking valid JSON against rules for required fields, expected types, allowed values, and nested structures.

Is JSON Schema validation the same as checking valid JSON?

No. Valid JSON only checks syntax. Schema validation checks whether the data follows the structure your workflow expects.

When should I validate JSON in a pipeline?

Validate JSON before a cleanup, transform, storage, or API step when the next system depends on a predictable payload shape.