Tech for Retail 2025 Workshop: From SEO to GEO – Gaining Visibility in the Era of Generative Engines

Back to blog

How to test structured data: methods and Google tools

SEO

Discover Incremys

The 360° Next Gen SEO Platform

Request a demo
Last updated on

1/11/2026

Chapter 01

Example H2
Example H3
Example H4
Example H5
Example H6

This article focuses on the practical side: testing structured data to validate schema.org markup and avoid errors that prevent eligibility for rich results. It covers the Google and schema.org tools, what each one checks, how to read Search Console and the most common errors, with a corrected example. For the full framework (formats, types, prioritisation), refer to our guide on structured data.

 

How to Test Structured Data to Validate Schema.org Markup

 

A markup test is designed to confirm two complementary things: your code follows the schema.org vocabulary (types, properties, values), and Google can use it to make the page eligible for specific rich results. The most reliable approach is a chained check:

 

  • validate schema.org compliance with the Schema.org validator, to eliminate structural and syntax errors;
  • check Google eligibility with the Rich Results Test, to see what Google detects and what blocks a rich result;
  • monitor at site level in Search Console (Enhancements reports and URL Inspection), to spot regressions after deployment.

 

What You Are Actually Checking When You Test Structured Data

 

Schema.org Validation vs Eligibility for Rich Results

 

A Schema.org validator answers the question "is my markup correct according to the standard?". The Rich Results Test answers a different one: "can Google use this markup for a given rich result display?". The two answers regularly diverge, and a serious test checks three distinct points:

 

  • eligible ≠ displayed: compliant, complete markup makes the page a candidate for a rich result, then Google decides based on relevance, quality and the context of the query;
  • actual rendering: the markup must exist in the HTML that Google obtains, including when it is injected with JavaScript;
  • consistency with visible content: every marked-up value (price, availability, author, date, address) must match what a visitor reads.

 

The tools offer two modes. The code snippet test is for debugging JSON-LD before deployment: syntax, missing fields, structure. The URL test confirms what Google actually reads on an accessible page, including rendered HTML and client-side injection. Fix issues on the snippet first, then confirm on the URL.

 

Prerequisites Before a Test: Rendering, Crawling and Data Consistency

 

Before interpreting an error, check three prerequisites, as they account for most of the gaps between tool output and reality:

 

  • Rendering: the markup must exist in the rendered HTML, not only inside an application that executes after the initial page load.
  • Crawling: the URL must be accessible to crawlers, not blocked in the robots.txt file, and not contradicted by a canonical tag or a noindex if you expect it to be tracked in Search Console.
  • Consistency: marked-up values must match visible content exactly; a mismatch loses eligibility and, if it misleads users, can lead to a manual action for spammy structured data.

 

Which Testing Tools Should You Use to Check Schema.org Markup?

 

Four free tools cover the essentials:

 

ToolWhat it checksModeWhen to use it
Rich Results TestEligibility for Google rich results: detected types, errors, warnings, previewURL or code snippetBefore and after deploying a template
Schema.org validatorCompliance with the vocabulary, for all types and all three formats; no display informationURL or code snippetFor types not covered by Google and for modelling errors
URL Inspection (Search Console)Indexed version of the page, detected rich results, live URL testURLAfter a fix, on a critical page
Enhancements reports (Search Console)Errors and warnings by type, across all crawled pagesWhole siteOngoing monitoring, after every release

 

What about the Structured Data Testing Tool? Google's Structured Data Testing Tool, long the reference, was retired in 2020. Its generic validation role was taken over by validator.schema.org, the Schema.org validator, while the Rich Results Test handles eligibility for rich results.

 

Rich Results Test: How to Use Google's Tool to Assess Eligibility

 

The Rich Results Test (search.google.com/test/rich-results) checks whether Google can correctly read a page and whether it qualifies for rich results. It only covers types that produce a rich result: for the others, use the Schema.org validator.

 

