Schema Markup for AI Search: Get Cited Accurately (2026)

Schema markup for AI search: what engines can use from JSON-LD, which types help cut wrong facts about your brand, and how to keep markup matching your content.

· BugViso Team

16 min read

Schema markup for AI search is JSON-LD that states your facts (price, author, organization, dates) as typed values, so a machine can read them without guessing from prose. No engine has published that it requires schema, and Google says outright that AI Overviews need "no special schema.org structured data". Treat it as a clarity layer that must match the visible page, not a citation switch.

The accuracy part is where schema earns its keep, and where it backfires. Our own AI brand accuracy audit traced one wrong price an engine quoted to old prices we'd left in our own FAQ structured data.

By the end you'll know which types and properties state the facts AI answers quote, have templates for a SaaS site and an article, and have a script that checks your JSON-LD against the visible text. New to schema? Start with schema markup for beginners.

Google documents how it uses structured data; ChatGPT, Perplexity and Claude haven't published whether they read it at all. Separate the confirmed from the plausible before you spend time on markup.

SourceWhat it says
Google, AI features and your website"There's also no special schema.org structured data that you need to add" to appear in AI Overviews or AI Mode
Google, structured data guidelinesJSON-LD is the recommended format; "Don't mark up content that is not visible to readers of the page"
OpenAI, Anthropic, PerplexityCrawler documentation covers access, not structured data

So the case for schema in AI search is indirect. It helps Google understand a page in the index those features draw on, and it gives any parser that does read it a typed copy of your key facts.

Why stated facts get misquoted

Answer engines retrieve passages, not whole pages, under latency and context limits. A typical retrieval pipeline (a general model, not any one engine's confirmed design) fetches candidate pages, splits them into chunks, picks the most relevant, and writes an answer from those chunks.

Chunking is where context breaks:

  • A price in a pricing card gets separated from its currency or billing period.
  • A feature in a bullet list loses the product name it belongs to.
  • An author's credentials in a sidebar end up in a different chunk from the article.

The model then infers how the fragments connect, and that's where wrong facts come from. The main fix is visible text that states each fact in a full sentence. JSON-LD that mirrors it adds a second, typed statement of the same facts that doesn't depend on layout.

Which Schema Types State the Facts AI Answers Quote

Prioritise the types that carry facts people ask about: what you sell, what it costs, who wrote it, and when. Nobody outside the engines has published a measured "extraction rate" per type, so this order follows what each type states explicitly.

  1. Organization and Person: who you are, with sameAs links to known profiles (Wikidata, LinkedIn, GitHub) that tie the entity to one identity.
  2. SoftwareApplication or Product with Offer: what it is, what it costs, which platforms it runs on.
  3. Article or TechArticle: author, publisher, and ISO 8601 datePublished and dateModified.
  4. FAQPage: explicit question and answer pairs. Google stopped showing FAQ rich results on May 7, 2026, so it earns no rich result; see FAQPage schema in 2026.
  5. HowTo: numbered steps. Google no longer shows HowTo rich results either, but the markup still states the steps unambiguously.

For each fact, know which property states it, which one tends to go wrong, and what it must match on the page:

Fact an engine might quoteProperty that states itEasy to get wrongMust match on the page
Priceoffers.price, priceCurrencyA price left in old FAQ markupThe visible price
Product capabilitiesfeatureList, operatingSystemsoftwareRequirements left vagueThe feature list in the text
Authorauthor.name, author.sameAsAn author object with no profile linkThe byline and author page
CompanyOrganization.name, url, sameAsfounder names that appear nowhere on the pageThe footer and About page
DatesdatePublished, dateModifiedA dateModified your CMS bumps on every deployThe visible dates
AnswersacceptedAnswer.textsuggestedAnswer, which marks an answer as not acceptedThe FAQ text

Check the rest of your markup against the 15-step schema validation checklist; several underused schema types, such as SoftwareApplication and Course, fit sites that skip them.

4 Rules for Schema That Reads Unambiguously

Connected, accurate markup beats more markup. A malformed block can't be read at all, and a contradictory one is worse than none.

Rule 1: Connect entities in one @graph with @id

Several separate <script type="application/ld+json"> tags (one for breadcrumbs, one for the article, one for the organization) leave a parser to guess how they relate. One @graph whose nodes reference each other by @id states the relationships:

html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "TechFlow Systems",
      "url": "https://example.com/",
      "logo": "https://example.com/assets/logo.png"
    },
    {
      "@type": "WebSite",
      "@id": "https://example.com/#website",
      "url": "https://example.com/",
      "name": "TechFlow",
      "publisher": { "@id": "https://example.com/#organization" }
    },
    {
      "@type": "TechArticle",
      "@id": "https://example.com/blog/latency-optimization#article",
      "isPartOf": { "@id": "https://example.com/#website" },
      "headline": "Zero-Copy Memory Techniques in High-Throughput Microservices",
      "author": { "@id": "https://example.com/authors/sarah-chen#person" }
    },
    {
      "@type": "Person",
      "@id": "https://example.com/authors/sarah-chen#person",
      "name": "Sarah Chen",
      "jobTitle": "Principal Infrastructure Engineer",
      "worksFor": { "@id": "https://example.com/#organization" },
      "sameAs": ["https://github.com/sarahchen", "https://www.linkedin.com/in/sarahchen"]
    }
  ]
}
</script>

