How to Validate JSON Against a Schema Online (Generate & Validate)

Why JSON Schema Matters

Without a schema, a JSON API might return a string where you expected a number. A config file might be missing a required field. A database import might have unexpected fields that break your pipeline. JSON Schema solves this by defining rules for your data:

• Required fields: Mark specific fields as mandatory.
• Data types: Enforce string, number, boolean, array, or object types.
• Value constraints: Set minimum/maximum for numbers, patterns for strings, enum values for restricted options.
• Nested structure: Define schema for nested objects and arrays with any depth.

The challenge is that schemas are verbose to write. That's why the tool includes a Generate Schema feature that creates a draft schema from your JSON automatically.

1. Auto-Generate a JSON Schema from Sample Data

Start with sample JSON data and let the tool infer the schema:

[
  {
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com",
    "role": "admin",
    "active": true,
    "profile": {
      "age": 32,
      "city": "Beijing"
    }
  }
]

Click Generate Schema in the toolbar. The tool produces a Draft 07 schema:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "id": { "type": "integer" },
      "name": { "type": "string" },
      "email": { "type": "string" },
      "role": { "type": "string" },
      "active": { "type": "boolean" },
      "profile": {
        "type": "object",
        "properties": {
          "age": { "type": "integer" },
          "city": { "type": "string" }
        },
        "required": ["age", "city"]
      }
    },
    "required": ["id", "name", "email", "role", "active", "profile"]
  }
}

The generated schema is a starting point — not perfect, but close. You can edit it to add constraints like minimum, pattern, enum, or remove optional fields from required.

2. Writing or Editing a Schema Manually

Once the schema is generated, you can refine it with additional constraints:

"role": {
  "type": "string",
  "enum": ["admin", "user", "editor", "viewer"]
},
"email": {
  "type": "string",
  "pattern": "^[\\w.-]+@[\\w.-]+\\.\\w+$"
},
"id": {
  "type": "integer",
  "minimum": 1
}

The schema editor provides syntax highlighting and real-time validation. As you type, any schema errors (like missing commas or invalid JSON) are highlighted. The schema and the JSON data validate simultaneously, so you can iterate quickly.

3. Validating JSON Against the Schema

With the schema in place, paste any JSON into the left panel to validate it instantly. The validator checks every field against the schema rules and reports:

• Missing required fields: "name" is required — the field is missing from the JSON.
• Wrong data types: Expected integer, got string — the value doesn't match the schema type.
• Constraint violations: Value 0 is less than minimum 1 — value is out of range.
• Enum violations: "superadmin" is not one of the allowed values — invalid option.
• Pattern mismatches: String does not match pattern — format validation failed.

Each error includes the exact JSON path, making it easy to locate and fix the problem. The error count badge shows how many issues exist at a glance.

4. Complete Validation Workflow

Here's the recommended workflow for schema validation:

1. Start with sample data. Paste a representative JSON sample into the validator.
2. Generate the schema. Click Generate Schema to create a Draft 07 schema.
3. Add constraints. Add enum, pattern, minimum/maximum, and format to tighten validation.
4. Test with variants. Paste different JSON inputs — valid and invalid — to verify the schema catches edge cases.
5. Iterate. Adjust the schema based on validation results until it covers all allowed structures.

This workflow ensures your schema is both correct and complete before deployment.

Best Practices for JSON Schema Validation

• Generate first, refine second. Auto-generate from a representative sample, then add constraints like enum, pattern, and minimum/maximum manually.
• Test with invalid data too. A good schema should both accept valid data and reject invalid data. Don't just test the happy path.
• Use enum for fixed values. If a field like status only allows "active", "inactive", and "pending", use an enum instead of a plain string type.
• Validate API responses. Use the schema to check API outputs against expected contracts — catch regressions before they reach production. Compare versions with JSON Diff after validation.
• Keep schemas in version control. Store your JSON Schema alongside your API specs in Git. Use the validator to verify every change.

Related Tools

Frequently Asked Questions