Testing a public URL. The procedure takes four steps:

 

  • paste the URL, ideally the accessible canonical version;
  • run the test and wait for the analysis to complete;
  • open the details for each detected type (Article, Product, BreadcrumbList…);
  • note what is eligible and what is not, with the explanation attached to each issue.

 

If the page relies on JavaScript, only the URL test shows what Google sees on the page that is actually served.

 

Testing a JSON-LD snippet. Use code mode when iterating on markup, for example a Product or a BlogPosting. Paste the <script type="application/ld+json"> block, fix the required properties flagged, then deploy and re-test the URL. Build this check into your development workflow rather than waiting until the end of a redesign.

 

Reading the output. The tool sorts what it finds into three categories:

 

  • Error: blocks eligibility for the associated rich result, for example a missing required property;
  • Warning: does not prevent eligibility, but signals a missing recommended property, so a potentially less complete display;
  • Detected items: the list of types found and, where applicable, a preview.

 

Check that the detected type matches the content and that nothing blocks eligibility. For an FAQ, FAQ rich results have been restricted since August 2023 to authoritative government and health websites: on a B2B site, a valid FAQPage will not produce one.

 

Rich Snippet Checkers and Rich Snippet Tests: What They Show and Their Limits

 

Checking a rich snippet means answering two questions: "am I eligible?" and "what is preventing the display?". The Rich Results Test answers them, with a fundamental limitation: even with perfect markup, Google never guarantees that a rich result will appear. The engine decides based on relevance, quality and the context of the query.

 

The preview shows what could be displayed, not what will be. Some displays have also disappeared at the time of writing: HowTo rich results removed in September 2023, breadcrumbs no longer shown on mobile since early 2025. A successful test on these types confirms compliance, not a display.

 

Schema Markup Validator: A Schema Validator for Standards Compliance

 

The Schema Markup Validator (validator.schema.org) validates markup against the schema.org vocabulary, independently of Google's eligibility rules. It accepts JSON-LD, Microdata and RDFa, covers all types and checks four levels:

 

  • Types: the @type exists in the vocabulary;
  • Properties: each field is permitted for that type and placed at the right level;
  • Values: expected formats (URL, number, text, date) are respected;
  • Structure: objects, lists and relationships between entities, for example from Product to Offer.

 

It catches modelling errors that Google's tool misses and that explain markup that is detected but unusable. The most common cases:

 

  • nested objects: an Offer should be a coherent object, not a flat list of fields;
  • lists: some fields accept several values (multiple images), others only one;
  • dates: non-standard formats or empty fields, particularly on Event;
  • currencies: a text value ("199,90 €") instead of a number in price and a currency code in priceCurrency.

 

Schema.org Validator: Good Practice for a Successful Schema.org Test

 

Four habits prevent most failures:

 

  • test even when nothing has changed: the vocabulary and Google's requirements evolve, and older markup can become incomplete;
  • test before going live, to avoid regressions on high-volume templates;
  • stay faithful to the content: no marked-up information that is not visible and accurate;
  • combine with the Rich Results Test: schema.org compliance first, eligibility second.

 

Google Search Console: Checking Structured Data at Site Scale

 

Search Console is a tool for tracking issues detected during crawling, across all pages. In Google Search Console, the "Enhancements" section provides one report per detected type (products, breadcrumbs, videos…). At the time of writing, the FAQ report only concerns authoritative government and health websites.

 

Understanding Statuses: Valid, Valid with Warnings, Invalid

 

Each URL in a report receives one of three statuses, which call for different actions:

 

StatusMeaningAction
ValidGoogle detects the markup and reports no blocking issuesMonitor; re-test after any template change
Valid with warningsPage eligible, but recommended properties are missingComplete them first on high-impact pages
InvalidBlocking error: the page cannot benefit from the rich resultFix the template, then start validation

 

URL Inspection: Checking the Indexed Version of a Page

 

