What goes in the POST body?

payload (required) plus exactly one of schema (inline object) or schemaUrl (HTTPS string). You cannot send both schema and schemaUrl.

Does HTTP 200 mean the payload is valid?

Not necessarily. Validation failures often return HTTP 200 with valid false and a populated errors array. Check the valid boolean. Client errors (bad request shape, bad schema) may return HTTP 400 or 413.

Can I load the schema from a URL?

Yes. schemaUrl must be fetchable over HTTPS; localhost and private IPs are blocked. Max about 1MB and 5 second timeout—see README for details.

What is the maximum payload size?

About 10MB for the serialized payload after parse. Oversize returns HTTP 413 with PAYLOAD_TOO_LARGE.

Does it store my JSON?

No. Stateless in-memory processing.

Is this full JSON Schema?

No. It supports a strict subset: type, required, properties, items, nesting. No $ref, anyOf, enum, pattern, or format validation.

Where are pricing and quotas defined?

On RapidAPI: Basic is free with 100 requests per month; Pro is $9.99/month with 10,000; Ultra is $49.99/month with 100,000; Mega is $99.99/month with 250,000.

Can I use this in CI/CD?

Yes. Output is deterministic; fail the job when valid is false or when summary.errorCount is greater than zero.

Enforce JSON Contracts Without Surprises

POST /validate with payload and either inline schema or schemaUrl (HTTPS). Get valid, errors[] with stable code values, and summary.errorCount. No type coercion; extra properties are EXTRA_FIELD. Supports type, required, properties, items, and nesting up to 100 levels—not full JSON Schema (no $ref, enum, format, etc.). Stateless; serialized payload up to ~10MB.

Try on RapidAPI Basic: 100 requests/month free

Important: schema violations often return HTTP 200 with valid: false. For automation, always check valid (or summary.errorCount), not only status codes.

Real-world use cases

API gateways & BFFs — Reject or flag requests before hitting business logic.
CI contract tests — Assert sample responses against a checked-in schema.
Ingestion — Validate partner webhooks or files on the way in.
Centralized schema URL — Pull the latest schema from your CDN (within size/timeout limits).

Who this API helps

Backend and API engineers
DevOps / CI owners
Data teams validating batches against a declared shape

Illustrative output

Valid

{ "valid": true,
  "errors": [],
  "summary": { "errorCount": 0 } }

Invalid (fragment)

{ "valid": false,
  "errors": [
    { "code": "TYPE_MISMATCH",
      "field": "age", ... }
  ] }

What the API does

POST /validate — JSON body: payload (any JSON value to validate) plus either schema or schemaUrl, not both.

GET /health — Liveness.

For cross-sample drift (same field sometimes string, sometimes number across rows) without a fixed schema, use the JSON Payload Consistency Checker. For two versions of a document, use JSON Diff Checker.

Supported schema subset

Structural rules only: types, required keys, nested properties, arrays with items, nullability. Unsupported features include $ref, anyOf / oneOf / allOf, enum, pattern, minLength, format, and conditionals.

Request, response & codes

Endpoint: POST https://json-schema-validator-api.p.rapidapi.com/validate with x-rapidapi-key and x-rapidapi-host: json-schema-validator-api.p.rapidapi.com (verify in your RapidAPI app).

Request body · Response · HTTP behavior · Error codes (table)

Field	Required	Description
`payload`	Yes	JSON value to validate (object, array, or primitive as allowed by your schema).
`schema`	One of schema / schemaUrl	Inline schema object with a `type` field.
`schemaUrl`	One of schema / schemaUrl	HTTPS URL to fetch JSON schema (blocked: localhost, private IPs; limits apply).

Field	Description
`valid`	`true` if the payload satisfied the schema.
`errors[]`	Each: `code`, `field`, optional `expected` / `actual` / metadata.
`summary.errorCount`	Number of errors reported.
`invalidInput`	May appear on some 400 responses (e.g. `schema` / `payload`).

Case	HTTP	Notes
Payload fails schema checks	200	`valid: false`, errors populated
Payload passes	200	`valid: true`
Missing payload, bad schema input, fetch errors, etc.	400	`valid: false` with specific error codes
Serialized payload > 10MB	413	`PAYLOAD_TOO_LARGE`
Malformed top-level JSON	400	`valid: false`, often empty `errors`

Code	Meaning
`MISSING_REQUIRED_FIELD`	Required property missing
`TYPE_MISMATCH`	Value type does not match schema
`EXTRA_FIELD`	Property not declared in schema
`NULL_VALUE_NOT_ALLOWED`	`null` where not allowed
`ARRAY_ITEM_VALIDATION_FAILED`	Array element failed `items`
`ROOT_TYPE_MISMATCH`	Root JSON type vs schema root type
`PAYLOAD_TOO_LARGE`	Payload exceeds size limit
`INVALID_SCHEMA`	Inline schema struct invalid / missing `type`
`INVALID_SCHEMA_INPUT`	Neither or both of `schema` / `schemaUrl`
`INVALID_SCHEMA_URL`	`schemaUrl` not a string
`SCHEMA_FETCH_FAILED`	HTTP/network failure fetching schema
`SCHEMA_FETCH_TIMEOUT`	Fetch exceeded timeout (~5s)
`INVALID_SCHEMA_JSON`	Fetched body not JSON
`SCHEMA_URL_NOT_ALLOWED`	URL blocked (e.g. localhost)
`SCHEMA_TOO_LARGE`	Fetched schema > ~1MB
`UNSUPPORTED_SCHEMA_REFERENCE`	`$ref` or similar not supported

Try it in the playground

Choose a sample or edit JSON. Add your RapidAPI key.

RapidAPI Key (required)

Sample request

Body must be JSON with payload and schema (or schemaUrl).

Request body (JSON)

Subscribe on RapidAPI for production quotas.

Get code

Snippets follow the playground. Path: /validate.

Integration tip: Treat valid === false as failure even when HTTP status is 200.

Real-world examples

1. CI gate

POST a captured API response as payload with your committed schema; exit non-zero if valid is false.

2. Shared schema URL

Publish schema.json on HTTPS; clients send only schemaUrl and payload to avoid huge inline schemas.

3. Strict public API

Combine required + explicit properties so unknown fields surface as EXTRA_FIELD during partner onboarding.

Pricing & tiers (RapidAPI)

Built for teams running high-volume validation at the edge or in CI.

Plans on RapidAPI:

Basic

$0/mo

100 requests/month included

Pro

$9.99/mo

10,000 requests/month included

Popular

Ultra

$49.99/mo

100,000 requests/month included

Mega

$99.99/mo

250,000 requests/month included

Overage and plan changes follow the live RapidAPI listing.

What to expect

Most successful calls return 200. Read valid and errors. 400 for malformed requests or schema fetch/parse issues; 413 for oversized payload.

About this API

Also known as

JSON schema checker, contract validation API, structural JSON validator, request/response schema API.

See the README for the exhaustive unsupported-feature list and security rules for schemaUrl.

Frequently asked questions

payload plus exactly one of schema or schemaUrl.
No—check valid. Many validation failures use 200 with valid: false.
Yes, HTTPS only; private hosts blocked; ~1MB and ~5s limits.
About 10MB serialized; larger triggers 413.
No. Stateless.
No—a strict structural subset; no $ref, enum, format, etc.
RapidAPI: Basic 100/mo; Pro $9.99/10k; Ultra $49.99/100k; Mega $99.99/250k.
Yes—fail on !valid or errorCount > 0.

Browse all APIs in the catalog →