Free API compatibility tool

JSON structure diff tool

Compare a baseline API response with a new response. Find type mutations, missing keys, unexpected nulls, and array changes without a noisy text diff.

Compare JSON structure

Compare types and paths, not changing values. Each document can contain up to 1 MB of JSON.

Privacy: documents are sent over HTTPS for in-memory schema extraction. Submitted JSON is not persisted or included in telemetry; telemetry contains only byte counts and outcome.

Prevent API schema drift in production

Tired of finding breaking changes after an app crashes? SteadyNode's zero-configuration API Guard detects schema drift on your live APIs automatically.

No credit card required.

Start for free

Detect API breaking changes without diffing values

A conventional text diff can be misleading for API responses. Identifiers, timestamps, prices, and user-provided strings change on every request, creating a long list of irrelevant differences. A schema comparison focuses on the shape of the data: JSON paths, node types, nullability, and whether an array can be empty. This makes a numeric identifier changing to a string much easier to see than it is in two large payloads.

What this JSON schema comparator checks

The comparison extracts a bounded, value-free structure from each document. It can flag a required key that disappeared, a field whose type changed, an unexpected null, or an array that is now empty when the baseline always contained values. Breaking changes are highlighted separately from warnings so an engineer can prioritize changes that are more likely to break a strict consumer.

The analyzer intentionally does not display submitted field values in its result. It also limits the size, object breadth, array sampling, and nesting depth it examines. These limits make requests predictable and keep the result focused on the portions of a payload that are practical to review. A comparison is a useful diagnostic—not a formal OpenAPI contract or a guarantee of backward compatibility.

How to use the JSON structure diff tool

  1. Paste a representative response from the last known-good API version into Baseline JSON.
  2. Paste a representative response from the new deployment into New JSON.
  3. Compare the paths and type transitions, then verify each finding against your client contract.

Compare examples from the same endpoint, version, and authorization context. Optional fields may appear only for some accounts, and an empty collection can be valid even when it did not occur in your baseline. If the tool reports an unexpected difference, determine whether it reflects an intentional contract change, a conditional response, or a deployment regression before changing a client.

Protect payload data while debugging

The JSON documents are sent over HTTPS to the comparison API because the tool reuses SteadyNode’s server-side schema engine. The API parses the documents in memory, returns only structural differences, and does not persist the submitted JSON. Telemetry contains byte counts and execution status rather than payload values. Do not paste credentials, tokens, or real personal data into diagnostic tools; use representative, sanitized examples whenever possible.

Prevent schema drift in production

This utility helps investigate a change after you have two responses to compare. For continuous protection, an API schema guard can learn a baseline and alert when a monitored endpoint begins returning an incompatible shape. Review intentional schema updates, keep a compatibility policy for consumers, and monitor the endpoints that carry the highest customer impact.

Frequently asked questions

How is a JSON schema comparison different from a text diff?

A text diff highlights changed characters and values. This comparator extracts JSON paths and types, then reports structural changes such as a number becoming a string or a required key disappearing.

Are the JSON values stored?

No. Documents are processed in memory to extract structural metadata and are not persisted. Usage telemetry stores only byte counts, outcome, duration, and a hashed client IP.

Can this detect every API compatibility issue?

It detects bounded structural changes in JSON. It cannot determine business semantics, authorization behavior, or compatibility rules that are not represented in the compared documents.