URL Inspection complements the reports for a specific page: indexed version, detected rich results, any errors. The live test confirms that a fix is actually being served before you request reindexing.

 

Linking an Issue to Templates Rather Than Individual URLs

 

When Search Console flags hundreds of URLs, look for the root cause at template level: an empty CMS field, a rendering condition, a mis-versioned mapping rule. Once fixed, start validation in Search Console; the return of a rich result remains at Google's discretion.

 

Diagnosing and Fixing Structured Data Tag Errors

 

A diagnosis starts with the detected type: does it match the page's primary topic? The following table links common issues to their symptom and their fix:

 

IssueSymptom in the toolsFix
Wrong typeDetected type unrelated to the page, cascading errorsStart from the main topic and the visible information
Missing required propertyError, page not eligibleAdd the property at the correct level (offers within Product) from the source CMS field
Missing recommended propertyWarningComplete it on high-impact pages
Value in the wrong formatError or ignored valueRespect the expected type: number, currency code, standard date, URL
Contradictory duplicatesSeveral Product entities or diverging values on one pageA single markup source per page

 

Address blocking errors first, then warnings on the highest-impact pages: there is no point working on completeness when a blocker prevents any eligibility. Typical blockers: a missing date on an Event, incomplete contact details on a LocalBusiness.

 

Data That Does Not Match Visible Content: Risks and Best Practice

 

A critical rule: never declare information in structured data that is not present on the page (non-existent reviews, a different price, availability that is not shown). The mismatch loses eligibility; if it misleads users, Google can apply a manual action for spammy structured data, reported in Search Console.

 

Note also that reviews about your own organisation, even when visible, are not eligible for rich results.

 

Format Errors: Invalid JSON, Encoding, Quotation Marks, Commas and Units

 

Format errors are the easiest to fix:

 

  • invalid JSON: a missing or trailing comma, curly quotes, an unclosed brace;
  • incorrect encoding or escaping in text content (special characters);
  • mixed units: "199,90 €" instead of 199.90 and EUR;
  • text provided where a URL is expected, for example availability, which should point to a schema.org value.

 

The following snippet combines three of these errors: a missing comma after name, a price as text with the euro symbol, and availability as free text.

 

  • {
  •   "@context": "https://schema.org",
  •   "@type": "Product",
  •   "name": "Annual licence"
  •   "offers": {
  •     "@type": "Offer",
  •     "price": "199,90 €",
  •     "availability": "in stock"
  •   }
  • }

 

The corrected version adds the comma, separates the amount (with a decimal point) from the currency and uses the schema.org availability URL:

 

  • {
  •   "@context": "https://schema.org",
  •   "@type": "Product",
  •   "name": "Annual licence",
  •   "offers": {
  •     "@type": "Offer",
  •     "price": "199.90",
  •     "priceCurrency": "EUR",
  •     "availability": "https://schema.org/InStock"
  •   }
  • }

 

Markup Conflicts: Duplicate JSON-LD, Microdata and Multiple Tags

 

Conflicts arise when multiple sources generate competing markup: a template, a CMS plugin, a tag manager. The goal is not to add more markup but to deduplicate and keep a single source of truth per page.

 

If you still use Microdata (itemscope, itemtype, itemprop attributes) and add JSON-LD, ensure both describe exactly the same thing, and limit the overlap to the duration of the migration.

 

Validation Workflow: Test Before and After Going Live

 

Quick-Check Checklist for a Critical Page

 

Before considering a critical page validated, check these six points:

 

  • the primary type matches the page's main topic;
  • the markup is present in the rendered HTML of the final URL;
  • the Rich Results Test reports no blocking errors;
  • the Schema.org validator reports no structure or typing errors;
  • all marked-up values are visible (price, dates, reviews, contact details);
  • no competing block describes the same entity with contradictory values.

 

On a large site, test by sampling: high-traffic pages, main templates, representative variants (in-stock or out-of-stock product). Also document the mapping between CMS fields and schema.org properties: a warning can then be traced back to its cause quickly.

 

