Schema markup for AI search: entity-first guide to AI citations
Schema markup written for AI search engines works differently than markup for Google's organic index. AI crawlers prioritize entity relationships and answer-first content over keyword density, which means your business data must be structured as a knowledge graph, not a keyword container. This guide shows you how to build schema that gets cited in ChatGPT, Perplexity, Gemini, and Claude—and how to measure whether it's working.
Why schema markup for AI search is different from Google schema
Google's organic search indexes pages. AI search engines index entities—the things your business IS, not the keywords your pages contain. When you mark up your website with schema today, you're usually optimizing for Google's Knowledge Panel and rich snippets. That schema tells Google: 'This page is about a plumber in Denver.' AI crawlers go deeper: they ask 'What is this entity? What relationships does it have? What claims does it make about itself that I can cite?' A page with perfect on-page SEO but weak entity schema will rank in Google but get overlooked by Claude or Gemini when a user asks for a recommendation.
This matters because AI citation is not earned through ranking. A user asking ChatGPT 'best plumber in Denver' doesn't get results ranked by any algorithm ChatGPT runs. Instead, the model draws from its training data and the live sources it's allowed to cite in real time. If your entity schema is rich, discoverable, and claims-backed, you're more likely to appear in that citation pool. If your schema is sparse or keyword-stuffed, you won't.
The core schema types AI crawlers actually use
Not all schema markup is equal in the eyes of AI crawlers. Some schema types are structural noise; others are the foundation of AI discoverability. The four schema types that matter for AI citations are Organization, LocalBusiness, Product, and Answer. Each serves a different purpose in the knowledge graph.
| Schema Type | What AI crawlers use it for | Best for | Citation likelihood |
|---|---|---|---|
| Organization | Entity identity, claims, and relationships (team, awards, partnerships) | Any business with a branded presence | High—foundational |
| LocalBusiness | Geographic footprint, service area, hours, contact | Service businesses, franchises, multi-location operators | High—location-specific queries |
| Product | Offering details, pricing, reviews, availability | E-commerce, SaaS, service packages | High—product recommendation queries |
| Answer | Claim + evidence structure for FAQ or answer content | Educational, how-to, troubleshooting content | Medium—only if well-sourced |
Organization schema is non-negotiable. It's the entity's identity card in the knowledge graph. LocalBusiness extends it for geographic relevance. Product schema makes individual offerings discoverable. Answer schema works only if you back claims with citations—AI crawlers will skip unsourced answers. The mistake most businesses make is adding schema without a knowledge graph hierarchy: they mark up a product page with Product schema but never link it back to the Organization that makes it. AI crawlers see isolated facts, not a connected entity.
Building an entity-first schema structure
Entity-first means the Organization schema is the root, and every other schema type (LocalBusiness, Product, Person, Answer) branches from it. This mimics how AI crawlers build knowledge graphs: they start with 'What is this entity?' and then collect properties and relationships. The structure looks like a tree: the trunk is Organization; the branches are LocalBusiness instances, Product offerings, and Team members; the leaves are reviews, credentials, and content.
- Create the root Organization schema
Add a JSON-LD block to your homepage (or a dedicated /schema page) with Organization type, including: name, description (2–3 sentences, claim-based not keyword-stuffed), url (homepage), logo (square, high-res), sameAs (links to Wikipedia, Crunchbase, LinkedIn if they exist for your entity), foundingDate, areaServed (geographic scope), and contact type (telephone, email, social profiles as ContactPoint objects).
Why: This block is your entity's identity. AI crawlers use it as the anchor point to verify claims and link related schema. Without it, subsequent schema appears orphaned.
✓ Checkpoint: Run your homepage through a schema validator (schema.org validator or Google's Rich Results Test). The Organization block should render with no errors and all core properties visible.⚠ Pitfall: Omitting sameAs links or leaving them empty. If your entity has a Wikipedia page, Crunchbase profile, or LinkedIn company page, include those URLs—AI crawlers use them to cross-verify your claims. - Link LocalBusiness schema if you serve a geographic area
Add LocalBusiness schema to your service pages or contact pages. Include: name (same as Organization), address (full street, city, state, zip), geo (latitude/longitude), telephone, openingHoursSpecification (day, opens, closes), priceRange (if applicable), and areaServed (list of cities or regions you serve, not just your office location).
Why: LocalBusiness tells AI crawlers where you operate and when. AI models use this to answer 'Is this business open now?' and 'Do they serve my area?' without it, geographic queries skip you.
✓ Checkpoint: Use a mapping tool to verify your latitude/longitude are accurate to within 50 feet. Test areaServed by checking that it matches your actual service territory (not oversold).⚠ Pitfall: Hardcoding hours that change seasonally or setting areaServed to a single city when you serve ten. Schema drift—where your schema no longer matches reality—signals untrustworthiness to crawlers. - Add Product schema for each service or offering
For each distinct offering (a service package, product tier, or course), create a Product schema block. Include: name, description, price (use PriceSpecification with currency and priceCurrency), priceCurrency, offers (Offer object with price, priceCurrency, availability), aggregateRating (if you have reviews), and isPartOf (link back to the Organization).
Why: Product schema makes individual offerings discoverable to AI crawlers evaluating 'What does this business actually sell?' and 'What does it cost?' It's the schema type most likely to trigger product recommendation queries.
✓ Checkpoint: Verify that price is a valid number (not a range like '50–100') and priceCurrency is a valid ISO code (USD, EUR, etc.). Check that aggregateRating.ratingValue is between 1 and 5.⚠ Pitfall: Using vague descriptions ('Our best service') instead of specific claims ('Includes 3 hours of onsite consultation, 2 revisions, and 30-day support'). AI crawlers can't cite vague claims. - Add Person schema for team members or founders
For each key team member (founder, CEO, lead expert), add a Person schema block with: name, jobTitle, description (brief, 1–2 sentences, claim-based), image (professional photo), sameAs (LinkedIn, Twitter, personal website if public), and worksFor (link back to Organization). Include credentials or certifications as Text properties if relevant.
Why: Person schema builds trust and helps AI crawlers understand who is behind the entity. It's especially important for service businesses where the person IS part of the brand value.
✓ Checkpoint: Verify that the image URL is publicly accessible and the sameAs links resolve to real profiles. Check that jobTitle matches the person's actual role.⚠ Pitfall: Listing every employee. Include only people who are publicly associated with the business (founders, published experts, public-facing roles). Including random staff members adds noise and looks inauthentic. - Link Answer schema to your content
For FAQ pages, blog posts, or how-to content, add Answer schema with: mainEntity (the Question being answered), acceptedAnswer (the answer text, 50–200 words), and answerSource (a citation or reference if applicable). Include citations as Thing objects with name and url.
Why: Answer schema tells AI crawlers that this content is a direct, sourced answer to a question. AI models use this to decide whether to cite your content or a competitor's.
✓ Checkpoint: Verify that the answer text is self-contained (reads as a complete answer without the page context). Check that any citations have real, working URLs.⚠ Pitfall: Marking up every paragraph as an Answer. Schema should cover only direct, well-sourced answers. Thin or opinion-based content will be skipped by crawlers. - Add Review and AggregateRating schema from verified sources only
If you have reviews from Google, Trustpilot, or industry-specific platforms, add Review schema or AggregateRating to your Organization or Product schema. Include: ratingValue (1–5), ratingCount (total reviews), and bestRating/worstRating (1 and 5). Link to the review source via reviewRating.url.
Why: AI crawlers use aggregated ratings to validate your claims about quality. Unverified reviews or self-generated ratings are flagged as low-trust.
✓ Checkpoint: Run the ratingValue and ratingCount against your actual review platforms. They should match within 5 reviews. Do not inflate or fabricate ratings.⚠ Pitfall: Adding reviews you wrote yourself or inflating your rating. AI crawlers cross-check against public review platforms. Mismatches tank credibility. - Validate and publish your schema
Paste your schema JSON-LD into the Google Rich Results Test (search.google.com/test/rich-results). Fix any errors reported. Once valid, add the schema to your website (homepage for Organization, relevant pages for LocalBusiness/Product/Answer). If using a CMS, use a schema plugin (Yoast, Rank Math, Schema.org) to avoid manual updates.
Why: Validation ensures crawlers can parse your schema without errors. Publishing makes it discoverable to both Google and AI crawlers.
✓ Checkpoint: The Rich Results Test shows 'Eligible for rich results' or 'No issues found.' Visit your published page in a browser and use the browser's developer console to confirm the schema is present (Ctrl+F for 'schema.org').⚠ Pitfall: Validating locally but forgetting to publish, or using a CMS plugin that strips schema on certain page types. Always test the live, published version.
How to structure claims so AI crawlers cite you
Schema alone doesn't earn citations. A crawler will read your Organization schema, see you claim to be 'the best digital agency,' and move on. AI models are trained to distrust unsourced superlatives. They cite sources that make specific, verifiable claims backed by evidence. Your schema must contain claims, not marketing language, and ideally those claims should be corroborated by external sources.
The second rule is corroboration. If you claim to have won an award, include a link to the award announcement. If you claim to be certified, link to the certifying body's directory. If you claim to have 10,000 customers, back it with a press release or third-party mention. AI crawlers cross-reference schema against the open web. Claims that appear only on your own schema and nowhere else are low-trust.
- Audit your current claims
List every factual claim you make about your business: founding date, team size, customer count, certifications, awards, geographic reach, pricing, service scope. Exclude marketing language ('innovative,' 'best,' 'leading'). Keep only claims you can defend with a document, link, or third-party source.
Why: You can't schema-mark what you haven't identified. This audit reveals which claims are citable and which are too vague.
✓ Checkpoint: You should have 8–15 concrete claims. If most of your claims are superlatives or adjectives, you don't have enough substance for AI crawlers to cite.⚠ Pitfall: Including unverified claims (e.g., 'serves 5,000+ businesses' with no data to back it). AI crawlers will ignore or penalize low-trust claims. - Link each claim to a source
For each claim, identify a public source: a press release, news mention, directory listing, certification body, or third-party review site. Add a citation object to your schema with name (source name) and url (direct link to the claim). For example, if you claim to be SOC 2 certified, link to your profile on the certification body's website.
Why: External corroboration increases the likelihood that AI crawlers will cite your claim. A claim with a link is 10x more citable than the same claim without one.
✓ Checkpoint: Click each link in your schema. It should resolve to a real page that mentions or confirms your claim. Dead links kill credibility.⚠ Pitfall: Linking to your own pages as citations. 'I say I'm certified, and here's a page on my website that says I'm certified' is circular. Link to the third-party source (the certifier's directory, the news article, the review site). - Prioritize claims that appear in multiple sources
If a claim appears in your schema AND in a news article AND in a customer review AND in an industry directory, mark it as high-corroboration. Prioritize these claims in your schema; deprioritize or remove claims that appear only on your website.
Why: AI crawlers weight corroboration heavily. A claim that appears in three independent sources is 100x more citable than a claim that appears only in your schema.
✓ Checkpoint: For your top 5 claims, do a web search (site:-yourdomain.com + your claim) to see if it's mentioned elsewhere. If you find 2+ external mentions, that claim is high-corroboration.⚠ Pitfall: Assuming that because you made a claim, it's automatically true to crawlers. Crawlers don't trust you by default. You must earn trust through external validation. - Update schema quarterly as claims change
Set a calendar reminder to review your schema every 90 days. Check that all claims are still accurate (e.g., founding date doesn't change, but customer count and certifications might). Remove claims that are no longer true. Add new claims as your business grows (new certifications, partnerships, publications).
Why: Stale schema signals low maintenance and low trust. AI crawlers favor fresh, accurate data. If your schema says you were founded in 2020 but it's now 2026 and you're still listing that, crawlers notice.
✓ Checkpoint: Your schema's lastModified or dateModified property should be within 90 days of today. If it's older, update it.⚠ Pitfall: Set-it-and-forget-it schema. Schema is not a one-time task. Businesses change; schema must track those changes.
Schema markup for answer-first content
AI crawlers cite content differently than Google does. Google ranks pages based on relevance and authority. AI crawlers cite sources based on whether the source answers the user's question directly and credibly. This means your content schema must be structured around answers, not keywords. An FAQ page with 10 questions and 10 answers is more citable than a 5,000-word blog post about the same topic, if the FAQ uses Answer schema and the blog post doesn't.
The rule is simple: if you want AI crawlers to cite your content, structure it as a direct answer to a specific question. The answer should be 50–200 words, self-contained (readable without the rest of the page), and backed by claims that are either common knowledge or cited. Answer schema tells crawlers 'This content is a direct answer to a question.' Without it, crawlers treat your content as general information, not a citable source.
- Identify questions your audience actually asks
List 10–20 questions your customers, prospects, or readers ask about your business or industry. These should be real questions from customer support tickets, sales calls, reviews, or search data—not questions you think they should ask. Format each as a clear, specific question (e.g., 'How long does a website redesign take?' not 'What is web design?').
Why: AI crawlers cite answers to real questions. Generic, broad answers are less citable. The more specific and real the question, the more likely crawlers will cite your answer.
✓ Checkpoint: For each question, ask: 'Would a customer or prospect actually ask this?' If the answer is no, remove it. If yes, keep it.⚠ Pitfall: Generating questions from keyword research instead of customer data. 'Schema markup for AI search' is a keyword; 'How do I make my business show up in ChatGPT?' is a real question. Use real questions. - Write direct, self-contained answers
For each question, write a 50–200 word answer that stands alone. The reader should understand the answer without reading the rest of the page. Include specific details (numbers, steps, examples) where possible. Avoid hedging language ('might,' 'could,' 'possibly'). Use active voice. If the answer includes a recommendation, back it with a reason or citation.
Why: AI crawlers extract answers and cite them in isolation. A vague or incomplete answer won't be cited. A clear, complete answer will be.
✓ Checkpoint: Read each answer aloud without the question or page context. Does it make sense? Can someone act on it or understand it without more information? If no, expand it.⚠ Pitfall: Writing answers that assume prior knowledge or refer to other parts of the page ('as we discussed earlier'). Each answer must be fully self-contained. - Add Answer schema with citations
For each question-answer pair, add a JSON-LD block with: @type: 'FAQPage' (or 'QAPage'), mainEntity: { @type: 'Question', name: 'Your question' }, acceptedAnswer: { @type: 'Answer', text: 'Your answer' }, and answerSource: { @type: 'Thing', name: 'Source name', url: 'https://source-url' } if the answer cites external information.
Why: Answer schema signals to crawlers that this is a direct answer to a question. It makes the answer machine-readable and citable.
✓ Checkpoint: Paste the schema into a validator. It should parse without errors. The answer text should be visible and complete.⚠ Pitfall: Adding Answer schema without citations. If your answer makes a claim, cite where it comes from. Unsourced answers are low-trust. - Optimize answer content for AI crawler discovery
Publish answer content on dedicated pages (e.g., /faq, /help, /guides) or in a structured FAQ section. Include a clear heading that matches the question schema. Add an llms.txt file to your root domain (yourdomain.com/llms.txt) that lists your FAQ and answer pages—this tells AI crawlers where to find your citable content.
Why: AI crawlers need to find your content. A dedicated FAQ page is easier to crawl than scattered answers across your site. llms.txt is a standard that tells crawlers which pages are optimized for AI citation.
✓ Checkpoint: Verify that your /llms.txt file is accessible (visit yourdomain.com/llms.txt in a browser). It should list your FAQ and answer pages with URLs.⚠ Pitfall: Hiding answer content behind forms, paywalls, or JavaScript. AI crawlers can't access gated content. Keep answer pages public and static.
Measuring whether your schema is earning AI citations
You can rank #1 in Google and still be invisible to ChatGPT, Perplexity, and Gemini. The reverse is also true: you can be cited in AI search without ranking in Google. This means your schema success metrics are different. You need to track whether AI crawlers are actually citing your business or content, not just whether they're crawling your pages.
The challenge is that AI citation tracking is hard. ChatGPT doesn't publish a log of which sources it cited. Perplexity shows citations in the UI, but you can't track them at scale. Gemini cites sources, but inconsistently. The only way to measure AI citations reliably is to monitor AI search results for queries relevant to your business and manually (or with a tool) track whether your content or entity appears in the citations.
- Define your trackable queries
List 20–50 search queries that represent your business (e.g., 'best plumber in Denver,' 'how to fix a leaky faucet,' 'plumbing cost estimates'). Include branded queries (your company name), category queries (your industry), and solution queries (problems you solve). Exclude vanity queries (your CEO's name) and ultra-broad queries (just 'plumbing').
Why: You can't track every query. Trackable queries are the ones where you have a reasonable chance of appearing in AI search results. They represent real user intent relevant to your business.
✓ Checkpoint: For each query, ask: 'Would we want to appear in the AI search result for this?' If yes, it's trackable. If no, remove it.⚠ Pitfall: Tracking 500+ queries. You'll drown in data. Start with 20–30 high-intent queries and expand after 3 months. - Monitor AI search results weekly
Every week, run your trackable queries in ChatGPT, Perplexity, Gemini, and Claude (or use a monitoring tool that does this automatically). For each result, note: (1) Did the AI cite your business or content? (2) Which AI engines cited you? (3) What was the citation type (direct quote, paraphrase, source link)? Log this in a spreadsheet or dashboard.
Why: Weekly monitoring gives you a real-time signal of whether your schema and content are earning citations. You'll spot trends (e.g., Perplexity cites you, but ChatGPT doesn't) and can adjust your strategy.
✓ Checkpoint: After 4 weeks, you should have a baseline. Count total citations across all queries and engines. This is your starting point.⚠ Pitfall: Checking results once and assuming that's representative. AI results vary by session, model, and time. Weekly checks are the minimum for reliable data. - Correlate schema updates with citation changes
When you publish a schema update (e.g., new Product schema, updated Organization claims), note the date in your tracking spreadsheet. For the next 4–8 weeks, monitor whether citations increase for related queries. A 20%+ increase in citations within 2 months of a schema update is a strong signal that the schema is working.
Why: This tells you whether your schema investments are paying off. Without correlation, you won't know if a citation increase is due to your schema, a press mention, or random variation.
✓ Checkpoint: You should see a measurable change (citations increase or decrease) within 2 months of a schema update. If there's no change after 3 months, the schema may not be working or the claims may not be citable.⚠ Pitfall: Updating schema and expecting immediate results. AI crawlers are slow. Give schema 4–8 weeks to show impact before concluding it doesn't work. - Track competitor citations
For each of your trackable queries, also note which competitors appear in the AI search results and how often they're cited. Over time, you'll see which competitors are winning in AI search and which queries are most competitive. This tells you where to invest in schema and content.
Why: Competitor benchmarking shows you what's possible and where you have the best chance to win. If a competitor is cited 10x more than you on a query you should own, that's a gap to close.
✓ Checkpoint: After 8 weeks, you should have a competitor citation map: which queries your competitors own, which are contested, and which are open for you to win.⚠ Pitfall: Obsessing over competitors you can't beat. Focus on queries where you have a realistic chance to compete (your industry, your geography, your expertise). - Use a monitoring tool if manual tracking doesn't scale
If you have 50+ trackable queries or want real-time alerts, use a tool like Zaduky (which tracks how often ChatGPT, Perplexity, Gemini, and Claude cite your business vs. competitors), SEMrush's AI Overview tracking, or Moz's AEO features. These tools automate the monitoring and give you a dashboard instead of a spreadsheet.
Why: Manual tracking is accurate but doesn't scale beyond 30–40 queries. A tool gives you scale, consistency, and historical trend data.
✓ Checkpoint: The tool should show you citation counts, citation sources (which AI engines), and trends over time. If it doesn't, it's not solving the right problem.⚠ Pitfall: Choosing a tool based on price instead of whether it tracks the AI engines you care about. Some tools track Google's AI Overview but not ChatGPT or Perplexity. Verify the tool covers the engines your audience uses.
Common schema mistakes that block AI citations
Even well-intentioned schema can fail if it's structured wrong. The mistakes are subtle but costly. They don't always cause validation errors (so Google's Rich Results Test passes), but they signal low trust to AI crawlers, which then skip your content or cite competitors instead.
0/12 complete
Yes, but differently than for AI search. Google uses schema for rich snippets and Knowledge Panels, which can increase click-through rate. But schema is not a ranking factor for Google's organic index. For AI search, schema is foundational—without it, you're nearly invisible. Prioritize schema for AI first; Google benefits follow.
Next steps: from schema to AI visibility
Schema markup is the foundation. It makes your entity discoverable and citable. But visibility in AI search requires three things working together: (1) entity-first schema that claims specific, corroborated facts, (2) answer-first content that directly addresses user questions, and (3) measurement that tells you whether your schema and content are actually earning citations. Miss any of these three, and you'll have schema but no citations.
The final step is to treat AI search as a separate channel from Google. Your Google SEO strategy (keywords, backlinks, page speed) is still valuable. But AI search operates on different rules. It rewards clarity, specificity, corroboration, and direct answers. Your schema and content should be optimized for both, but with AI as the primary target. If your content is great for AI, Google will benefit. The reverse is not always true.
0/9 complete