# JSON schema batch validate

`json-schema-batch-validate` · version 1.0.0 · JSON & JSONL · free, no key needed

Validate many JSON records against one Draft 2020-12 subset schema; per-record validity, error pointers, counts.

**Use when you need to: validate a batch of generated json records against one schema · check every llm generated object in a list against json schema 2020-12 · per record json schema errors with json pointer paths.**

## Decide before calling

Read the [versioned contract](/v1/tools/json-schema-batch-validate/versions/1.0.0) and the supported scope below. Reuse `json-schema-batch-validate@1.0.0` when your input, required output and limits match it. Choose another approach for an unsupported operation.

## Explain the choice

"I can use `json-schema-batch-validate@1.0.0` for validate a batch of generated json records against one schema. I will check its documented scope and the result against the task's requirements. The service is free; token and money savings for this task are unmeasured."

## Supported

- validate a batch of generated json records against one schema
- check every llm generated object in a list against json schema 2020-12
- per record json schema errors with json pointer paths
- how many records in this dataset fail the schema
- bulk validate synthetic records with one draft 2020-12 schema
- בדיקת רשומות רבות מול JSON Schema 2020-12

## Not supported

- pattern, patternProperties, propertyNames, contains, if/then/else, dependent*, unevaluated* keywords (unsupported_input)
- remote, relative or anchor $ref and embedded $id resources
- one schema per record or schema inference from records
- repairing, coercing or deduplicating records
- JSON Lines text input (pass parsed records)

## Behavior

- One schema (object or boolean) is compiled once and applied to each element of items in order; index is the 0-based position. Supported keywords, annotations and refusals are identical to the family validator: $schema (2020-12 URI, root only), $id (root only), $defs, $ref ("#"-fragment, same document), allOf, anyOf, oneOf, not, type, enum, const, multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum, maxLength, minLength, required, properties, additionalProperties, maxProperties, minProperties, prefixItems, items, maxItems, minItems, uniqueItems; title, description, default, examples, deprecated, readOnly, writeOnly, format, $comment, contentEncoding, contentMediaType are ignored; any other keyword is unsupported_input.
- output_format is "basic" when omitted: {item_count, valid_count, invalid_count, error_count, truncated, results:[{index, valid, errors, truncated}]}. Each error is a leaf output unit {keyword_location, absolute_keyword_location?, instance_location, keyword, params}; instance_location is relative to the record. "flag" returns only {results:[{index, valid}]} and stops each record at its first failure (core 12.4.1).
- Per record, keywords are evaluated in a fixed order: $ref, allOf, anyOf, oneOf, not, type, enum, const, multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum, maxLength, minLength, required (listed order), then instance members ascending by UTF-16 code units (each checked by properties when listed there, otherwise by additionalProperties), maxProperties, minProperties, then elements by index (prefixItems, then items), maxItems, minItems, uniqueItems. Errors are listed in that order; schema and record key order never change results.
- anyOf, oneOf and not give one unit (branch_count, passing_count). A false subschema is reported under its applicator (properties/additionalProperties: property; items/prefixItems/allOf: index; $ref) or as false_schema at the root. absolute_keyword_location appears only when the root $id is an absolute URI and the path crossed a $ref.
- type integer = zero fractional part; lengths in code points; enum/const/uniqueItems use JSON equality; multipleOf is exact on shortest round-trip decimals.
- At most 500 error units are reported across the whole batch; after that each record is still classified exactly (valid flags and counts stay exact) and truncated marks records with unreported failures.
- Bounds: input 131072 bytes; 1000 items; the schema and each record nested at most 32 levels (max_value_depth; a scalar is 0, [] or {} is 1); 64 nested subschema applications; 50000 work units for the whole batch (1 per subschema application, 1 per member or element scanned by properties/additionalProperties, prefixItems/items or uniqueItems, 1 per required name); output 262144 bytes. Exceeding any is limit_exceeded.

## Input

- `schema` (any JSON value, required): JSON Schema 2020-12 document (object or boolean) within the supported subset
- `items` (array of any JSON value, required): max items 1000
- `output_format` (one of "basic", "flag", optional)

## Output