Use the same @id for the organization on every page, so every article points at one entity rather than a new anonymous one each time.

Rule 2: Tie topics and people to known entities

sameAs on a Person or Organization links it to profiles that already identify it. For topics, about and mentions with a sameAs to Wikipedia or Wikidata resolve ambiguous terms:

json
"about": [
  {
    "@type": "Thing",
    "name": "Core Web Vitals",
    "sameAs": "https://en.wikipedia.org/wiki/Core_Web_Vitals"
  }
]

Link only to profiles that really are the same entity. A sameAs to the wrong Wikidata item merges you with someone else.

Rule 3: Use typed values, not phrases

A price written as a sentence inside a property is still prose to a parser. Put numbers in numeric properties and words in the visible text:

json
// ❌ A phrase where a value belongs
"price": "Free for developers, then starts around $5/mo"

// ✅ Typed values; the explanation goes in the visible text
"offers": {
  "@type": "AggregateOffer",
  "lowPrice": "0.00",
  "highPrice": "49.00",
  "priceCurrency": "USD",
  "offerCount": "3"
}

Use ISO 8601 for dates (2026-11-09T00:00:00Z) and ISO 4217 for currencies (USD, never $). Google's Product structured data documentation asks for the three-letter ISO 4217 code, so a symbol isn't a valid value.

Rule 4: Mark up only what the page shows

Google's guidelines say "Don't mark up content that is not visible to readers of the page", and that reviews or ratings not by real users may lead to a manual action, which removes rich result eligibility. For AI accuracy the risk is simpler: when markup and text disagree, a reader of either gets a different answer. Render the visible text and the JSON-LD from one data source so they can't drift.

JSON-LD Templates for a SaaS Site and an Article

Replace every placeholder with real values, and keep each one identical in meaning to the visible page.

Template A: Organization and software product

json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "DevMetrics Cloud",
      "url": "https://example.com",
      "logo": "https://example.com/images/logo.png",
      "sameAs": ["https://github.com/devmetrics-cloud", "https://www.linkedin.com/company/devmetrics"]
    },
    {
      "@type": "SoftwareApplication",
      "@id": "https://example.com/#software",
      "name": "DevMetrics Engine",
      "applicationCategory": "DeveloperApplication",
      "operatingSystem": "Web",
      "publisher": { "@id": "https://example.com/#organization" },
      "offers": {
        "@type": "Offer",
        "price": "29.00",
        "priceCurrency": "USD",
        "description": "Team plan, billed monthly, up to 10 seats"
      },
      "featureList": [
        "Error tracking for JavaScript and Python",
        "Release health per deploy",
        "Alerts by email"
      ]
    }
  ]
}

