The schema markup mistakes Google's rich results validator catches

Rich results, the star ratings, price tags, and product images in search results, only show up when your schema markup is correct. A single error can disable them entirely. Google's Rich Results Test catches hundreds of thousands of schema mistakes every day, but most site owners never run it. The ones who do often see unexpected failures that cost them traffic.

This post walks through the schema markup mistakes that actually disable rich results, why Google's validator flags them, and how to prevent them from breaking your visibility.

What schema markup is and why rich results matter

Schema markup is structured data wrapped around your content. It uses schema.org vocabulary to tell search engines what your page is about: a product with a price, a recipe with instructions, an article with an author, an event with a date.

Google uses schema markup to generate rich results. Rich results are expanded search listings that show more context: price, availability, rating, ingredients, publication date. They take up more space in search results and draw more clicks. Studies show rich results get significantly higher click-through rates than plain text snippets, sometimes 2 to 3 times more traffic from the same ranking position.

Without correct schema markup, you don't get rich results. Your listing competes on title and meta description alone, and you lose the visibility bump.

The mistakes Google's validator catches

Google's Rich Results Test is a free tool that validates your schema markup against Google's requirements. It's stricter than the official schema.org spec. Run your homepage through it and you'll likely see one or more errors. Here are the most common ones.

Missing or incorrect required fields

Schema types have required and optional fields. For a Product schema, you need a name. For a Recipe, you need ingredients and instructions. For an Event, you need a name and start date.

The Rich Results Test catches missing required fields and shows them as errors. The schema might be valid according to the schema.org spec, but it won't generate a rich result.

Example: A product page with a Product schema that includes name, image, and price, but no description or availability. Google won't show it as a rich result even though the schema is technically valid. You need at least name, image, price, and availability for Google to render the rich snippet.

Invalid data types

Every field in schema markup expects a specific data type. A price should be a number or text with a currency code. A date should be in ISO 8601 format (2026-07-02). An image URL should be an absolute URL (http or https), not a relative path.

If you pass the wrong data type, Google's validator rejects it:

• Price field gets a comma-formatted string like "1,234" instead of "1234"
• Date field gets "July 2, 2026" instead of "2026-07-02"
• Image URL is "/images/product.jpg" instead of "https://yourdomain.com/images/product.jpg"

These look correct to a human but break the schema validation.

Mismatched schema types

A schema type and its parent should make logical sense. A Recipe shouldn't be nested inside a Product. A NewsArticle shouldn't contain an Event. These mismatches confuse Google's parser.

More subtle: using a generic "Thing" type when you should use a specific subtype. A "Thing" with a name and description is too vague for a rich result. You need the specific type: "Product", "Article", "Recipe", etc.

Missing or incorrect URLs

Schema markup often references images, links, or other resources. These URLs must be absolute (fully qualified with https://) and must return 200 status codes.

Common mistakes:

• Image URLs that use relative paths: "/img/product.jpg" instead of "https://yourdomain.com/img/product.jpg"
• Links to pages that don't exist or return 404
• URLs with temporary redirects (302) instead of permanent ones (301)
• Images that load behind authentication or geo-blocking

If Google crawls your schema and can't fetch the referenced resource, it may ignore that field or reject the entire rich result.

Duplicate or conflicting schema

If a page has two Product schemas describing the same item with different prices or availability, Google gets confused. It won't show a rich result because it can't determine which data is canonical.

Similarly, schema placed inside another schema's container can create conflicts. A Recipe schema inside a Product schema is ambiguous.

Hidden or invisible schema

Schema markup placed in hidden HTML (display: none, opacity: 0, hidden elements) can be rejected. Google's guidelines require that the schema markup accurately represent the visible content on the page.

If your schema says a product is "in stock" but the visible page says "out of stock", the validator catches it.

Incomplete structured data

Some schema types require multiple instances to form a valid rich result. A local business with multiple locations needs separate LocalBusiness schemas for each location. An article needs both the article schema and a linked image. A product with multiple reviews needs individual Review schemas connected to the main Product.

Incomplete data gets flagged as warnings. It won't break a rich result, but it'll be less complete than it could be.

How to identify and fix these mistakes

The Rich Results Test shows every error and warning. Click on each one and you'll see the line of code causing the problem, what the requirement is, and what you're actually providing.

Start with errors. Errors prevent rich results from showing. Warnings don't block rich results but might reduce what Google can display.

Fix errors first:

1. Check the required fields for your schema type. schema.org has a reference for every type.
2. Verify data types. Prices are numbers. Dates are ISO 8601 format. Images are absolute HTTPS URLs.
3. Make sure your URLs are absolute and that the resources exist (run an HTTP headers check on the URLs to confirm).
4. Remove duplicate schema. If two schemas describe the same item, keep only one and make sure it's complete.
5. Unhide any hidden schema. If you're using schema for internal tracking, move it to robots-only sections or use the API instead.

After fixing errors, run the Rich Results Test again. The page should pass validation.

Why this matters for your traffic

Every error you don't catch costs you visibility. A product page that fails schema validation doesn't get a rich result. A recipe page that's missing instructions doesn't show the star rating. An article that has no image won't appear in Google News.

You're still ranking for the keyword, but you're competing on title and description alone while competitors with correct schema get the visual advantage.

Scanning for these issues manually across a large site isn't practical. A 500-page product catalog could have 50 different schema problems across 200 pages, and you wouldn't catch all of them manually.

Tools for validation and auditing

Google's Rich Results Test is the gold standard, but it's designed for spot-checking single pages. For a full site audit, you need a tool that can crawl your entire site and validate all schema markup automatically. This catches the errors that would otherwise hide in less-visited pages.

AcuityScan includes a schema markup validation module that crawls your site and tests every schema for Google's rich result requirements. It identifies which pages have validation errors, which pages are missing schema entirely, and which schema types are incomplete. You get a full inventory of schema problems prioritized by impact.

The HTTP headers check also helps: it validates that your image and link URLs in schema markup are returning the correct status codes.

Run a full scan and you'll see which pages are losing traffic due to broken schema. Then fix the high-impact items first: product pages with missing prices, articles with no author, recipes with incomplete instructions.

Takeaway

Schema markup drives rich results. Rich results drive clicks. But one small error anywhere in your markup disables the whole thing. Google's Rich Results Test catches most of these errors, but running it once per page isn't scalable.

Find the mistakes across your entire site, prioritize by impact, and fix them. That's how you get the traffic back from competitors who already did.