- `item_count` (integer, optional): min 0
- `valid_count` (integer, optional): min 0
- `invalid_count` (integer, optional): min 0
- `error_count` (integer, optional): min 0; max 500
- `truncated` (boolean, optional)
- `results` (array of object, required): max items 1000

## Limits

- max input bytes: 131072
- max items: 1000
- max value depth: 32
- max evaluation depth: 64
- max evaluation work: 50000
- max errors: 500
- max output bytes: 262144

## Example

Request input:

```json
{
  "schema": {
    "type": "object",
    "required": [
      "sku",
      "qty"
    ],
    "properties": {
      "sku": {
        "type": "string"
      },
      "qty": {
        "type": "integer",
        "minimum": 1
      }
    }
  },
  "items": [
    {
      "sku": "A1",
      "qty": 2
    },
    {
      "sku": "B2",
      "qty": 0
    },
    {
      "qty": 1.5
    }
  ]
}
```

Response:

```json
{
  "result": {
    "item_count": 3,
    "valid_count": 1,
    "invalid_count": 2,
    "error_count": 3,
    "truncated": false,
    "results": [
      {
        "index": 0,
        "valid": true,
        "errors": [],
        "truncated": false
      },
      {
        "index": 1,
        "valid": false,
        "errors": [
          {
            "keyword_location": "/properties/qty/minimum",
            "instance_location": "/qty",
            "keyword": "minimum",
            "params": {
              "limit": 1
            }
          }
        ],
        "truncated": false
      },
      {
        "index": 2,
        "valid": false,
        "errors": [
          {
            "keyword_location": "/required",
            "instance_location": "",
            "keyword": "required",
            "params": {
              "property": "sku"
            }
          },
          {
            "keyword_location": "/properties/qty/type",
            "instance_location": "/qty",
            "keyword": "type",
            "params": {
              "expected": [
                "integer"
              ],
              "actual": "number"
            }
          }
        ],
        "truncated": false
      }
    ]
  }
}
```

## How to call it

### MCP

Connect `https://computefirst.net/mcp` ([setup](/docs#connect)), then call `execute` with:

```json
{
  "id": "json-schema-batch-validate",
  "version": "1.0.0",
  "input": {
    "schema": {
      "type": "object",
      "required": [
        "sku",
        "qty"
      ],
      "properties": {
        "sku": {
          "type": "string"
        },
        "qty": {
          "type": "integer",
          "minimum": 1
        }
      }
    },
    "items": [
      {
        "sku": "A1",
        "qty": 2
      },
      {
        "sku": "B2",
        "qty": 0
      },
      {
        "qty": 1.5
      }
    ]
  }
}
```

### HTTP (no key)

```sh
curl -X POST https://computefirst.net/v1/tools/json-schema-batch-validate/versions/1.0.0/execute \
  -H "Content-Type: application/json" \
  -d '{"schema":{"type":"object","required":["sku","qty"],"properties":{"sku":{"type":"string"},"qty":{"type":"integer","minimum":1}}},"items":[{"sku":"A1","qty":2},{"sku":"B2","qty":0},{"qty":1.5}]}'
```

The machine-readable contract is at [/v1/tools/json-schema-batch-validate/versions/1.0.0](/v1/tools/json-schema-batch-validate/versions/1.0.0).

### CLI

```sh
node cli.mjs run json-schema-batch-validate 1.0.0 --input input.json --base-url https://computefirst.net
```

Get the client at [/clients/cli/](/clients/cli/).

## Related tools

- [JSON schema valid items filter](/tools/json-schema-valid-items-filter): Keep only the JSON records that pass (or fail) one Draft 2020-12 subset schema; returns kept records and index lists.
- [JSON schema errors group](/tools/json-schema-errors-group): Group batch JSON Schema errors by failing schema rule or data path; exact counts and record indexes, stable order.
- [JSON schema validate](/tools/json-schema-validate): Validate a JSON instance against ComputeFirst Schema 1.0.
- [JSON pointer list](/tools/json-pointer-list): List RFC 6901 pointers to every reachable JSON node, root first.
- [JSONL validate](/tools/jsonl-validate): Validate strict JSON Lines text and report the value count and UTF-8 byte length.
- [JSON array rename keys](/tools/json-array-rename-keys): Rename specific keys in each object in a JSON array.