Add aggregateRating only when the page shows the same rating from real reviews. A rating in markup that the page doesn't show breaks Rule 4.

Template B: Article with author and dates

json
{
  "@context": "https://schema.org",
  "@type": "TechArticle",
  "@id": "https://example.com/blog/fix-cls#article",
  "headline": "How to Eliminate Layout Shifts Caused by Web Fonts",
  "datePublished": "2026-08-15T08:00:00Z",
  "dateModified": "2026-09-20T14:30:00Z",
  "inLanguage": "en-US",
  "mainEntityOfPage": "https://example.com/blog/fix-cls",
  "author": {
    "@type": "Person",
    "name": "Marcus Vance",
    "jobTitle": "Web Performance Engineer",
    "url": "https://example.com/authors/marcus-vance",
    "sameAs": ["https://github.com/marcusvance"]
  },
  "publisher": { "@id": "https://example.com/#organization" }
}

Add a FAQPage node only if the page has a visible FAQ and you accept that it earns no Google rich result.

Generate it from data in Next.js

Hand-written JSON-LD drifts from the page. Build it from the same props that render the visible text, in one server-rendered @graph:

typescript
// components/ArticleSchema.tsx: server component; markup comes from the same data as the page
interface ArticleSchemaProps {
  url: string;
  headline: string;
  datePublished: string;
  dateModified: string;
  author: { name: string; url: string; sameAs?: string[] };
}

export default function ArticleSchema({ url, headline, datePublished, dateModified, author }: ArticleSchemaProps) {
  const graph = {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "TechArticle",
        "@id": `${url}#article`,
        headline,
        datePublished,
        dateModified,
        mainEntityOfPage: url,
        author: { "@type": "Person", name: author.name, url: author.url, sameAs: author.sameAs ?? [] },
        publisher: { "@id": "https://example.com/#organization" },
      },
    ],
  };
  // Escape "<" so a title containing "</script>" can't break out of the tag.
  const json = JSON.stringify(graph).replace(/</g, "\\u003c");
  return <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: json }} />;
}

The full pipeline from a headless CMS is in automating JSON-LD in Next.js.

Check Your JSON-LD Against the Visible Page

Validators check syntax and required properties; they don't check whether the markup tells the truth. This script does the second job. It reads the raw HTML (what a non-rendering crawler gets), parses every JSON-LD block, and checks that names, headlines, prices, dates and ratings in the markup also appear in the visible text. Standard library only.

python
#!/usr/bin/env python3
"""schema_vs_page.py: does the JSON-LD on a page say the same thing as the visible text?

Usage: python3 schema_vs_page.py https://example.com/pricing [more URLs...]
Reads the raw HTML (what a non-rendering crawler gets), parses every JSON-LD
block, flags syntax errors and unresolved @id references, then checks that the
facts an AI answer would quote (names, prices, dates, authors, ratings) also
appear in the visible text. Exit code 1 on a parse error or a mismatch.
"""
import json, re, ssl, sys, urllib.request
from datetime import date
from html import unescape

UA = "Mozilla/5.0 (compatible; schema-vs-page/1.0)"
FACTS = ["name", "headline", "price", "lowPrice", "highPrice",
         "datePublished", "dateModified", "ratingValue", "reviewCount"]

def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": UA})
    with urllib.request.urlopen(req, timeout=20, context=ssl.create_default_context()) as r:
        return r.read(5_000_000).decode("utf-8", "replace")

def visible_text(html):
    body = re.sub(r"(?is)<(script|style|noscript|template|svg)\b.*?</\1>", " ", html)
    return re.sub(r"\s+", " ", unescape(re.sub(r"<[^>]+>", " ", body)))

