Structured data for AI search: what helps and what is hype

Structured data helps AI search in one modest, real way: it states facts about your pages (who publishes them, what a product costs, when an article was updated) in a format machines can read without guessing. It is not a way into AI answers. Google says no special schema is needed for AI Overviews or AI Mode, and OpenAI, Anthropic and Perplexity don't mention structured data in their crawler documentation at all.

So the honest position is: add accurate JSON-LD for the handful of types that describe your site, make sure it matches what the page shows, and ignore anyone selling "AI schema". This guide covers what is documented, which types matter, and how to check your markup.

What structured data actually does

Structured data is a block of machine-readable statements about a page, written in the schema.org vocabulary. Google describes it as "a standardized format for providing information about a page and classifying the page content" in its introduction to structured data, and says it uses it to understand page content and to gather information about the world, such as people, books and companies.

The most common format is JSON-LD: a <script type="application/ld+json"> tag holding a JSON object. Google supports JSON-LD, Microdata and RDFa, says all three are equally fine when valid, and recommends JSON-LD where your setup allows it.

Here is the kind of fact JSON-LD makes explicit. A human reading your About page can work out that "Acme" and "Acme Analytics Ltd" are the same company and that the logo in the header is its logo. JSON-LD says so directly:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://www.example.com/#organization",
      "name": "Acme Analytics",
      "legalName": "Acme Analytics Ltd",
      "url": "https://www.example.com/",
      "logo": "https://www.example.com/images/logo.png",
      "sameAs": [
        "https://www.linkedin.com/company/acme-analytics",
        "https://github.com/acme-analytics"
      ]
    },
    {
      "@type": "WebSite",
      "@id": "https://www.example.com/#website",
      "name": "Acme Analytics",
      "url": "https://www.example.com/",
      "publisher": { "@id": "https://www.example.com/#organization" }
    }
  ]
}
</script>

The @id values let other markup on the site point back to the same organization, so every article and product page can say "published by this entity" without repeating the details.

What search engines and AI operators document

This is where most of the hype falls apart. Here is what the operators say, at the time of writing:

There is no "AI schema". None of these operators has published a schema.org type, property or format that it requires for AI answers. If a plugin or agency offers special markup "for ChatGPT", ask which operator documents it and where.

That does not make structured data useless for AI search. It means its value comes from the ordinary things it does: Google's systems use it, it is part of the HTML any crawler downloads, and it removes ambiguity about entities. Whether a given AI system parses JSON-LD from the pages it fetches is not documented by OpenAI, Anthropic or Perplexity, so don't rely on markup to carry facts that aren't also in the visible text. For the wider picture of what Google requires, see Google AI Overviews: the technical requirements.

Which structured data types matter for most sites

You do not need dozens of types. Six cover most sites. The Google requirements below come from each type's Search Central page and apply to Google's rich results; schema.org itself makes nothing mandatory.

Google says you don't need Organization on every page: the home page or a single page about the organization is enough. WebSite must be on the home page of the domain or subdomain.

Each type has its own details and pitfalls. We cover them in Organization schema, Product schema and Article and BlogPosting schema.

Types that no longer do much

Some markup still circulates in templates long after the feature behind it went away. Google removed its HowTo documentation in September 2023 because the rich result was no longer shown. FAQ rich results were limited to authoritative government and health sites in August 2023, and Google's changelog says they stopped appearing in Search from May 7, 2026, with the documentation removed on June 15, 2026. FAQPage markup is still valid schema.org, but don't expect a Google feature from it.

Why structured data must match the visible page

Google's general structured data guidelines are blunt: "Your structured data must be a true representation of the page content", and "Don't mark up content that is not visible to readers of the page." Breaking those rules can lead to a manual action, under which a page loses eligibility to appear as a rich result.

Mismatches are rarely deliberate. They come from markup generated in one place and content edited in another:

• The product JSON-LD says "price": "49.00" from an old feed, while the page shows a sale price of 39.00.
• The Organization name is a legal entity that appears nowhere on the site.
• dateModified updates on every deploy, although the article text hasn't changed.
• A theme outputs LocalBusiness with a placeholder address the owner never replaced.
• An aggregateRating is marked up on a page that shows no reviews.

For AI search the risk is the same as for Google: two different answers to one question on the same page. A system that reads the markup and one that reads the text would come away with different facts. Keep the visible text as the source of truth and generate JSON-LD from the same data, never maintained by hand in a separate field.

Google makes a related point about JSON-LD generated with JavaScript: duplicating page data in Google Tag Manager "increases the risk of having a mismatch between page content and the structured data", so pull values from the page instead.

Put JSON-LD in the server HTML, not only in JavaScript

