What Schema Markup Actually Gets You Cited in AI Search (And What Doesn't)

What Schema Markup Actually Gets You Cited in AI Search (And What Doesn't)

Schema markup will not get you cited in ChatGPT, Perplexity, or Google AI Overviews on its own. That is the first thing any honest guide on this topic needs to say.

What schema markup does do is qualify your content for consideration. It tells AI engines what type of content they're looking at, who produced it, and whether specific claims are structured clearly enough to extract. Think of it as the entrance exam, not the prize.

The prize is entity-dense content. We'll explain exactly what that means shortly, because it's the thing no other guide on this topic actually covers.

First, let's look at which schema types are worth your time.

---

Why Most Schema Guides Get This Wrong

If you've searched for schema markup advice, you've probably found lists of 8, 10, or 15 schema types with instructions to "implement them all." That advice is wrong for two reasons.

First, AI engines only actively parse a small number of schema types for direct answer generation. Implementing 15 types from schema.org doesn't multiply your citation chances, it creates conflicting markup signals that can actually confuse extraction algorithms.

Second, and more critically: the schema type is not the deciding factor. The text inside the schema is. A page with technically perfect JSON-LD that says "Yes, we offer fast shipping" will not get cited. A page with basic markup that says "AllEO ships same-day within the UK via Royal Mail Tracked 24 for orders placed before 2pm GMT" will.

AI engines cite facts. Named entities. Specific claims with verifiable details. That principle is called entity density, and it governs whether your schema content earns a citation regardless of which type you implement.

With that foundation in place, here are the five schema types that consistently produce results.

---

The 5 Schema Types That Drive AI Citations

1. FAQPage Schema

FAQPage schema is the highest-leverage AEO implementation available right now. It maps directly onto how users interact with conversational AI: they ask a question, they expect a direct answer.

When you structure Q&A content with FAQPage JSON-LD, you're giving AI engines a pre-packaged extraction target. The engine doesn't have to infer what the answer is. It finds a Question node, finds the acceptedAnswer node, and has a citable unit ready to use.

The critical rule: the acceptedAnswer text must contain named entities. Not "We offer competitive pricing" but "AllEO's AEO Article service is priced at £200 as a one-off engagement, with no monthly commitment required." The first sentence is invisible to AI citation. The second is citable.

What good FAQPage schema looks like:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "How long does it take for schema markup to affect AI citations?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "Schema changes typically take 2-4 weeks to reflect in Google AI Overviews after Google's crawl cycle. For ChatGPT and Perplexity, which use real-time web retrieval, the effect can appear within days of recrawling, though citation frequency depends primarily on content quality and topical authority, not schema implementation alone."
    }
  }]
}

Notice what's in that answer: specific timeframes, named platforms, a nuanced qualification. That's what gets cited. The answer is a fact, not a sentence.

---

2. Article Schema

Article schema establishes the authorship, publication date, and publisher identity of your content. This matters for AI citations because recency and authority are citation filters.

Perplexity, for example, surfaces recently published sources. ChatGPT's retrieval layer weights authority signals including author credibility. Without Article schema, AI engines have to infer these signals from page context. With it, they're explicitly declared.

The properties that matter most are author, datePublished, dateModified, and publisher. The headline must match your H1 exactly. Mismatches between the JSON-LD and visible page content flag your page as a potential hallucination risk, and AI engines skip it.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "What Schema Markup Actually Gets You Cited in AI Search",
  "author": {
    "@type": "Person",
    "name": "Your Name",
    "url": "https://your-site.com/about"
  },
  "datePublished": "2026-04-05",
  "dateModified": "2026-04-05",
  "publisher": {
    "@type": "Organization",
    "name": "AllEO",
    "url": "https://all-eo.com"
  }
}

Keep dateModified current. Stale modification dates signal dead content to AI retrieval systems.

---

3. Organization Schema (with sameAs)

Organization schema on your homepage performs a specific function: it establishes your brand as a known entity in the AI's knowledge graph.

The most important property is sameAs. This links your brand entity to external profiles (LinkedIn, Twitter/X, Crunchbase, Wikipedia if applicable, industry directories) and tells AI engines that your brand name in any context refers to this specific entity. It's how you prevent AI models from confusing your brand with competitors or generic terms.

