Your FAQ dropdown worked last month. Your product star ratings showed up in search. Then one day, they're just gone, and nothing on your site looks broken. That's the frustrating part about structured data: it fails silently. There's no 404, no broken image icon, no angry email from a customer. The only way you find out is by testing it, and the tool for that job is Google's free Rich Results Test.
This guide walks through how to actually use that tool to find what broke, why it broke, and how to fix it without guessing.
Table of Contents
- Why Broken Schema Markup Quietly Costs You Rich Results
- What Google's Rich Results Test Actually Checks
- Step 1: Run the URL Test, Not Just the Code Snippet Test
- Step 2: Read Errors vs. Warnings as Different Priorities
- Step 3: Match Markup Fields to What's Visibly on the Page
- Step 4: Fix the Three Most Common Failure Patterns
- Step 5: Re-Test After Every Single Change
- Known Limits: Rich Results Test vs. Google Search Console
- A Quick Comparison: What Each Tool Actually Tells You
- How We Approach This for Las Vegas Small Business Sites
- FAQ
Why Broken Schema Markup Quietly Costs You Rich Results
Structured data is the code (usually JSON-LD) that tells Google what a page's content means, not just what it says. A block of text might read like a product page to a human, but without schema, Google has to infer that it's a Product, with a price, an availability status, and a review count. Schema removes the guesswork.
The problem is what happens when that code has a typo, a mismatched field, or a missing required property. Google doesn't flag it for you on the page. It doesn't guess what you meant. It just quietly skips the rich result and moves on. Your page still ranks, still loads, still looks fine to a visitor. The only thing missing is the star rating or FAQ dropdown that used to show up in search, and you'd have no reason to notice unless you went looking.
If your rich results silently disappeared, nothing on the site itself will tell you why. You have to go test for it.
Seoclarity's analysis of common structured data issues makes the same point from the other direction: Google will not reward markup whose attributes don't exactly match what's visibly on the page (seoclarity.net, 2024). The fix isn't just technical correctness; it's correctness that matches reality.
What Google's Rich Results Test Actually Checks
The Rich Results Test is Google's free diagnostic tool for structured data. You give it a URL or a pasted code snippet, and it tells you which schema types it found, whether they're eligible for a rich result, and what errors or warnings are attached to each one.
It covers product snippets, FAQ markup, review stars, breadcrumbs, event listings, and several other rich result types. For each one, the tool runs through a checklist of required and recommended fields and reports back.
Here's the part people miss: 'valid' in this tool means eligible, not guaranteed. Passing the test tells you Google can show a rich result for that page. It doesn't mean Google will. Google makes that call independently, based on factors the test doesn't expose, like overall page quality and search intent.
A Google Search Central walkthrough on reading the test's report emphasizes that every status line maps to a specific requirement, and the detail most people skip, the "More Info" link under each item, is usually where the actual fix lives (google.com, 2026). Don't just glance at the pass/fail headline. Click into it.
Step 1: Run the URL Test, Not Just the Code Snippet Test
If you only ever paste your raw JSON-LD into the tool, you're testing your intentions, not what Google actually sees. Run the live URL instead. That forces the tool to render the page the way Googlebot does, including any JavaScript that injects or modifies schema after the initial page load.
This matters a lot more than it used to. Sites built on React, Next.js, or many modern page builders often inject schema client-side. Your code can look perfectly clean in the editor and still fail live, because a script didn't finish executing before Google parsed the page.
After the scan completes, click "View Tested Page." This is the single most skipped step in the whole process. It shows you exactly what resources loaded, what didn't, and what the rendered HTML looked like at the moment Google grabbed it. If a resource failed to load, that's often your root cause, not the schema syntax itself.
Step 2: Read Errors vs. Warnings as Different Priorities
The test splits findings into two buckets, and they are not the same emergency.
- Errors mean the schema is invalid for that rich result type. Google will not show it, period. These go to the top of your list.
- Warnings mean the markup is technically valid but missing a recommended field. You might still get the rich result, just a thinner version of it.
A real example from Google's own support forum illustrates how confusing this can get: a site owner built Service schema that followed schema.org's spec correctly, and the Rich Results Test still flagged it, because that specific rich result type required a sub-property that schema.org itself treats as optional (support.google.com, 2020). The lesson: schema.org compliance and Rich Results Test eligibility are related but not identical standards.
Don't treat every warning as a fire drill. Triage by asking which rich result type the warning actually blocks, then work down from there.
Step 3: Match Markup Fields to What's Visibly on the Page
Here's a root cause that shows up constantly and has nothing to do with syntax: your schema says one thing, and your page says another.
Google's own guidance and third-party audits consistently point to the same pattern: schema that claims a price, a star rating, or a stock status that doesn't match what a visitor actually sees. This isn't treated as a simple validation error. It's flagged as a potential spam signal under Google's structured data guidelines, a different and more serious category than a missing field.
Before you chase syntax fixes, do a visual pass:
- Does the
reviewCountin your schema match the number of reviews actually displayed? - Does the
pricefield match the price rendered on the page? - Does
availabilitymatch what a shopper would see if they tried to buy right now?
If any of those are out of sync, that's your fix, and it's usually a content or data-feed problem, not a code problem.
Step 4: Fix the Three Most Common Failure Patterns
Most broken schema falls into one of three buckets. Knowing which one you're looking at saves a lot of time.
| Failure Pattern | What It Looks Like | How to Catch It |
|---|---|---|
| Missing required properties | Tool lists a specific absent field (e.g., address on LocalBusiness) | Read the error detail; it names the exact field |
| Nested type errors | A Review inside a Product lacks its own author or reviewRating object | Check that nested objects have their own complete structure, not flattened fields |
| Duplicate/conflicting schema | Two JSON-LD blocks describe the same entity differently | Test the live URL and view page source for repeated <script type="application/ld+json"> tags |
Missing required properties are the most straightforward: each schema type (Product, LocalBusiness, FAQPage) has its own required fields per schema.org, and the test names the exact one that's absent.
Nested type errors are sneakier. A Review nested inside a Product needs its own complete author and reviewRating objects. A flattened structure that skips that nesting often fails without an obvious error pointing you to the real cause.
Duplicate or conflicting schema blocks happen constantly on sites running page builders or plugins alongside hand-coded schema. The plugin injects its own JSON-LD on top of what a developer already wrote, and now you have two competing descriptions of the same entity. EZRankings' structured data troubleshooting guide specifically recommends using the URL test field to catch these layered, plugin-introduced duplicates, since they often don't show up in a code-only review (ezrankings.com). If you're setting up schema from scratch rather than debugging an existing build, our guide on how to add schema markup to a local business website walks through the clean version of this process.
Step 5: Re-Test After Every Single Change
Make one fix. Re-run the test. Don't batch five changes and hope they all landed.
This sounds tedious, but batching fixes is exactly how people end up stuck debugging the wrong thing for an hour. If you change three fields and the test still fails, you don't know which change worked and which one didn't.
Caching is the other quiet culprit here. CDN caching, browser caching, and plugin-level caching can all serve a stale version of your page to the testing tool, long after you've actually fixed the code. If a fix "didn't work," check whether you're looking at a cached version before you start second-guessing your markup.
A fix you haven't re-tested is a hypothesis, not a fix. Treat every markup change as unverified until the tool confirms it.
Known Limits: Rich Results Test vs. Google Search Console
The Rich Results Test has a narrow job: it checks one page, right now, as rendered. It tells you nothing about how Google has historically crawled that page, or whether other pages on your site share the same problem.
For that broader view, you need Search Console's Enhancements reports. These show aggregate structured data health across your entire site over time, including pages Google has already crawled and flagged, which is invaluable if the same template is used across dozens of pages.
There's also a feature-level limit worth knowing about: Google officially scaled back FAQ rich results as an eligible feature for most sites, which means the feature-specific test may no longer validate FAQPage markup as a visible search feature even when the code itself is technically valid (google.com, 2026). Validating schema and getting a rich result are two different outcomes, and it's worth checking Google's current structured data documentation before investing significant time in any one markup type.
A Quick Comparison: What Each Tool Actually Tells You
| Tool | Scope | Best For |
|---|---|---|
| Rich Results Test | One URL or code snippet, live | Debugging a single page right now |
| Search Console Enhancements | Site-wide, historical | Spotting trends and recurring errors across templates |
| Schema.org Validator | Syntax only, no rich result eligibility | Checking raw JSON-LD validity without Google's opinion |
Use all three together rather than picking one. The Rich Results Test tells you what's wrong on this page today; Search Console tells you whether it's a pattern; the Schema.org Validator tells you if your code is even syntactically sound in the first place.
How We Approach This for Las Vegas Small Business Sites
When we build or audit sites for Las Vegas and Henderson clients through our web design and technical SEO work, schema validation is part of the launch checklist, not something we circle back to later.
We've also learned that performance and markup problems often disguise themselves as something else. On one landscape services client, we traced a Lighthouse score drop from 96 to 41 over six weeks, with almost no code deploys on our end, back to a stack of five third-party tracking beacons quietly dragging down Total Blocking Time. It wasn't a regression in anything we wrote. It was invisible drift from scripts nobody was watching.
The same investigate-before-you-fix discipline applies to schema. Don't assume a markup failure is your code until you've ruled out plugins, third-party scripts, and caching layers. If you're also chasing related rendering issues, our walkthrough on diagnosing render-blocking scripts covers the same investigative approach, and our Core Web Vitals checklist is a good companion audit to run alongside any schema cleanup.
FAQ
What does 'valid' mean in Google's Rich Results Test?
Valid means your structured data meets the technical requirements for that rich result type, nothing more. Google still decides independently whether to actually display the rich result in search; passing validation is necessary but not sufficient for visibility.
Why does my schema look correct in the code but still fail the test?
The most common cause is JavaScript-injected markup that hasn't finished rendering when Google crawls the page. Test the live URL, not just a code snippet, and check "View Tested Page" to see exactly what resources loaded.
Can broken schema markup hurt my rankings?
Broken schema typically costs you the rich result (star ratings, FAQ dropdowns, etc.) rather than your core ranking position. However, schema that misrepresents visible page content can be treated as a spam signal under Google's structured data guidelines.
Does FAQ schema still show up in Google search results?
Google has scaled back FAQ rich results for most sites as of 2026, so even technically valid FAQPage markup may no longer produce a visible SERP feature. Check Google's current structured data documentation for which types are actively supported before investing time there.
How often should I re-test my schema markup?
Re-test after any template change, plugin update, or migration, and periodically (quarterly is reasonable) even without changes, since third-party scripts and CMS updates can silently alter rendered markup without a code deploy on your end.
If you've never run your own site through the Rich Results Test, do it today, not next quarter. Pull up your homepage and your top three service pages, paste each URL in, and read past the pass/fail headline into the actual field-level detail. If you find errors you're not sure how to prioritize, that's exactly the kind of technical SEO cleanup we handle for Las Vegas small business sites.
