# Structured Data Testing for AI

> How to test structured data when AI visibility is the goal: Rich Results Test, Schema Markup Validator, URL Inspection, rendered HTML and a QA routine.

Source: https://mentionx.ai/learn/technical/structured-data-testing-ai  
Author: Dipuck Jones, founder of MentionX  
Updated: 30 October 2026  
Level: Practitioner

**Test structured data with three tools: Google's Rich Results Test for Google features, the Schema.org Markup Validator for general schema.org correctness, and Search Console's URL Inspection to see what Googlebot actually rendered ([Google](https://search.google.com/test/rich-results), [Schema.org](https://validator.schema.org/), [Google](https://support.google.com/webmasters/answer/9012289)).** There is no AI-specific test, and Google says no special schema is needed for its AI features ([Google](https://developers.google.com/search/docs/appearance/ai-features)).

*Facts are from Google Search Central and Schema.org, accessed 30 Oct 2026. Points marked "Our view" are interpretation.*

> **Key takeaways**
>
> - Use the Rich Results Test for Google eligibility and the Schema Markup Validator for general schema.org validity.
> - Check both raw and rendered HTML, because some crawlers don't run JavaScript.
> - Markup must follow Google's policies: match visible content and use the right types.
> - Build a QA routine that tests templates before launch and monitors Search Console after.

*Checked on 31 October 2026. "Our view" marks MentionX opinion. Ledgerline is a fictional company used for illustration.*

## Which tool answers which question?

| Question | Tool |
|---|---|
| Is it eligible for a Google rich result? | [Rich Results Test](https://search.google.com/test/rich-results) |
| Is the schema.org syntax and vocabulary valid? | [Schema Markup Validator](https://validator.schema.org/) |
| Did Googlebot see the markup after rendering? | [URL Inspection](https://support.google.com/webmasters/answer/9012289) |
| Are there errors across the site? | Search Console rich result reports |
| Does markup match the page? | Manual review |

*Our view:* the Schema Markup Validator matters for GEO because many useful types, such as `sameAs` on Organization or `DefinedTerm`, aren't Google rich results, so the Rich Results Test won't evaluate them.

## How do you test a page step by step?

1. **Fetch the raw HTML** and confirm the JSON-LD is there:

```bash
curl -s https://www.example.com/page | grep -c 'application/ld+json'
```

2. **Run the Schema Markup Validator** on the URL. Fix syntax errors and unknown properties.
3. **Run the Rich Results Test** if the type is a Google feature (Product, Article, Organization and so on). Fix errors, then review warnings.
4. **Use URL Inspection** on live pages to check the rendered HTML and detected structured data.
5. **Compare to visible text:** names, prices, ratings, dates and authors must match what users see.

## Why check raw HTML as well as rendered?

Vercel and MERJ found that major AI crawlers they studied didn't execute JavaScript ([Vercel](https://vercel.com/blog/the-rise-of-the-ai-crawler)). *Our view:* if your JSON-LD is injected by a tag manager or client-side script, Google may see it after rendering while AI crawlers don't. Put markup in server-rendered HTML.

## What do Google's policies require?

From Google's structured data guidelines ([Google](https://developers.google.com/search/docs/appearance/structured-data/sd-policies)) and AI features guidance ([Google](https://developers.google.com/search/docs/appearance/ai-features)):

- Markup must represent the main content of the page.
- Don't mark up content that's hidden from users.
- Structured data should match visible text.
- Violations can make a page ineligible for rich results.

## How do you test before a page is live?

Both the Rich Results Test and the Schema Markup Validator accept a code snippet as well as a URL ([Google](https://search.google.com/test/rich-results), [Schema.org](https://validator.schema.org/)). *Our view:* paste the rendered template output from staging into the code input, so errors are caught before release. Don't rely on the URL option for staging sites behind authentication, because the tools can't reach them. After launch, re-test with the live URL, since CDN caching, plugins and consent scripts can change the final HTML.

## What should a QA routine look like?

*Our view:*

| When | Check |
|---|---|
| Before release | Validator and Rich Results Test on templates in staging (use code input) |
| After release | URL Inspection on one URL per template |
| Weekly | Search Console rich result reports for new errors |
| Monthly | Manual match check on 10 priority pages |
| After CMS or theme updates | Raw HTML check for missing JSON-LD |

Test per template, not per page: if the product template is right, all products usually are, but check edge cases such as out-of-stock items or missing ratings.

## What errors are most common?

| Error | Cause | Fix |
|---|---|---|
| Missing required field | Template doesn't output it | Add field or remove the type |
| Price mismatch | Markup cached, page updated | Generate both from one source |
| Duplicate Organization blocks | Plugin plus theme | Keep one, link with `@id` |
| Review markup on own products from self | Policy issue ([Google](https://developers.google.com/search/docs/appearance/structured-data/review-snippet)) | Use genuine reviews only |
| JSON-LD only after JS | Tag manager injection | Server-render |
| Invalid date format | Non-ISO dates | Use ISO 8601 |

## Can you test how AI uses your markup?

Not directly. *Our view:* the best proxy is to check whether AI answers state facts that live in your markup correctly, such as price, founder or release date. Keep a fixed prompt set, run it monthly, and log errors. If an assistant gets a fact wrong, check that the visible text and markup agree, then look at third-party sources it may be citing instead.

## How do you link entities across markup?

*Our view:* give your Organization a stable `@id` (for example `https://www.example.com/#org`) and reference it from Article `publisher` and Product `brand` instead of repeating the details. The Schema Markup Validator shows the resolved graph, which makes inconsistencies easy to spot. See [Organization schema](https://mentionx.ai/learn/technical/organization-schema-brand-entities).

## Exercise

Pick one template each for articles, products and your home page. Run all three tools, log every error and warning, fix the errors, and compare raw versus rendered HTML for JSON-LD presence.

## Checklist

- JSON-LD in raw HTML
- Validator clean
- Rich Results Test clean for Google types
- URL Inspection confirms rendered markup
- Markup matches visible text
- Weekly Search Console check

## From MentionX data: which pages engines cite

**Method.** Read-only aggregate queries over MentionX scans from 22 August to 29 October 2026 (UTC): 2,217 engine runs (2,154 completed) across 18 anonymised projects and six engines.

Structured data testing protects the pages engines cite. In the MentionX sample, those pages span several types:

| Cited URL type | Share of 9,750 citations |
| --- | --- |
| Blog or article | 19.6% |
| Homepage | 10.0% |
| Review page | 2.7% |
| Docs | 2.6% |
| Pricing | 1.9% |
| Wikipedia | 1.6% |

Engines also differ in how often they cite anything:

| Engine | Brand mentioned | Answers with no citations |
| --- | --- | --- |
| Gemini | 47.3% | 50.7% |
| OpenAI | 42.9% | 30.2% |
| Perplexity | 31.5% | 4.1% |
| AI Mode | 31.3% | 12.6% |
| Copilot | 26.0% | 47.0% |
| DeepSeek | 24.0% | 99.0% |

*Our view:* no public test shows how an AI engine uses your markup. What you can test is whether the markup is valid, matches the page and is visible to crawlers that don't run JavaScript.

**Limits.** A convenience sample of mostly B2B software projects, run through engine APIs, which can behave differently from the consumer apps. Perplexity, Copilot and DeepSeek figures come from a single day (26 October 2026), so treat them as a snapshot, not a trend.

## Worked example: Ledgerline adds markup testing to its release checklist

*Ledgerline is a fictional accounts-payable tool. Figures are illustrative.*

After a redesign, Ledgerline's article pages lose their Article markup without anyone noticing for weeks. The team adds structured data checks to its release process.

Before each release, a developer tests one page per template in the Rich Results Test and the Schema Markup Validator, and compares the raw HTML with the rendered HTML to confirm the JSON-LD is present in both. After release, the SEO lead checks Search Console's enhancement reports weekly for new errors.

The team also keeps a sheet of each template, the markup types it should carry and the properties it uses, so any change to a template triggers a re-test.

> **Pro move:** Test one URL per template, not every page. Markup is almost always generated by templates, so a template-level test catches nearly every problem.

## How do you choose which pages to test?

List each template on your site, such as articles, product pages, pricing and author pages. Pick one representative URL for each, plus any pages with unusual content. Test those after every template change. *Our view:* a short list tested often beats a full crawl tested rarely.

## How do you read test results?

Errors usually mean a required property is missing or invalid, and they can make a page ineligible for a rich result. Warnings usually mean a recommended property is missing. Fix errors first. Check that the detected items are the ones you expected, because a page may carry markup you didn't know about from a plugin or tag manager.

## How do you handle markup from plugins?

Content management plugins often add markup automatically. Check what they output, and remove duplicates when two plugins mark up the same item. Keep one source for each markup type so changes are predictable.

## How do you monitor markup after launch?

Search Console's enhancement reports show errors by type over time. Set a regular review and investigate any sudden change. Crawl the site periodically with a tool that extracts structured data, so you can spot pages that lost their markup.

## How do you compare raw and rendered HTML?

View the page source to see the raw HTML the server sends, and use the URL Inspection tool in Search Console or the Rich Results Test to see the rendered HTML. Check that the JSON-LD block appears in both. If it only appears after rendering, crawlers that don't run JavaScript won't see it. *Our view:* serve markup in the raw HTML wherever you can.

## How do you check markup matches the page?

Compare each marked-up value with what readers see, such as the headline, author, dates, prices and ratings. Values that don't appear on the page, or that differ, break Google's guidelines. Automate this check where possible by generating markup from the same data as the visible content.

## How do you handle staging sites?

Test markup on staging with code snippets before release. Make sure staging is blocked from indexing, but don't copy that block to production. Check robots.txt and noindex tags after each release.

## What should a markup inventory include?

List each template, the markup types it uses, the properties and where the values come from. Note the owner of each template. Update the inventory when templates change, and use it to plan tests.

## How do you prioritise fixes?

Fix errors on templates that cover the most pages first, then errors on high-value pages such as pricing and product pages. Leave warnings for optional properties until errors are fixed.

## How do you test entity links?

Where markup references other items, such as an author or an organisation, check that the ids and urls are consistent across pages. The same organisation should use the same name, url and logo everywhere. *Our view:* consistent entity references make it easier for engines to connect your pages to the right brand.

## Who should own structured data?

Give one person responsibility for the markup inventory and the QA routine, usually an SEO lead or developer. Make sure template changes go through them, or at least trigger a test.

## How do you document fixes?

Record each error found, the cause, the fix and the date. Over time, the log shows which templates cause the most problems and where testing should focus.

## How do you test markup in bulk?

Use a site crawler that extracts JSON-LD to check every page of a template, not just one sample. Export the results and look for missing properties, empty values and pages without markup. Compare the counts with the number of pages in each section. *Our view:* a monthly bulk check catches problems that single-page tests miss, such as markup dropped from older pages.

## How do you report on markup health?

Share a short monthly summary with the number of errors by template, what was fixed and what's outstanding. Keep it simple so developers and content teams can act on it.

## Common questions

**Which tool should we use first?** The Rich Results Test for Google features, then the Schema Markup Validator for general validity.

**Does valid markup guarantee a rich result?** No. Google decides whether to show rich results, even for valid markup.

**Can we test pages before they're live?** Yes. Both tools accept code snippets, so you can test staging HTML.

## Related

- Technical GEO audit checklist
- [Wikidata for brands](https://mentionx.ai/learn/technical/wikidata-brands)

## Sources

- Google, [Rich Results Test](https://search.google.com/test/rich-results); [URL Inspection](https://support.google.com/webmasters/answer/9012289); [structured data policies](https://developers.google.com/search/docs/appearance/structured-data/sd-policies); [AI features](https://developers.google.com/search/docs/appearance/ai-features); [review snippet](https://developers.google.com/search/docs/appearance/structured-data/review-snippet)
- Schema.org, [Schema Markup Validator](https://validator.schema.org/)
- Vercel, [The rise of the AI crawler](https://vercel.com/blog/the-rise-of-the-ai-crawler)
All accessed 30 Oct 2026.

## Frequently asked questions

### Is there a structured data test for AI Overviews or ChatGPT?

No dedicated one. Google says no special schema is needed for its AI features. Test with the Rich Results Test, the Schema Markup Validator and URL Inspection.

### What's the difference between the Rich Results Test and the Schema Markup Validator?

The Rich Results Test checks markup against Google's supported rich result features. The Schema Markup Validator checks schema.org markup generally, including types Google doesn't use.

### Why does markup pass the test but not show in AI answers?

Valid markup is not a guarantee of any feature. Our view: it must also match visible content and the page must be crawlable and indexed.

---

Written and reviewed by Dipuck Jones for MentionX Learn. The HTML version of this page: https://mentionx.ai/learn/technical/structured-data-testing-ai