def nodes(data):
    """Yield every dict in the JSON-LD tree, so nested offers and authors are checked too."""
    if isinstance(data, dict):
        yield data
        for v in data.values():
            yield from nodes(v)
    elif isinstance(data, list):
        for v in data:
            yield from nodes(v)

def date_forms(value):
    try:
        d = date.fromisoformat(str(value)[:10])
    except ValueError:
        return [str(value)]
    return [d.isoformat(), f"{d:%B} {d.day}, {d.year}", f"{d.day} {d:%B} {d.year}",
            f"{d:%b} {d.day}, {d.year}", f"{d.day} {d:%b} {d.year}"]

def on_page(key, value, text):
    value = str(value).strip()
    if key in ("datePublished", "dateModified"):
        return any(f.lower() in text.lower() for f in date_forms(value))
    if key in ("price", "lowPrice", "highPrice"):
        n = value.rstrip("0").rstrip(".") if "." in value else value
        return re.search(rf"(?<![\d.]){re.escape(n)}(?:\.0+)?(?![\d])", text) is not None
    return value.lower() in text.lower()

def check(url):
    html = fetch(url)
    text = visible_text(html)
    blocks = re.findall(r'(?is)<script[^>]+type=["\']application/ld\+json["\'][^>]*>(.*?)</script>', html)
    print(f"\n{url}\n  {len(blocks)} JSON-LD block(s) in the raw HTML")
    bad, ids, refs = False, set(), set()
    for i, raw in enumerate(blocks, 1):
        try:
            data = json.loads(raw)
        except json.JSONDecodeError as e:
            print(f"  ✗ block {i}: invalid JSON ({e.msg}, line {e.lineno})")
            bad = True
            continue
        for node in nodes(data):
            if "@id" in node and len(node) > 1:
                ids.add(node["@id"])
            elif "@id" in node:
                refs.add(node["@id"])
            kind = node.get("@type", "?")
            cur = node.get("priceCurrency")
            if cur is not None and not re.fullmatch(r"[A-Z]{3}", str(cur)):
                print(f"  ✗ {kind}.priceCurrency = {cur!r}: use an ISO 4217 code such as USD")
                bad = True
            for key in FACTS:
                val = node.get(key)
                if isinstance(val, (str, int, float)) and str(val).strip():
                    if key == "name" and kind in ("ListItem", "Thing", "ImageObject"):
                        continue
                    ok = on_page(key, val, text)
                    bad |= not ok
                    print(f"  {'✓' if ok else '✗'} {kind}.{key} = {str(val)[:60]!r}{'' if ok else '  NOT in visible text'}")
    for ref in sorted(refs - ids):
        print(f"  · @id reference {ref!r} has no matching node on this page")
    if not blocks:
        print("  · no JSON-LD in the server response (added by JavaScript, or missing)")
    return bad

if __name__ == "__main__":
    if len(sys.argv) < 2:
        sys.exit(__doc__)
    sys.exit(1 if any([check(u) for u in sys.argv[1:]]) else 0)

We ran it on our own pricing page on 9 November 2026. The product name, the $1.49 offer price, the page name and all eight FAQ questions matched the visible text. Two Person names nested in our Organization markup didn't appear anywhere on the page, which is exactly the kind of invisible markup Rule 4 warns about.

Treat a ✗ as a question, not a verdict. A date shown as "9/11/2026" won't match, and a name can legitimately live on another page. A price or rating that's missing from the page, though, is a real mismatch.

Quick checks from the command line

bash
# Is the JSON-LD in the server response, or added later by JavaScript?
curl -sL https://example.com/pricing | grep -c 'application/ld+json'

0 on a page that shows markup in your browser's dev tools means it's injected client-side, and a crawler that doesn't run JavaScript never sees it. Render it on the server or at build time. Then validate the syntax: no trailing commas, absolute https:// URLs, escaped quotes inside strings. When Search Console reports parse errors, see fixing unparsable structured data.

How BugViso Validates Schema and GEO Citability

