Most Common Schema Markup Mistakes (And How to Fix Them)

Adding schema markup feels like a solved problem — paste a JSON-LD block into the head of the page and move on. Then Search Console shows zero rich results, or worse, a spike of "Invalid" items in the Enhancements report, and nobody can tell why the page that used to get star ratings suddenly doesn't.

Nearly every case traces back to a handful of repeat offenders: mistakes that are easy to make, hard to notice, and just as easy to fix once you know where to look. This guide walks through the ones that show up most often, why each one breaks things, and exactly how to catch them before they cost you a rich result.

What counts as a schema markup mistake?

A schema mistake isn't just a typo — it's any gap between what your JSON-LD claims and what Google can actually verify or trust about the page. Mistakes generally fall into a few buckets:

• Accuracy mistakes. The schema states something that isn't true or isn't visible on the page — a rating that doesn't appear anywhere, a price that's out of date.
• Type mistakes. The wrong schema.org type is used for the content, like labeling a blog post as a Product or an opinion piece as NewsArticle.
• Syntax mistakes. The JSON-LD itself is malformed — a missing comma, an unescaped quote, a broken bracket — which can invalidate the entire block.
• Structural mistakes. Multiple schema blocks describe the same entity differently, or required properties for a given type are simply missing.

Google's validators catch some of these automatically. Others, like a type that technically parses but doesn't reflect the content, require a human judgment call — which is exactly why they slip through so often.

Why these mistakes matter

A broken schema block rarely crashes the page for a visitor, which is precisely why these mistakes are so easy to leave unfixed:

• Rich results quietly disappear. A single invalid field can drop a page out of eligibility for the star ratings, prices, or FAQ dropdowns it used to qualify for.
• Errors compound across templates. Because schema often lives in a shared template or CMS field, one mistake can silently propagate across hundreds of pages at once.
• Trust signals get muddied. Inaccurate or inconsistent structured data makes it harder for search engines and AI answer engines to extract reliable facts about the page.
• Repeated violations escalate. Deliberately or repeatedly marking up content that isn't real, like fabricated reviews, can move beyond a disabled rich result into a manual guideline action.

Step-by-step: auditing your schema for mistakes

1. Pull every URL that should have schema markup. Start from your sitemap or CMS templates so you have a complete list of pages that are supposed to carry structured data, not just the ones you remember adding it to.
2. Run each template through the Rich Results Test. Check one representative page per template rather than every single URL — most mistakes live in the template, not the individual page.
3. Cross-check with the Schema Markup Validator. The Rich Results Test only reports what affects eligibility; the Validator gives a stricter read of the raw JSON-LD, surfacing issues that wouldn't otherwise show up.
4. Compare every claimed field against the visible page. For each property in the schema — rating, price, author, date — confirm a visitor can actually see that exact value somewhere on the page.
5. Check for duplicate or conflicting blocks. Search the page source for more than one script tag of type application/ld+json and confirm they don't describe the same entity with different values.
6. Fix at the template level. Correct the source template or CMS field so the fix applies everywhere the mistake was repeated, instead of patching one URL at a time.
7. Set a recurring check. Re-run validation after any CMS, plugin, or theme update, and periodically otherwise, since schema breaks silently and doesn't announce itself.

The most common schema markup mistakes

1. Marking up content that isn't visible on the page

The single most flagged violation in Google's structured data guidelines: a rating, price, or review count sitting in the JSON-LD that a real visitor can't find anywhere on the page. If it's not visible, it shouldn't be in the schema.

2. Choosing a schema type that misrepresents the content

Labeling a blog post as Product, or an opinion piece as NewsArticle without meeting the criteria, mismatches the declared type against the real content. Validators often miss this one entirely, since the JSON-LD can be perfectly well-formed and still be the wrong type.

3. Copy-pasting a competitor's or template's schema without updating every field

Reusing someone else's JSON-LD block and forgetting to swap out the name, URL, image, or author fields leaves your page technically pointing at someone else's data — invisible to visitors, but immediately obvious to Google.

4. Publishing malformed JSON-LD

A missing comma, an unescaped quotation mark, or a mismatched bracket is enough to break parsing for the entire block, not just the one field. The rest of an otherwise-perfect schema gets discarded along with the typo.

5. Running duplicate or conflicting schema on one page

Two script blocks describing the same Organization or Product with different values create ambiguity that search engines resolve unpredictably — sometimes by picking one arbitrarily, sometimes by discarding both.

6. Leaving required properties out

Each schema type has properties Google treats as required for a rich result to appear, and others that are merely recommended. Omitting a required property, like image for Recipe, quietly disqualifies the page even though the JSON-LD still validates as syntactically correct.

Real-world examples

How these mistakes typically show up in practice, and what tends to happen once they're left unaddressed:

The common thread: none of these mistakes crash the page for a visitor, which is exactly why they survive so long without anyone noticing.

Mistake severity compared

Not every schema mistake carries the same risk. A side-by-side look at how severe each common issue tends to be, and how quickly it's usually caught.

Generate mistake-free schema markup — free

The Rebrixe Schema Generator builds clean, validated JSON-LD for the most common schema types — Article, Product, FAQPage, Recipe, and more — so the syntax and required-field mistakes above never happen in the first place.

Frequently asked questions