Structured data · JSON-LD · Microdata · RDFa
Your schema is valid.
But do the blocks agree?
The Rich Results Test checks each block alone. It stays silent when two valid blocks describe the same product with a different price, or your theme and your SEO plugin both emit an Organization. schemaconflict matches blocks that describe the same entity and diffs their fields — surfacing the contradiction and the exact Search Console / Merchant Center error it triggers.
What it checks
The contradictions validators miss
Price & availability mismatch
The same product priced differently across two JSON-LD blocks, or in-stock in one and out in another — what Merchant Center calls Mismatched value.
JSON-LD vs Microdata
The same item described in two formats with different values. Google often won't merge them — flagged explicitly as cross-format.
Duplicate Organization / WebSite
Two SEO plugins (or a theme plus a plugin) each emitting an Organization, so Google can't tell which is canonical.
Rating disagreement
An aggregateRating that differs between blocks — a common reason the review stars silently vanish.
Entity matching
Blocks are paired by @id, then GTIN/SKU/MPN, then URL, then type + name — so two genuinely different products are never falsely flagged.
Invalid JSON-LD
A block that doesn't parse is ignored entirely by Google. The exact JSON error is shown so you can recover the lost rich result.
Open methodology
Every rule, in the open
No mystery score. Here is exactly how each conflict is decided — so you can verify and trust the result.
- ParseExtract every JSON-LD block (parsed exactly, including @graph and nested offers/aggregateRating), plus Microdata (itemscope/itemprop) and RDFa (typeof/property) items.
- Invalid JSON-LDFAIL — a JSON-LD block that does not parse is ignored entirely by Google; the exact JSON error is shown.
- Entity matchingGroup items that describe the same thing by the strongest shared identifier: @id, then GTIN/SKU/MPN, then URL, then type + name.
- Field diffFor each matched group of ≥2 blocks, compare name, price, price currency, availability, rating value, review count, SKU, GTIN, MPN and brand after normalization (1,299.00 = 1299; schema.org/InStock = InStock).
- Price / availability / currency mismatchFAIL — these map to Merchant Center “Mismatched value” errors and usually drop the offer rich result.
- Name / rating / identifier mismatchWARN — Search Console treats the entity as ambiguous and may drop the snippet or pick a value arbitrarily.
- Cross-format duplicateINFO/FAIL — the same entity in both JSON-LD and Microdata is flagged because Google may not merge them; a value disagreement across formats is a hard conflict.
- Duplicate Organization / WebSiteWARN — two distinct Organization (or WebSite) entities on one page (often two SEO plugins) confuse which is canonical.
Need to generate clean structured data rather than audit it? That's a different job — use a generator like schemawright. schemaconflict only audits the schema already on a page for contradictions.
Frequently asked questions
What does schemaconflict check?
It finds value-level contradictions across all the structured data on a page: two JSON-LD blocks that give the same product different prices, a JSON-LD Product and a Microdata Product that disagree on availability, two SEO plugins each emitting an Organization, an aggregateRating that differs between blocks, and so on. It is not another syntax validator — it assumes your markup already parses, and looks for blocks that fight each other.
How is this different from the Rich Results Test or Schema.org validator?
Those validate each block in isolation: is this one block valid and eligible? They stay silent when two separate valid blocks describe the same thing with different values. schemaconflict matches blocks that refer to the same entity (by @id, GTIN/SKU, URL or name) and diffs their fields, so it catches the contradictions a per-block validator cannot see.
Why do conflicting blocks matter?
When Google sees the same product priced $19 in one block and $29 in another, it cannot trust either. Merchant Center reports “Mismatched value (price)”, Search Console treats the page as ambiguous, and the rich result (price, stars, availability) is often dropped entirely. One source of truth per entity is the fix.
Can I paste markup instead of a URL?
Yes. Paste a full HTML page, or just your JSON-LD, into the box and it runs entirely in your browser — nothing is sent to a server. The URL mode fetches the page for you (with private/internal addresses blocked) and runs the exact same checks.
Which formats does it read?
JSON-LD (exact, including @graph and nested offers/aggregateRating), Microdata (itemscope/itemprop), and RDFa (typeof/property) — best-effort for the latter two. Cross-format conflicts (JSON-LD vs Microdata for the same item) are flagged explicitly, because Google often will not merge them.
How are two blocks decided to be “the same entity”?
By the strongest identifier they share: @id first, then GTIN, SKU or MPN, then URL, then type + name. Only blocks that match are diffed, so a page with two genuinely different products is not flagged.
Does it generate schema?
No — for generating clean JSON-LD use a generator (we link to schemawright). schemaconflict is the opposite end: it audits the schema already on a live page for contradictions.
Is my data safe?
Paste mode never leaves your browser. URL mode runs on Cloudflare, fetches only public http(s) URLs (private, loopback, link-local and cloud-metadata addresses are blocked, redirects are re-validated, responses are size-capped) and keeps no logs.