A BugViso scan extracts the JSON-LD on every crawled page and validates it against the required and recommended properties for each Schema.org type (Organization, Product, SoftwareApplication, Article, FAQPage, BreadcrumbList and more). It flags missing required attributes, such as offers on a Product or price on an Offer, and checks canonical URLs against the live target, preventing the conflicts in our canonical tag guide.

The same scan runs the AI Search Readiness checks: a RAG chunk simulator that shows how answer-ready each passage is, E-E-A-T signals such as author and date, and a 0–100 GEO citability score built from crawler access, extractability and indexability, in the report and the PDF.

BugViso doesn't compare schema values with the rendered text, so run the script above for that. More on the structured data checks is on the technical SEO audit page.

4 Implementation Mistakes That Produce Wrong Facts

1. Prices fetched on the client, with no price in the markup

When a pricing table loads from an API in the browser, the server HTML often carries an empty price or a placeholder, and JSON-LD filled in by useEffect arrives too late for a non-rendering crawler. Render prices and their markup on the server or at build time.

2. Markup copied from an old version of the page

Prices, plan names and FAQ answers change; markup copied by hand doesn't. That's how our own stale FAQ prices ended up in an AI answer. Generate every copy from one source.

3. Schema types that don't match the page

Recipe or Event on a SaaS landing page to chase rich results breaks Google's policies and confuses anything reading the page. Use the type that matches the primary intent: SoftwareApplication for software, Service for agencies, Article or TechArticle for content. Which rich results still show is covered in do rich snippets increase clicks?; multi-location businesses should read LocalBusiness schema for multiple locations.

4. Unescaped quotes in long text fields

json
// ❌ Breaks the parser: the whole block is ignored
"text": "The phrase "core web vitals" refers to three metrics."

// ✅ Escaped
"text": "The phrase \"core web vitals\" refers to three metrics."

Frequently Asked Questions

Does schema markup guarantee that ChatGPT or Perplexity will cite my website?

No. No single signal guarantees a citation, and no major AI engine has published that it requires schema. Google says AI Overviews need no special structured data. Clean markup makes your facts easier to read correctly; whether you're cited depends on crawl access and what the page says.

Google recommends JSON-LD; other engines haven't published a preference. JSON-LD is a self-contained block, so any parser can read it without walking the HTML. See JSON-LD vs Microdata vs RDFa.

Can schema markup stop AI hallucinations about my brand?

It removes one source of them. Wrong facts appear when a model works from ambiguous or conflicting text; a price stated plainly on the page and as "price": "49.00" in markup leaves less to resolve. Markup that contradicts the page adds a source of error instead.

What is the most important schema type for a B2B SaaS site?

SoftwareApplication with an Offer, connected to your Organization by @id. Together they state what the product is, what it costs and who makes it, which are the facts buyer questions ask about.

Should I put several schema types on one page?

Yes, when the page really contains them. An article can carry TechArticle, BreadcrumbList, the Organization and the author Person, best in one @graph linked by @id rather than separate unconnected blocks.

Can invalid JSON-LD hurt my rankings?

Not directly; Google's guidelines say a structured data manual action affects rich result eligibility, not web ranking. But an unparsable block is invisible to every parser, so the facts in it are lost.

Make the Page and the Markup Say the Same Thing

Pick your three most-quoted pages (usually pricing, the main product page and your top guide), run the script on each, and fix every price, name or date that the markup states but the page doesn't. Then keep it that way by generating both from one source; a BugViso scan validates the markup on every page it crawls.

Written by

· BugViso Team

Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.

Found this useful? Share it.

Summarise with AI

Open this guide in your assistant.

Follow BugViso

New guides and audit data as we publish them.

AI visibility tracker

Is your brand in AI answers?

See how often AI assistants mention you, cite your site and rank you against your competitors.

  • ChatGPT
  • Gemini
  • Perplexity
  • Claude
  • AI Overviews
See how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.