What is the maximum request size?

The Express JSON parser allows up to about 10MB for the entire request body (before and after together).

Does the API store my JSON?

No. Processing is stateless and in-memory.

Can I use this in CI/CD pipelines?

Yes. Output is deterministic: same inputs always yield the same diff and summary counts.

What counts as a breaking change?

Examples include removed fields, type changes, root object vs array changes, non-nullable to nullable, and certain array element structure changes.

How are errors returned?

Invalid or missing input often returns HTTP 400 with validJson false, empty change lists, and invalidSide when applicable—same general shape as a normal diff response.

Does it infer JSON Schema or OpenAPI?

No. It compares two concrete JSON values only.

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 (popular) with 100,000; Mega is $99.99/month with 250,000.

How is this different from a text diff?

It understands structure and types, classifies breaking vs non-breaking changes, and reports field paths—not just line differences in serialized text.

Know If Your API Change Breaks Clients—Before You Ship

POST /diff with before and after JSON values. The API returns breakingChanges and nonBreakingChanges with types (e.g. FIELD_REMOVED, TYPE_CHANGED, FIELD_ADDED), field paths, values, metadata where useful, plus summary.breakingCount / nonBreakingCount. Deterministic rules—no ML. Stateless; request body up to ~10MB (entire payload).

Try JSON Diff Checker Basic on RapidAPI: 100 requests/month free

Stop eyeballing giant JSON blobs. Fail CI when breakingChanges.length > 0, or gate releases on summary counts—without maintaining a custom diff engine per service.

Real-world use cases

API versioning — Compare v1 sample response to v2 candidate before bumping the version.
CI/CD gates — Diff golden files against new codegen or serializer output.
Contract regression — Catch accidental type drift (number → string) early.
Partner integrations — Document what changed between two exported payloads.
Post-normalization checks — After normalization APIs, verify shape stability.

Why not a plain text diff?

Key order and whitespace shouldn’t drive “changes”
Type and nullability matter for compatibility
You want breaking vs safe changes labeled consistently

Who this API helps

Backend and API platform engineers
DevOps and CI maintainers
QA automating response regression
Product teams reviewing contract evolution

Illustrative diff

Output fragment

breakingChanges: [
  { type: "TYPE_CHANGED", field: "id", ... }
]
nonBreakingChanges: [
  { type: "FIELD_ADDED", field: "email", ... }
]

Summary

summary: {
  breakingCount: 2,
  nonBreakingCount: 1
}

What the API does

POST /diff — Body must include before and after (any JSON values Express can parse: objects, arrays, primitives).

GET /health — Liveness.

This API does not infer schemas, generate OpenAPI, or do semantic “same meaning” matching (e.g. field renames appear as remove + add).

Deterministic output

Same before and after always produce the same change lists and counts.

Request & response

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

View request · View success response · View change types · View invalid input behavior

Field	Required	Description
`before`	Yes	Baseline JSON value.
`after`	Yes	Candidate JSON value.

Field	Description
`validJson`	`true` when comparison ran.
`breakingChanges[]`	Each: `type`, `field` path, optional `before`/`after`, `metadata`.
`nonBreakingChanges[]`	Same general shape for safe changes.
`summary`	`breakingCount`, `nonBreakingCount`.

Try it in the playground

Pick a sample or edit JSON, add your RapidAPI key, run, then copy generated code.

RapidAPI Key (required)

Sample request

Templates load into the editor; edit before running.

Request body (JSON)

Subscribe on RapidAPI for production quotas.

Get code

Snippets match the playground. Path: /diff.

Integration time: One HTTP POST from CI with two JSON snapshots.

Real-world examples

1. Release gate

Store last prod sample as before; on deploy candidate, POST and fail if summary.breakingCount > 0.

2. Golden file tests

Check test output (after) against committed golden (before) with stable sorting from the API.

3. Filter noise in app code

Allow-list FIELD_ADDED under certain paths; alert on TYPE_CHANGED anywhere.

Pricing & tiers (RapidAPI)

Built for teams running many contract comparisons in CI and staging.

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 and populated change lists when both sides parse and compare succeeds. 400 with validJson: false for many client errors. Rare failures may still return the error-shaped body.

About this API

Also known as

JSON diff API, breaking change detector, API contract comparator, structural JSON diff.

See the README for the full list of change type strings and design limitations (no rename detection, no semantic value equality).

Frequently asked questions

About 10MB for the whole JSON body (before and after together).
No. Stateless in-memory processing.
Yes—deterministic output is ideal for gates and golden tests.
Removed fields, type changes, root type changes, certain nullability and array structure changes—see change types section.
Often HTTP 400 with validJson false, empty changes, and invalidSide for the failing half.
No—only two concrete JSON values are compared.
On RapidAPI: Basic 100/mo; Pro $9.99/10k; Ultra $49.99/100k; Mega $99.99/250k.
Structure and types drive results; you get breaking vs non-breaking classification and paths.

Browse all APIs in the catalog →