Schema Comparison Tool

Free

Two schemas go in. One diff comes out. The part where you squint at two tabs trying to spot what changed — that's over.

Paste two JSON-LD blocks or fetch them from URLs. See what's been added, removed, or changed — side by side, colour-coded, with Before/After or Structural mode depending on whether you're checking your own work or sizing up a competitor. No logins. No diff tool that requires a PhD. Just the differences.

A Schema A (baseline)

B Schema B (compare)

A Schema A

B Schema B

Why comparing schemas manually is a bad afternoon

You changed the schema. Or someone else did. Or a plugin updated itself and nobody noticed until the rich results vanished. Either way, now you need to know what's different between two versions of structured data — and the answer is buried inside two blocks of nested JSON-LD that look almost identical until they don't.

You could paste both into a text diff tool. You'd get a wall of red and green that treats a trailing comma the same as a missing @type. This tool understands the structure — it knows what a property is, what a type is, what a value is — and shows you exactly what moved, what appeared, and what disappeared. The noise goes away. The signal stays.

Added properties

New types, fields, or nested objects that exist in B but not in A. Green-highlighted so they're obvious at a glance.

Removed properties

Anything that was in A but is missing from B. The fields that somebody deleted — intentionally or otherwise.

Changed values

Same property, different value. Price went from 29.99 to 34.99. URL switched from HTTP to HTTPS. The quiet changes that break things quietly.

Structural overview

Summary counts — how many types in each schema, total differences, and a breakdown by category so you know how big the gap is before you dig in.

When this saves you from tab-switching

Schema comparison comes up more often than people admit. Usually at inconvenient times.

Before / After deploys

You just pushed a schema update. Paste the old version and the new version. See exactly what changed before your client asks why FAQs stopped appearing in search results.

Competitor analysis

Fetch schema from your product page and your competitor's. Structural mode shows you which types they're using that you're not — and which properties they've filled in that you left empty.

Migration audits

Replatforming and need to verify the new CMS outputs the same schema as the old one? Before/After mode was built for this. Run it across your key templates and spot what the migration lost.

Schema debugging

Rich results disappeared and you don't know why. Compare today's schema against a cached version from when it was working. The diff tells you what changed. Usually faster than the validator.

Two modes, one goal: show you what's different

The tool parses both JSON-LD inputs into structured trees, then walks them node by node. The comparison is type-aware — it understands @type, @context, and nested objects — so the diff is semantic, not just textual.

Before / After mode

Treats A as the baseline and B as the update. Shows what was added, removed, or changed — the way you'd review a pull request. Best for checking your own changes or verifying a deploy.

Structural mode

Compares the shape of both schemas without assuming one is "correct." Shows differences in both directions — what A has that B doesn't, and vice versa. Best for competitor analysis or comparing two independent pages.

💡

Tip

Use the Swap A / B button to quickly flip perspective. In Before/After mode, this reverses what counts as "added" vs "removed" — useful when you pasted them in the wrong order. Happens more than you'd think.

What this tool does and doesn't do

It compares structure and values. It doesn't validate against schema.org or check Google's eligibility requirements. Different tools, different jobs.

✅

Compares JSON-LD

Parses and diffs valid JSON-LD structured data. Handles nested objects, arrays, multiple @type declarations, and deeply nested properties.

✅

Colour-coded diff

Green for added, red for removed, amber for changed. Visible in both the summary panel and the side-by-side tree view.

⚠️

Client-side only

Everything runs in your browser. Nothing is sent to a server. But that also means very large schemas (50KB+) might slow the diff rendering.

⚠️

JSON-LD only

Microdata and RDFa are not supported. If you need to compare those formats, convert to JSON-LD first — Google's Rich Results Test can export it.

Frequently asked questions

What's the difference between Before/After and Structural mode?

Before/After treats Schema A as the original and Schema B as the updated version — so the diff is directional, like a code review. Structural mode compares both schemas symmetrically, showing what each has that the other doesn't. Use Before/After for checking your own changes. Use Structural for competitor analysis or comparing two unrelated pages.

Can I compare schemas from live URLs?

Not directly from this tool — but you can use the Schema Markup Visualizer to fetch schema from any URL, copy the JSON-LD output, and paste it here. Two extra clicks, but it works.

Does this validate my schema against schema.org?

No. This tool compares two schemas against each other, not against a specification. For validation, use Google's Rich Results Test or the schema.org validator. Different questions, different tools.

Is my data sent to a server?

No. The entire comparison runs in your browser using JavaScript. Nothing is transmitted, stored, or logged. Paste confidential schemas without worry.

What if my JSON-LD has syntax errors?

The tool will tell you which input failed to parse and roughly where the error is. Fix the syntax first — a comparison requires two valid JSON-LD blocks. If you're not sure where the error is, paste it into the Schema Markup Visualizer which has auto-repair built in.

Can I compare more than two schemas at once?

Not currently. The tool handles one pair at a time. For multi-page audits, compare each page's schema individually against your baseline template — it's more manageable than a three-way diff anyway.