# JSON Schema Batch Validator (`junipr/json-schema-batch-validator`) Actor

Validate JSON/JSONL batches against JSON Schema and return row-level validation errors and summaries.

- **URL**: https://apify.com/junipr/json-schema-batch-validator.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** SEO tools, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.90 / 1,000 schema validateds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## JSON Schema Batch Validator

### Store Positioning

**Store title:** JSON Schema Batch Validator

**Short description:** Validate JSON/JSONL batches against JSON Schema and return row-level validation errors and summaries.

**SEO title:** JSON Schema Batch Validator — data QA, validation, and cleanup utility

**SEO description:** Validate JSON/JSONL batches against JSON Schema and return row-level validation errors and summaries. Use it to validate rows, schemas, duplicates, field quality, and delivery-readiness before handing data to clients or automations.

**Categories:** SEO\_TOOLS, DEVELOPER\_TOOLS, ECOMMERCE

**Keywords:** json, schema, batch, validator, data/schema qa utility

### Pricing

This actor uses pay-per-event pricing. Event prices include Apify platform usage; users are not expected to pay a separate platform-usage pass-through charge for the configured pricing model.

- Tier: U2 — Data/schema QA utility
- Primary event: `schema-validated` at $0.00390 base
- Default max charge: $5.00
- Store discounts: FREE/BRONZE base, SILVER discounted, GOLD deepest approved discount

Event set:

- `actor-start`: base $0.00500, GOLD $0.00400. JSON Schema Batch Validator: charged when actor start is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `schema-validated`: base $0.00390, GOLD $0.00312. JSON Schema Batch Validator: charged when schema validated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `issue-detected`: base $0.00372, GOLD $0.00298. JSON Schema Batch Validator: charged when issue detected is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `qa-report-generated`: base $0.05000, GOLD $0.04000. JSON Schema Batch Validator: charged when qa report generated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.

### Public Task Concepts

- Validate JSON Schema Batch records from bounded input
- Find invalid JSON Schema Batch values before delivery
- Check JSON Schema Batch coverage against expected rules
- Review JSON Schema Batch failures with error paths
- Export JSON Schema Batch pass-fail rows with evidence

### What It Does

Validate JSON/JSONL batches against JSON Schema and return row-level validation errors and summaries.

Use it to identify missing required fields and type mismatches in a bounded set of JSON records before ingestion or API delivery.

### What It Does Not Do

- It does not repair invalid records or mutate the supplied schema.
- It does not call external endpoints or upload records to third-party services.
- It currently checks required properties and declared primitive property types.
- It does not replace a full application-level semantic validation suite.

### Input Fields

Provide `schemaJson` and `recordsJson`, then set bounded item and charge limits.

### Output Fields

- `rowIndex`
- `isValid`
- `errorCount`
- `errorPath`
- `errorKeyword`
- `errorMessage`
- `schemaPath`
- `warnings`

### Public Task Examples

#### Validate JSON records against a JSON Schema

- Input: A JSON Schema and a bounded array of records.
- Output: Row-level validity, error counts, paths, keywords, messages, and an optional report.
- Use case: Catch contract violations before sending a batch downstream.

#### Find missing required fields in a batch import

- Input: Records where selected required fields are intentionally absent.
- Output: Failed rows with required-field error paths and messages.
- Use case: Stop incomplete imports before they reach production tables.

#### Report type mismatches in JSON payload samples

- Input: Payload samples containing strings, numbers, and booleans in incorrect fields.
- Output: Type mismatch paths, expected type keywords, and row-level validity.
- Use case: Identify coercion problems before integrating a feed.

#### Create validation rows for API example records

- Input: API documentation examples and the corresponding object schema.
- Output: One normalized validation row per example record.
- Use case: Verify that published examples satisfy the stated contract.

#### Audit customer JSON before ingestion

- Input: A capped customer JSON export and its expected schema.
- Output: Valid and invalid row evidence with an optional summary.
- Use case: Triage customer import defects before ingestion.

### Tests

- Actor-specific tests live in `test/json-schema-batch-validator.test.ts`.
- The suite validates output artifacts, invalid/no-result cases, report billing, and max-charge stops.

### FAQ

#### Does the actor modify invalid records?

No. It reports validation evidence and leaves the supplied records unchanged.

#### Are all JSON Schema keywords supported?

The current bounded validator covers required properties and declared primitive property types. Use a full schema engine when advanced keywords are required.

# Actor input Schema

## `schemaJson` (type: `object`):

Object schema used to validate each supplied record.

## `recordsJson` (type: `array`):

JSON records to check against the schema.

## `maxRecords` (type: `integer`):

Hard cap for emitted validation rows.

## `includeValidRows` (type: `boolean`):

Include passing records as well as failed records.

## `failFast` (type: `boolean`):

Return only the first invalid record.

## `includeReport` (type: `boolean`):

Create charged Markdown and JSON report artifacts.

## `maxChargeUsd` (type: `number`):

Stop before an event would exceed this run budget.

## Actor input object example

```json
{
  "schemaJson": {
    "type": "object",
    "properties": {
      "productId": {
        "type": "integer",
        "title": "Product Id",
        "description": "Product Id input value."
      },
      "productName": {
        "type": "string",
        "title": "Product Name",
        "description": "Product Name input value."
      },
      "price": {
        "type": "number",
        "title": "Price",
        "description": "Price input value."
      },
      "tags": {
        "type": "array",
        "title": "Tags",
        "description": "Tags input value."
      }
    },
    "required": [
      "productId",
      "productName",
      "price"
    ]
  },
  "recordsJson": [
    {
      "productId": 1,
      "productName": "A green door",
      "price": 12.5,
      "tags": [
        "home",
        "green"
      ]
    }
  ],
  "maxRecords": 1,
  "includeValidRows": true,
  "failFast": false,
  "includeReport": true,
  "maxChargeUsd": 1
}
```

# Actor output Schema

## `dataset` (type: `string`):

Structured rows emitted by the actor.

## `report` (type: `string`):

Run summary report stored in the default key-value store.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/json-schema-batch-validator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("junipr/json-schema-batch-validator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call junipr/json-schema-batch-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=junipr/json-schema-batch-validator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/24d4LPgsvMgkJTRVg/builds/yyVfs2a3YjcOTYlRM/openapi.json