Without a strong sameAs network, AI engines may cite a page from your site while attributing the information to a vaguer entity or no entity at all. You want the citation to include your brand name. That requires entity disambiguation, which sameAs provides.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "AllEO",
  "url": "https://all-eo.com",
  "logo": "https://all-eo.com/images/allEO-logo.png",
  "sameAs": [
    "https://linkedin.com/company/allEO",
    "https://twitter.com/allEO",
    "https://www.crunchbase.com/organization/allEO"
  ]
}

The sameAs list doesn't need to be long. Two or three high-authority, consistent profiles outperform ten low-authority ones.

---

4. Product or Service Schema

If your business sells something, Product or Service schema is what links your brand to commercial intent queries in AI search.

When a user asks Perplexity "what's a good AEO service for a small business," Perplexity is looking for pages that clearly declare: this is a service, here is what it costs, here is who it's for, here is what it does. Without structured commercial data, your page competes on generic text parsing. With it, you're presenting machine-readable commercial claims directly.

The critical properties: name, description, offers (including price and priceCurrency), and provider. If you're a service business rather than a product business, use Service schema with the same structure.

{
  "@context": "https://schema.org",
  "@type": "Service",
  "name": "AEO Article",
  "provider": {
    "@type": "Organization",
    "name": "AllEO"
  },
  "description": "A one-off AEO-optimised article written to appear in AI search citations. Includes schema markup, entity-density writing, and FAQ injection.",
  "offers": {
    "@type": "Offer",
    "price": "200",
    "priceCurrency": "GBP"
  }
}

Note that the description contains entity-dense language, not a marketing sentence. "Helps you get found online" does nothing. Named deliverables, specific methods, and concrete scope are what AI engines extract.

---

5. BreadcrumbList Schema

BreadcrumbList is the most overlooked schema type on this list. It does something structural: it tells AI engines where a page sits within a site's information architecture.

This matters because AI engines use topical clustering as a citation signal. A page on "schema markup for AI citations" that sits within a clear Learn > Technical SEO > Schema Markup hierarchy carries more topical authority than the same page with no declared site structure. The breadcrumb chain signals to the AI that your site has depth and expertise in this topic area.

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://all-eo.com"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Learn",
      "item": "https://all-eo.com/learn"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Schema Markup for AI Citations",
      "item": "https://all-eo.com/learn/schema-markup-ai-citations"
    }
  ]
}

Every interior page should have this. It takes ten minutes to implement and adds structural authority signals that compound across your entire site.

---

The Entity Density Rule: Why Schema Alone Is Not Enough

This is the concept most guides miss entirely, and it's the difference between a technically valid page that never gets cited and a modest page that shows up in AI answers regularly.

Entity density means the degree to which your content contains specific, verifiable, named facts rather than vague assertions.

Here's the clearest way to see it. Two coffee shops, same neighbourhood, similar domain authority. Shop A has perfect FAQPage JSON-LD. Their answer reads: "Yes, we serve great coffee sourced from ethical farms." Shop B has simpler schema. Their answer reads: "Yes, we serve single-origin Ethiopian Yirgacheffe, roasted in-house three times a week at our Downtown Austin location, available as espresso, filter, and cold brew from 7am Monday to Saturday."

When a user asks Perplexity "best coffee near me with single-origin beans," Perplexity chooses Shop B. Not because Shop B's schema is better. Because Shop B's answer contains entities: a named origin, a roasting process, a location, a product list, specific hours. These are facts. AI engines cite facts.

Apply this rule everywhere your schema contains acceptedAnswer, description, or text fields. Before publishing, run this self-check: does this sentence contain at least one named entity (brand, place, price, date, product name, person, statistic)? If not, it's not citable content.

---

When to Use Schema Markup for AI Citations

Use schema markup when:

• You're launching a new site or page and want to be AI-citation-eligible from day one
• Your existing content is already high quality but not appearing in AI Overviews or Perplexity results
• You're adding a FAQ section to any page (this is the fastest ROI schema implementation available)
• You're publishing a product, service, or pricing page where commercial intent queries are the target
• You've updated content and want to signal recency to AI retrieval systems via dateModified

Don't wait until your content strategy is "complete." FAQPage schema on a single well-written page with entity-dense answers can produce AI citations within weeks of indexing.

---

What to Avoid

Don't implement schema that contradicts your visible content. If your page says "starting from £200" and your JSON-LD says "price": "150", AI engines treat this as a hallucination risk and skip the citation. Contextual integrity means the markup and the text must say the same thing.

Don't use generic placeholder language inside schema. "Contact us to find out more" as an acceptedAnswer value is ignored by AI models. It contains no entities, no facts, no citable claims.