Google can read structured data that exists in the DOM after rendering. Many AI crawlers don't render. Vercel's analysis with MERJ, published in December 2024, found that the major AI crawlers it measured, including OpenAI's crawlers, ClaudeBot and PerplexityBot, did not execute JavaScript at the time. JSON-LD injected by a tag manager or a client-side component would not exist for them.

Google also warns that dynamically generated markup can make Shopping crawls less frequent and less reliable, which matters for prices and stock. The safe default is to render JSON-LD on the server, in the initial HTML response. If you are unsure how your stack behaves, read Do AI crawlers run JavaScript?.

How to test your structured data

Use three checks: one for Google features, one for schema.org validity, and one for what a non-rendering crawler receives.

1. Google's Rich Results Test

The Rich Results Test shows which Google rich results a page is eligible for and lists errors and warnings per item. Test the live URL rather than pasted code: Google recommends URL input because code input has JavaScript limitations. After launch, the URL Inspection tool and the rich result reports in Search Console confirm what Google found.

2. The Schema Markup Validator

The Schema Markup Validator checks markup against the full schema.org vocabulary, without Google-specific rules. It replaced Google's old Structured Data Testing Tool in 2021. Use it for types and properties that Google's tool doesn't check, and as a second opinion on syntax.

3. Check the raw HTML

Neither tool tells you whether the markup is in the HTML before JavaScript runs. Fetch the page the way a non-rendering crawler would and parse every JSON-LD block:

curl -s -o page.html -w "HTTP %{http_code}\n" \
  -A "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.4; +https://openai.com/gptbot" \
  https://www.example.com/

python3 - page.html <<'EOF'
import json, re, sys
html = open(sys.argv[1], encoding="utf-8", errors="replace").read()
blocks = re.findall(r'<script[^>]*application/ld\+json[^>]*>(.*?)</script>', html, re.S | re.I)
print(f"{len(blocks)} JSON-LD block(s) in the raw HTML")
for i, block in enumerate(blocks, 1):
    try:
        data = json.loads(block)
    except json.JSONDecodeError as error:
        print(i, "invalid JSON:", error)
        continue
    items = data.get("@graph", [data]) if isinstance(data, dict) else data
    print(i, "ok:", [item.get("@type") if isinstance(item, dict) else item for item in items])
EOF

Check the status line first: a 403 or a challenge page means the crawler is blocked before markup matters. With a 200, zero blocks here while the Rich Results Test finds markup means the JSON-LD is added by JavaScript. "Invalid JSON" usually points to a trailing comma, an unescaped quote in a product name, or two objects pasted into one script tag. Common JSON-LD errors walks through the usual fixes.

Then compare the values with the page: name, price, currency, address, author and dates. Neither validator does this comparison for you, and Crawlito's checks do not either. They cover whether JSON-LD parses and whether documented required fields are present, such as a name on Organization and Product, or a name and address on LocalBusiness.

What to do, in order

1. Add Organization and WebSite JSON-LD to the home page, linked with @id.
2. Add Article or BlogPosting to articles, Product to product pages, LocalBusiness to location pages and BreadcrumbList where you show breadcrumbs.
3. Generate every value from the same data the page displays.
4. Render the JSON-LD on the server, then confirm it with the curl check above.
5. Validate with the Rich Results Test and the Schema Markup Validator.
6. Remove markup for things the page doesn't show, including leftover HowTo or placeholder business details.

None of this makes a page more likely to be cited by a particular assistant. It makes your facts unambiguous and consistent, which is the part you control.

Frequently asked questions

Do I need special schema for ChatGPT or Perplexity?

No. Neither OpenAI's nor Perplexity's crawler documentation mentions structured data, and neither documents a schema type or property for AI answers. Standard schema.org markup is all there is.

Does structured data help with Google AI Overviews?

Google says structured data isn't required for its generative AI features and no special schema.org markup is needed. It still recommends structured data as part of normal SEO because it supports rich results.

Is JSON-LD better than Microdata or RDFa?

Google says all three formats are equally fine when valid and recommends JSON-LD where your setup allows. JSON-LD is easier to generate and keep separate from your templates, which is why most sites use it.

Can structured data hurt my site?

Markup that misrepresents the page or marks up hidden content breaks Google's guidelines and can lead to a manual action, which removes rich result eligibility for affected pages. Accurate markup that matches the visible content carries no such risk.

Should structured data be on every page?

Only where it describes the page. Organization and WebSite belong on the home page, and type-specific markup such as Product or Article belongs on the pages it describes.

Check your own pages

Run the free check on your home page or a product page to see what a crawler receives without JavaScript, including its headings and structured data. It checks one page and needs no account.