When to Re-Run a Test After a Template Update

 

Re-validate after any change that affects marked-up information or how it is rendered:

 

  • a front-end redesign or a change to the product, service or article template;
  • adding or modifying a reviews module;
  • a change to pricing or stock rules;
  • a CMS or domain migration, internationalisation;
  • automation that alters visible content.

 

What the Test Does Not Tell You: How Generative Engines Read Your Page

 

The Rich Results Test checks eligibility for Google rich results, not how AI systems read the page. Generative engine crawlers (GPTBot, ClaudeBot, PerplexityBot, Googlebot for AI Overviews) read the HTML, and therefore the markup: valid markup is as readable to them as to other systems. It supports accurate restitution, with no demonstrated direct effect on being cited.

 

This role is covered in detail in our article on structured data and generative engines.

 

Depending on Your Situation

 

Depending on your starting point, these resources complement this guide:

 

 

To detect markup errors across all your pages, not just the ones you test one by one, the Incremys 360 GEO/SEO Audit module, a GEO & SEO platform, groups faulty pages by template and tracks your AI presence by keyword.

 

FAQ: Testing, Tools and Interpreting Results

 

How Can You Test Your Structured Data Reliably?

 

Follow a three-step chain. First, validate compliance with the vocabulary using the Schema.org validator. Then test eligibility with the Rich Results Test, on a code snippet and then on the deployed URL. Finally, monitor the Enhancements reports in Search Console to catch regressions early, especially after template changes or releases.

 

How Do You Interpret an Error Versus a Warning in a Test?

 

An error is blocking: the page is not eligible for the targeted rich result, because of a missing required property, an inconsistent type or an invalid format. A warning signals a missing recommended property: the page remains eligible, but the display may be less complete. Fix errors first, then warnings on your strategic pages.

 

Why Might a Validated Page Still Not Show a Rich Result?

 

Because the test validates eligibility and interpretation, not the display decision. Google decides based on relevance, perceived quality and the context of the query. Some types also no longer produce rich results for most sites, such as HowTo, or FAQ outside authoritative government and health websites.

 

What Should You Do if Google Search Console Flags an Issue but the Rich Results Test Does Not?

 

Check three leads: does the issue concern a different type from the one tested? Is the tested URL exactly the one Google crawls (canonical, parameters)? Does the markup vary depending on rendering (A/B test, personalisation, injection)? Compare with URL Inspection, fix at template level, then start validation in Search Console.

 

Do You Need to Test Every Page or Just Templates?

 

On a large site, test templates and a sample of high-traffic pages, then let Search Console surface issues at site scale. Exhaustive testing is only justified on a small site or a tightly defined critical scope, for example your best-selling product pages.

 

Can You Test a Page That Is Not Yet Live?

 

Yes, in code snippet mode: the Rich Results Test and the Schema.org validator accept a JSON-LD block or an HTML snippet pasted directly. This mode lets you fix the syntax before deployment, without replacing the URL test after go-live, which alone shows what Google obtains from the actual rendering.

 

How Often Should You Re-Run a Rich Results Test?

 

After every change that affects marked-up information or how it is rendered: price, stock, dates, author, contact details, template, migration. Add a regular check of your main templates, even without changes, because the schema.org vocabulary and Google's requirements evolve. Between two tests, Search Console acts as your alert system.

 

Does Structured Data Help You Get Cited by Generative AI?

 

No direct effect on citations has been demonstrated at the time of writing. Generative engine crawlers read the HTML, and therefore the markup: valid markup helps these systems identify a page's entity, author, date and facts, and supports accurate restitution. The rest depends on the content, its structure and the consistency of information across sources.

Discover other items

See all

Next-Gen GEO/SEO starts here

Complete the form so we can contact you.

The new generation of SEO
is on!

Thank you for your request, we will get back to you as soon as possible.

Oops! Something went wrong while submitting the form.