Don't implement every schema type from schema.org. HowTo, SpeakableSpecification, VideoObject, EventSeries — adding them without relevant content creates conflicting signals. Implement only the types that match content actually present on the page.

Don't treat schema as a one-time task. Every time you update pricing, change service scope, add a team member, or revise key content, the JSON-LD must be updated to match. Stale schema is worse than no schema for AI citation credibility.

Don't add FAQ schema with questions that can't be answered directly. "Is your service right for me?" has no entity-dense answer. "What is included in your AEO Article service?" does. Build your FAQ around specific, factual questions where the answers contain named entities.

---

How to Measure Whether Schema Is Working

This is one of the most common frustrations from the community, and for good reason: Google Search Console does not track ChatGPT citations. There is no dashboard that tells you "this schema change produced this citation."

What you can measure:

Google AI Overviews presence: Use Google Search Console's "Search type: AI Overviews" filter (available in 2025 onwards) to see if your pages are appearing. Compare before and after schema implementation.

Perplexity monitoring: Run the exact questions from your FAQPage schema directly in Perplexity. Note whether your site appears as a source. Do this weekly for the 4 weeks following implementation.

Google Rich Results Test: Validates that your JSON-LD is parseable. This is a hygiene check, not a citation predictor, but unparseable schema produces zero results, so validate before and after any change.

Manual ChatGPT/Perplexity queries: Search for the specific entities and claims in your acceptedAnswer text. If you've written "AllEO's Growth Retainer is priced at £740 per month," search for "AEO retainer pricing UK" in both platforms and see whether your brand appears.

Track these weekly for six weeks after any schema change. The correlation isn't always clean, but directional movement is usually visible.

---

Frequently Asked Questions

Does schema markup guarantee AI citations?

No. Schema markup is a qualifying signal, not a citation guarantee. Studies show schema predicts roughly 4-7% of citation behaviour for AI Overviews. The primary drivers are content quality, entity density in the text, domain authority, and external mentions. Schema gets your content parsed correctly; high-information-density writing gets it cited.

Which schema type has the most impact on AI citations?

FAQPage schema consistently shows the strongest correlation with AI citations across platforms, because it directly mirrors the question-and-answer structure of conversational AI queries. However, its impact is entirely conditional on the quality of the acceptedAnswer text. A FAQPage with vague answers will still not be cited.

Should I prioritise JSON-LD or llms.txt for AI visibility?

These serve different functions and aren't in competition. JSON-LD structured data helps AI engines parse and extract from your existing content at crawl time. llms.txt is an emerging standard that signals to AI systems how to navigate and interpret your site, similar to robots.txt but for language models. Both are worth implementing, but JSON-LD has broader current support and higher near-term ROI.

Does schema markup work the same way for Perplexity and ChatGPT?

No. Perplexity places relatively high weight on structured signals and real-time web retrieval, making schema implementation more directly impactful. ChatGPT's retrieval layer weights domain authority more heavily, roughly 3.5 to 1 compared to structured data signals. Both benefit from schema, but Perplexity shows faster measurable response to schema changes.

How many FAQ entries should I include per page?

Five to eight FAQ entries per page is the practical target. Fewer than five provides limited citation surface area. More than ten starts to dilute the page's topical focus. Each FAQ entry should address a distinct question that a real user types into a conversational AI, not an internal marketing question.

Can too much schema hurt my AI citation chances?

Yes. Implementing schema types that don't match the actual content on the page creates conflicting signals. AI engines use contextual integrity checks: if your JSON-LD declares a product with pricing but your visible page text doesn't mention pricing, that mismatch is treated as a credibility warning. Implement only schema types that reflect content actually present on the page.

---

Next Steps

Start with FAQPage schema on your highest-traffic pages. Write the acceptedAnswer text with at least one named entity per answer: a price, a timeframe, a location, a product name, a specific process. Validate the JSON-LD at schema.org/validator. Then run the exact FAQ questions through Perplexity and note whether your page appears as a source.

Add Organization schema with sameAs properties to your homepage. Set up three or four consistent external profiles and link them. This is a one-time implementation with long-term entity disambiguation benefit.

Update Article schema dateModified every time you revise content. Keep the headline field in exact sync with your H1. Check for contextual integrity between your JSON-LD and visible text every time you update pricing or service scope.

Schema markup is not a shortcut to AI citations. But implemented correctly, with entity-dense content inside the markup, it removes the technical barriers that prevent well-written pages from being cited. That's a meaningful advantage, and it compounds as your content library grows.