How to Use Google's Structured Data Testing Tool (And Read the Results)

Most teams implementing schema markup run their first test, see a wall of JSON-LD and status codes, and aren't sure what to do next. The problem isn't a lack of tools — Google provides several — it's knowing which tool to use, what its output actually means, and how to connect that output to what appears in search results. This article walks through each of Google's testing tools, explains what the results tell you, and shows you where teams most commonly go wrong after the test is done.

If you're looking for expert help in this area, explore how Indexed's technical SEO services can drive measurable results for your business.

The Structured Data Testing Tool Google Offers Today

There is a persistent question across SEO forums: is Google's Structured Data Testing Tool deprecated? The short answer is yes — in part. Google officially retired the original Structured Data Testing Tool (SDTT) in 2023 and redirected users to two replacement tools. Understanding the distinction between them matters more than most tutorials acknowledge.

The Rich Results Test

The Rich Results Test is Google's primary replacement for the old SDTT when your goal is feature eligibility. You enter a URL or paste raw code, and it tells you whether the structured data on that page qualifies for a specific Google rich result — FAQs, review stars, product carousels, recipes, and so on. This is the tool to use when your question is: "Will Google show a rich snippet for this page?"

Importantly, it only validates schema types that Google actively uses for rich results. If you implement Organization or SiteNavigationElement markup — both valid and useful — the Rich Results Test will return little or no feedback, because those types don't produce visible SERP features directly.

The Schema Markup Validator

For broader validation — covering any Schema.org type, not just Google-supported rich result types — validator.schema.org is the correct tool. It replaced the old SDTT's core validation function and checks whether your structured data is technically correct against the Schema.org specification, without applying Google-specific warnings or feature requirements. If you want to test Organization, WebSite, or custom schema types, this is the right starting point.

What the Test Results Actually Mean

Both tools return output in a similar format, but the labels are easy to misread. Here is what each status indicates in practice.

Errors vs. Warnings: A Practical Distinction

An error means a required property is missing or incorrectly formatted. Google's documentation specifies which properties are required for each rich result type — for a Product schema, for instance, name is required, and missing it will prevent eligibility. An error is not a ranking signal in itself, but it will block the rich result.

A warning flags a recommended property that is absent. Recommended properties don't block eligibility, but they do affect how complete and competitive your rich result will appear. A product listing with only the required fields may still display review stars, but a competitor who also includes aggregateRating, offers, and brand is likely to receive a richer, more prominent result.

The practical takeaway: fix errors first, then treat warnings as a prioritised backlog, not a nice-to-have list.

"Detected But Not Eligible" — the Status Nobody Explains

This is where most teams get stuck. The Rich Results Test may show that your schema was detected but the page is not eligible for a rich result. This does not mean your markup is wrong. It frequently means one of the following:

