What do I send in the request body?

Any single JSON value: usually an array of objects to compare across items, or an object (nested arrays are analyzed recursively). There is no payloads wrapper—the body is the value itself.

What is the maximum request size?

About 10MB for the JSON body per Express limits. If the serialized payload exceeds 10MB after parsing, the API returns HTTP 413 with PAYLOAD_TOO_LARGE.

Does the API store my JSON?

No. Processing is stateless and in-memory.

Is this the same as JSON Schema validation?

No. This API finds inconsistencies across concrete samples (e.g. mixed types in the same field). Use JSON Schema Validator when you have a schema contract.

How are invalid JSON and oversized payloads handled?

Malformed JSON often returns HTTP 400 with validJson false and invalidJson true. Oversized parsed payloads return HTTP 413 with error PAYLOAD_TOO_LARGE.

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. Results are deterministic; gate on warning codes or summary.warningCount thresholds.

Catch Silent JSON Drift Before It Breaks Clients

Send one JSON value in the body—usually an array of objects from an API or pipeline—and get warnings[] with codes like MISSING_FIELD, TYPE_INCONSISTENCY, NUMERIC_STRING, plus summary.warningCount and summary.totalItems. For a root object, nested arrays are scanned recursively. Not JSON Schema and not AI: deterministic rules. POST /analyze, ~10MB body, stateless.

Try on RapidAPI Basic: 100 requests/month free

Validators only say “valid JSON.” This flags inconsistent shapes across rows—mixed types, missing keys in some items, sketchy dates—so CI can fail on summary.warningCount or specific codes.

Real-world use cases

API response QA — Sample N responses; ensure every object exposes the same fields and types.
ETL / ingestion — Check batches from a partner before loading.
CI golden tests — Compare captured payloads against expectations using warning codes.
Version drift — After a backend deploy, spot new optional fields turning into inconsistent types.

Who this API helps

Backend and API engineers
Data and platform teams
QA automating contract-ish checks without maintaining a full schema

Illustrative output

Summary

summary: {
  totalItems: 3,
  warningCount: 3
}

Warning (example)

{ code: "TYPE_INCONSISTENCY",
  field: "age",
  metadata: { typeCounts: {...} } }

What the API does

POST /analyze — Body is the JSON to analyze (Content-Type application/json). You may also send a JSON string as text/plain (server parses it).

GET /health — Liveness.

There is no { "payloads": [...] } wrapper—the HTTP body is the payload. The old catalog snippet that used /check was incorrect; the live service uses /analyze.

Deterministic analysis

Same JSON input always yields the same warnings and counts. No training data, no probabilistic guesses.

Request, response & errors

Endpoint: POST https://json-payload-consistency-checker.p.rapidapi.com/analyze with x-rapidapi-key and x-rapidapi-host: json-payload-consistency-checker.p.rapidapi.com (verify in your RapidAPI app).

Request body · Success response · Warning codes · HTTP errors

The entire body must be one JSON value:

Shape	Typical use
`[{...}, {...}]`	Compare objects across array elements (missing fields, types, etc.).
`{ ... }`	Object-level checks plus recursive analysis of nested arrays inside the object.

Field	Description
`validJson`	`true` when analysis ran.
`rootType`	`array` or `object`.
`summary`	`totalItems`, `warningCount`.
`warnings[]`	`code`, `field` path, `metadata`.

Situation	HTTP	Body (typical)
Malformed JSON (syntax)	400	`validJson: false`, `invalidJson: true`
Empty / missing body	400	Same as invalid JSON
Serialized payload > 10MB after parse	413	`error: "PAYLOAD_TOO_LARGE"`, optional `warnings` entry

Raw HTTP body larger than Express’s JSON limit may be rejected by the framework before your JSON reaches the handler.

Try it in the playground

Pick a sample or paste your own JSON (array or object). Add your RapidAPI key.

RapidAPI Key (required)

Sample request

Body must be valid JSON (array or object).

Request body (JSON)

Subscribe on RapidAPI for production quotas.

Get code

Snippets reflect the playground. Path: /analyze.

Integration time: One POST per batch or sample file in CI.

Real-world examples

1. Fail CI on any drift

POST your nightly sample array; fail the job if warnings.length > 0 or if MISSING_FIELD appears on critical paths.

2. Allow-list benign codes

Ignore NUMERIC_STRING on specific paths (e.g. legacy SKU fields) but fail on TYPE_INCONSISTENCY or MISSING_FIELD for core columns.

3. Pair with schema validation

Use JSON Schema Validator for contract enforcement; use this API to catch what the schema did not anticipate across real samples.

Pricing & tiers (RapidAPI)

Built for teams running repeated quality checks on API and pipeline JSON.

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

200 with validJson: true, warnings, and summary when analysis succeeds. 400 with invalidJson: true for many client errors. 413 when the parsed payload exceeds the size guard.

About this API

Also known as

JSON sanity checker, payload consistency API, JSON structure analyzer, data quality JSON API.

Source implementation lives in the json-sanity-checker-api repository; the RapidAPI product name is JSON Payload Consistency Checker. See the README for the full warning catalog and design limits (no schema inference, no auto-fix).

Frequently asked questions

One JSON value: typically an array of objects, or an object (nested arrays are scanned). No payloads wrapper.
About 10MB for the JSON body; larger serialized payloads after parse return 413 with PAYLOAD_TOO_LARGE.
No. Stateless in-memory processing.
No. This compares concrete samples for drift; schema validation enforces a declared contract.
POST /analyze on json-payload-consistency-checker.p.rapidapi.com—confirm host in RapidAPI.
400 with validJson false and invalidJson true for bad syntax; 413 with PAYLOAD_TOO_LARGE when the parsed payload is too big.
On RapidAPI: Basic 100/mo; Pro $9.99/10k; Ultra $49.99/100k; Mega $99.99/250k.
Yes—threshold on warningCount or specific codes; output is deterministic.

Browse all APIs in the catalog →