GEON GEON
SEO & GEO last month 7 min

The Schema Markup Stack AI Search Engines Actually Read

Four JSON-LD schemas — Organization, Article, Person, and BreadcrumbList — carry almost all the signal AI search engines extract. Stuffing the rest of the schema.org vocabulary into your templates dilutes machine trust instead of building it.

The Schema Markup Stack AI Search Engines Actually Read

Four JSON-LD schemas carry almost all the signal AI search engines extract from your pages — Organization, Article, Person, and BreadcrumbList — and stuffing your templates with everything else in the schema.org vocabulary doesn't help, it dilutes machine trust. Two more, FAQPage and HowTo, still earn their place when the content genuinely matches, even though Google deprecated their rich-result treatment in 2023. The schemas that hurt you are the ones a human couldn't verify from the visible page: Product on a marketing site, AggregateRating with no reviews, Event on an evergreen article.

Why JSON-LD Is the Format AI Engines Actually Read

JSON-LD won the structured data race because it lives in a <script> block, decoupled from the rendered DOM. A crawler — whether GPTBot, ClaudeBot, or Googlebot — can parse it as a single JSON tree without walking the page or stitching together microdata attributes scattered across dozens of elements. Google's own structured data guidance recommends JSON-LD as the preferred encoding format for Search, ahead of microdata and RDFa.

That preference matters more for AI ingestion pipelines than for classical search. LLM-based crawlers sample the <head> and <script type="application/ld+json"> blocks early in their fetch budget, then use the parsed AST as a structured prior over what the page is about — author, publisher, publication date, hierarchy. Microdata forces the model to reconstruct that prior from interleaved tag soup, which is slower and noisier.

The vocabulary itself is the same across formats. Schema.org is a collaborative project founded by Google, Microsoft, Yahoo, and Yandex, and it's now the de facto shared semantic layer both classical and AI crawlers consume. You're not picking a format to please any single engine — you're picking the cleanest serialization of a vocabulary everyone has agreed on.

The Core Stack: Four Schemas That Carry Most of the Signal

Every blog post on a publisher site only needs four schemas to be machine-legible. Each one answers a specific question the LLM is trying to resolve about the page.

Schema Question it answers Recommendation
Organization Who publishes this content? Always
Article (or BlogPosting, NewsArticle) When was it written, by whom, what's the headline? Always
Person Who is the author and why should readers trust them? Always
BreadcrumbList Where does this page sit in the site hierarchy? Always
FAQPage Is this a genuine Q&A? Conditional
HowTo Is this a real step-by-step procedure? Conditional
Product, Review, Event on non-matching pages — Avoid

Here's the minimum viable JSON-LD wiring for a typical blog post:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#org",
      "name": "Example Publishing",
      "url": "https://example.com",
      "logo": "https://example.com/logo.png",
      "sameAs": ["https://www.linkedin.com/company/example"]
    },
    {
      "@type": "Person",
      "@id": "https://example.com/authors/jane#person",
      "name": "Jane Doe",
      "jobTitle": "Senior Engineer",
      "worksFor": { "@id": "https://example.com/#org" },
      "sameAs": ["https://www.linkedin.com/in/janedoe"]
    },
    {
      "@type": "BlogPosting",
      "headline": "The Schema Stack AI Search Engines Read",
      "datePublished": "2026-04-29",
      "dateModified": "2026-04-29",
      "author": { "@id": "https://example.com/authors/jane#person" },
      "publisher": { "@id": "https://example.com/#org" }
    },
    {
      "@type": "BreadcrumbList",
      "itemListElement": [
        { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.com" },
        { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://example.com/blog" }
      ]
    }
  ]
}

Notice the @graph form with shared @id references — this links Person to Organization without duplicating data, and it's the form most AI parsers handle cleanly.

The four schemas map onto the E-E-A-T signals AI engines try to reconstruct: experience and expertise come from Person, authoritativeness from Organization, trust from publication metadata on Article plus a coherent BreadcrumbList. Skip any of the four and you force the engine to guess.

Conditional Schemas: FAQPage and HowTo After the 2023 Deprecation

In August 2023, Google removed HowTo rich results entirely and limited FAQ rich results to authoritative government and health sites. A lot of teams read that as "stop using these schemas." That's the wrong inference.

The schemas stayed valid markup. Google didn't drop them from the schema.org vocabulary or stop parsing them — it just stopped rendering rich snippets for them in the SERP. AI engines still parse the same JSON-LD blocks and treat FAQPage as Q&A metadata and HowTo as a structured step list. Perplexity and ChatGPT will happily extract a Q&A pair from your page when the FAQPage block accurately reflects the content underneath it.

The rule is the one humans already enforce: only mark up FAQPage if the page is actually a Q&A page, and only HowTo if it's actually a step-by-step procedure. Faking the schema to chase a rich result you can no longer earn is the classical-search version of the problem covered next.

Speakable, QAPage, and ItemList belong in the same conditional bucket. They earn their place when the content genuinely matches, and they hurt you when it doesn't.

Schemas That Add Noise (or Get You Penalized)

The Princeton GEO research framework (Aggarwal et al., 2023) shows that source-level signals — citations, statistics, quotes, structural cues — measurably increase the likelihood that generative engines surface a piece of content as a referenced source. The corollary nobody quotes: noisy signals dilute the credible ones.

The schemas that consistently hurt:

  • Product / Offer / Review on non-commerce pages. The historic spam pattern — bolting a fake AggregateRating onto a marketing page to harvest stars. Classical search caught it years ago; AI engines treat it as a credibility flag.
  • Event on an evergreen article. Date fields don't match the content. Schema says one thing, page says another. The model trusts the page.
  • AggregateRating on a page with no visible reviews. If a user can't see the rating on the rendered page, the schema is asserting a fact it can't back up.
  • Multiple conflicting Article subtypes on the same page. BlogPosting and NewsArticle and TechArticle for the same content. Pick one.
  • Stuffed sameAs lists pointing to irrelevant profiles or to accounts that don't actually represent the organization.

A counter-example we see often on Stripe-style or Notion-style marketing landing pages:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Our Workflow Platform",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.9",
    "reviewCount": "1247"
  }
}

There's no product detail page. There's no list of reviews on the page. The schema is asserting a rating no human can verify from what's rendered. That's the heuristic: if a human reader couldn't confirm the schema's claim from the visible page, the schema is a liability.

Validation and Monitoring Workflow

Treat schema as code. The teams that get this right run a checklist in PR review on every template change:

  • Validate the rendered JSON-LD with the Schema.org Validator and Google's Rich Results Test before shipping
  • Diff schema output between staging and production after each deploy — silent breakage from a CMS upgrade or analytics tag is the most common failure mode
  • Confirm datePublished and dateModified are populated and ISO 8601 formatted
  • Check that @id references resolve inside the same @graph
  • Log AI bot user agents (GPTBot, ClaudeBot, PerplexityBot) and verify schema-bearing pages are crawled at expected rates

One more check that pays off: monitor schema output on critical templates with automated tests. If your site publishes 10,000 articles, you don't want to discover three months from now that a deploy broke Article.author on every post written in Q2. GEON's schema validation surface is one way to automate the diff and alert step; you can also build it yourself with a headless browser and a JSON schema validator in CI.

The mental model that ties this all together: every schema you add is a claim. Each claim earns trust if the page can back it up and burns trust if it can't. A small core of well-grounded claims beats a stack of speculative ones every time.

Deniz

Deniz

Content & GEO Strategy