• The page type doesn't qualify for the rich result you're targeting (e.g., applying Recipe schema to a blog post that isn't a genuine recipe).
• The content on the page doesn't match the structured data — Google's guidelines require that schema reflects what a user actually sees on the page.
• The page is blocked from crawling or indexing, so Google cannot independently verify the markup.

Resolving "detected but not eligible" usually requires checking robots.txt, verifying canonical tags, and confirming that the content on-page and the schema markup are genuinely consistent.

Testing by URL vs. Pasting Code: When Each Approach Is Right

Both the Rich Results Test and the Schema Markup Validator accept either a URL or a code snippet. The distinction is significant and often overlooked in basic tutorials.

URL Testing

Testing by URL reflects what Google would actually see when it crawls your page, including any schema injected via Google Tag Manager, JavaScript frameworks, or server-side rendering. If your schema is delivered dynamically, URL testing is the only way to confirm it renders correctly. A common failure pattern: developers paste the raw JSON-LD and it validates perfectly, but the URL test returns no schema — because the JavaScript that injects it isn't executing correctly for crawlers.

Code Snippet Testing

Pasting code is faster for iteration during development. If you're building a new schema template or debugging a specific property, code-snippet mode lets you test variations without deploying to a live URL. Use it in the build phase; switch to URL testing for final validation.

The Gap Between "Valid" and "Appearing in Search"

This is the section that most structured data guides skip entirely, and it is the one that generates the most client questions in practice. A clean validation result does not guarantee that rich results will appear in Google Search. There are several additional conditions that must be met.

Google Applies Its Own Discretion

Google's structured data documentation explicitly states that valid markup does not guarantee a rich result will be displayed. Google uses signals including page quality, content relevance, and query context to decide whether a rich result is appropriate for a given search. A page with technically valid FAQPage schema on a thin or low-authority site may simply never display FAQ rich results — not because the schema is wrong, but because Google has assessed the page as insufficient.

Search Console Is Where Validation Ends and Monitoring Begins

Once schema is deployed and validated, Google Search Console's Rich Results report is the correct ongoing monitoring tool. It shows how many pages are eligible, how many are producing impressions and clicks, and any new errors Google has detected at crawl scale. Unlike the testing tools — which check a single URL at a point in time — Search Console reflects what Google's crawlers are seeing across your entire site over time.

A practical workflow: validate new schema with the Rich Results Test before deployment, then check the Rich Results report in Search Console four to six weeks after deployment to confirm impressions are growing. If impressions don't appear within eight weeks on an indexed, crawlable page, the issue is typically content quality or schema-to-content mismatch, not a technical markup error.

Four Structured Data Mistakes the Tools Won't Catch

Google's testing tools are good at identifying property-level errors. They are not designed to catch strategic or editorial mistakes, and these tend to be more damaging in practice.

• Marking up content that isn't on the page. Adding aggregateRating with a score when no reviews appear on the page violates Google's spam policies and can result in a manual action, not just a suppressed rich result.
• Using deprecated schema types. Schema.org evolves, and some types or properties that passed validation two years ago have since been superseded. Checking the Schema.org changelog periodically is worth the time investment.
• Applying rich result schema to paginated or filtered URLs. Product category pages with parameter-driven URLs (e.g., ?colour=blue) often inherit schema from a template incorrectly, producing hundreds of near-duplicate schema instances that can confuse Google's indexing.
• Ignoring entity-level schema in favour of rich result types only. Organization, Person, and WebSite schema don't generate rich results, but they help Google understand who you are and can support Knowledge Panel development. Omitting them because they don't show in the Rich Results Test is a common oversight.

FAQ

Is the Google Structured Data Testing Tool deprecated?

Yes, Google retired the original Structured Data Testing Tool in 2023. It has been replaced by two tools: the Rich Results Test for checking rich result eligibility, and validator.schema.org for broader Schema.org validation. Both are free to use.

Can I test a URL that isn't live yet?

The Rich Results Test offers a code-snippet input mode precisely for this reason — you can paste your JSON-LD or Microdata directly without a live URL. For staged or password-protected environments, you'll need to either use code-snippet mode or temporarily allow Google's user agent through your staging server for an accurate URL test.

Is there a Google Structured Data Testing Tool API?

Google previously offered a Structured Data Testing Tool API, but it was deprecated alongside the original tool. The Rich Results Test does not currently offer a public API equivalent. Teams running validation at scale typically integrate Schema.org validation into their CI/CD pipelines using open-source libraries rather than relying on Google's interface directly.

My schema passes validation but no rich result appears. What should I check?

First, confirm the page is indexed — use the URL Inspection tool in Search Console. Second, verify that every property in the schema has a corresponding, visible equivalent in the page's on-page content. Third, check whether the Rich Results report in Search Console shows the page as "valid" but with zero impressions — this typically indicates Google is choosing not to display the rich result due to quality or relevance signals, not a markup error. Improving the overall depth and authority of the page content is usually the right response.

What to Do This Week

If you haven't already audited your site's structured data, here are specific first steps you can take immediately:

• Open the Rich Results Test and enter your five highest-traffic URLs. Note any errors (fix these first) and any warnings (add to your backlog with priority weighting by traffic).
• Check validator.schema.org for your homepage. Confirm that Organization and WebSite schema are present and error-free — these are often missing on sites that focus only on rich-result types.
• Open the Rich Results report in Google Search Console. If you haven't visited it recently, you may find errors that have accumulated at scale without triggering any visible alerts.
• Cross-reference your schema against on-page content. For any aggregateRating, price, or offers properties, confirm the values match exactly what a user sees on the page — this is the most common cause of policy violations.
• Set a calendar reminder to re-check the Rich Results report in six weeks. Structured data is not a one-time implementation task; it requires ongoing monitoring as Google's rich result requirements evolve.

Related Reading

• Entity SEO: How to Build Knowledge Graph Authority
• How Google's AI Overviews Work (And How to Appear in Them)
• What Are Common SEO Mistakes?
• SEO vs. GEO vs. AEO: What's the Difference?
• How to Write Content That AI Will Cite