Schema Markup for AI Search: AEO Schema That Agents Can Read (2026)

Schema Does Not Earn Citations

For years the advice was simple: add structured data and AI engines will pick you. It was repeated everywhere, including in an earlier version of this post. The controlled evidence says otherwise. When Ahrefs compared pages that added JSON-LD with matched pages that did not, the change in AI citations was within noise on ChatGPT and AI Mode, and slightly negative on AI Overviews.

What an engine quotes is still decided by the words on the page: a direct answer near the top, specific facts, a source it can name. Markup does not stand in for any of that. If an engine skips you today, start with why it picks a competitor instead.

Related: How to Write an llms.txt File for SaaS (And the Top Generator Tools) — covers how to write an llms.txt from a different angle.

What Schema Actually Does: Facts an Agent Can Read

AI engines no longer only answer questions. Agents compare products, check prices and, more and more often, buy on someone's behalf. An agent reading your page needs exact values: what it costs, in which currency, whether it is in stock, what the return terms are, which product identifier matches the one the buyer searched. On a page with no structured data it has to infer those from a styled pricing table or a product grid.

Schema markup is a standardized vocabulary (maintained by Schema.org) for stating those facts outright: who wrote the page and when, what the product is, what it costs, what questions the page answers, what steps it outlines.

It reaches AI systems two ways:

1. Directly → an agent or shopping tool that fetches your page can read the JSON-LD in it, and gets your price, stock and identifiers without parsing the layout
2. Through knowledge graphs → Google and Bing index your structured data, which keeps your brand, author and product entities defined, so you are not confused with a company that has a similar name

Neither route makes an engine quote you more often. What both give you is that the facts machines repeat about you are the ones you stated, not the ones they guessed.

Related: The Complete AI SEO Audit Checklist for 2026 — covers the complete ai seo audit from a different angle.

The 5 Schema Types Worth Adding

Not all schema types matter equally. These five carry the facts engines and agents most often need, and each one comes with copy-paste JSON-LD code.

1. Organization Schema — Say Who You Are

Why it matters: Organization schema states your name, site, logo and official profiles. Knowledge graphs use it to tell you apart from companies with similar names, and an agent can use it to confirm that the business it is reading is the one the buyer meant.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Your Company Name",
  "url": "https://yoursite.com",
  "logo": "https://yoursite.com/logo.png",
  "description": "One sentence describing what your company does.",
  "foundingDate": "2024",
  "sameAs": [
    "https://twitter.com/yourhandle",
    "https://linkedin.com/company/yourcompany",
    "https://github.com/yourcompany"
  ],
  "contactPoint": {
    "@type": "ContactPoint",
    "contactType": "customer support",
    "email": "support@yoursite.com"
  }
}

Where to add it: Your homepage (site-wide layout). Place it once — it covers your entire domain.

Pro tip: The sameAs array links your website to your external profiles, so a machine can confirm they belong to the same entity. Include every official profile — LinkedIn, Twitter/X, GitHub, Crunchbase, Product Hunt.

2. FAQPage Schema — State Your Answers Plainly

Why it matters: FAQPage schema marks up the questions and answers already on your page, so a machine reading it gets each answer as a clean pair instead of untangling your layout. The answer still has to be a good one: the markup does not make an engine quote it more often.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the best way to optimize for AI search?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Answer the question directly near the top of the page, back the answer with specific facts, and make sure AI crawlers are allowed to read the page."
      }
    },
    {
      "@type": "Question",
      "name": "Your second question here?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Your detailed answer here. Keep answers between 50-150 words for optimal extraction."
      }
    }
  ]
}

Where to add it: Any page with a FAQ section — blog posts, product pages, landing pages.

Pro tip: Write each question the way a buyer would actually ask it. "How do I track AI citations?" says what the answer is about; "Citation Tracking Information" does not.

3. HowTo Schema — Spell Out the Steps

Why it matters: HowTo schema states each step of a guide in order, so a machine summarising it does not have to guess where one step ends and the next begins.

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to [Do the Thing Your Guide Teaches]",
  "description": "A concise description of what this guide achieves.",
  "step": [
    {
      "@type": "HowToStep",
      "position": 1,
      "name": "Step Name",
      "text": "Detailed description of step 1. Include specific actions, tools, and expected outcomes."
    },
    {
      "@type": "HowToStep",
      "position": 2,
      "name": "Step Name",
      "text": "Detailed description of step 2."
    }
  ]
}

Where to add it: Any guide, tutorial, or step-by-step blog post.

Pro tip: Keep name fields short (3-5 words) and text fields detailed (1-3 sentences): the name is the label, the text is the instruction. If your guide has more than 8 steps, split it into two HowTo schemas covering distinct phases.

4. Article/BlogPosting Schema — Say Who Wrote It and When

Why it matters: BlogPosting schema states who wrote your content, when it was published, and when it was last updated. Without it, a machine has to read those facts off a byline and a date in your layout, and it cannot tell a page you revised last week from one nobody has touched in three years.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Your Blog Post Title",
  "description": "Your meta description.",
  "datePublished": "2026-03-18",
  "dateModified": "2026-03-18",
  "url": "https://yoursite.com/blog/your-post-slug",
  "image": "https://yoursite.com/blog/hero-image.png",
  "inLanguage": "en",
  "author": {
    "@type": "Person",
    "name": "Your Name",
    "url": "https://yoursite.com/about",
    "sameAs": [
      "https://linkedin.com/in/yourprofile",
      "https://twitter.com/yourhandle"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "Your Company",
    "url": "https://yoursite.com"
  }
}

Where to add it: Every blog post. No exceptions.

Pro tip: The author.sameAs array is where many founders drop the ball. Include at least 2 external profiles — LinkedIn and Twitter/X — so a machine can connect the byline to a real person. Google's E-E-A-T guidelines emphasize first-hand experience, and sameAs is how you say whose experience it is.

5. Product Schema — State Your Price, Stock and Identifiers

Why it matters: This is the type agents depend on most. Product schema (SoftwareApplication if you sell software) states your price, currency, availability and identifiers in a form an agent reads without guessing. An agent comparing "best [category] tools", or buying on someone's behalf, needs those values exact; a price it has to scrape from a styled table is a price it can get wrong.

{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Your Product Name",
  "applicationCategory": "BusinessApplication",
  "operatingSystem": "Web",
  "url": "https://yoursite.com",
  "description": "What your product does in one sentence.",
  "offers": {
    "@type": "AggregateOffer",
    "priceCurrency": "USD",
    "lowPrice": "0",
    "highPrice": "199",
    "offerCount": "4"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "47"
  }
}

Where to add it: Your pricing page and homepage.

Pro tip: Only add aggregateRating if you have real reviews on a verifiable platform. Fake ratings violate Google's structured data guidelines and can get your markup penalized. If you're a new product, skip the rating and focus on offers. If you sell physical goods, use Product with a gtin or sku, and add hasMerchantReturnPolicy and shippingDetails to the offer: return terms and delivery costs are facts a buyer, human or agent, needs before committing.

Want to compare GEO tools side-by-side? See our best AI visibility tools ranking.

How to Generate Schema Markup for Answer Engines (Step-by-Step)

Step 1: Audit Your Current Schema

Before adding new markup, check what you already have. Open any page on your site, right-click → View Page Source, and search for application/ld+json. If you find nothing, your pages have zero structured data.

For a faster audit, use Google's Rich Results Test. Paste your URL and it shows which schema types are detected and whether they have errors.

Step 2: Start With Organization + BlogPosting

These two say who you are and who wrote what. Add Organization schema to your layout (so it appears on every page) and BlogPosting to every blog post.

Step 3: Add FAQPage and HowTo Where Relevant

Scan your existing content for pages with FAQ sections or step-by-step guides. Add the matching schema type. Don't force it — only add FAQPage schema to pages that actually contain questions and answers. Google treats markup that describes content the page does not show as a guidelines violation.

Step 4: Add Product/SoftwareApplication to Pricing and Homepage

If you have a pricing page, add SoftwareApplication schema with offers. If you have reviews, add the aggregate rating. These are the values an agent comparing "best [category] tools" needs exact, so keep them in step with the visible page every time your prices change.

Step 5: Validate Everything

Test every page after adding schema:

1. Google Rich Results Test — catches Google-specific errors
2. Schema.org Validator — validates against the full Schema.org vocabulary
3. Browser DevTools — inspect the rendered HTML to confirm JSON-LD appears in the <head> section

Fix any errors before deploying. Invalid schema is worse than none: a parser that fails on it reads nothing, and a wrong price in your markup is a wrong price stated with confidence.

Deeper look at how LoudPixel checks ChatGPT, Perplexity, Gemini, Claude, Google AI Overviews and Grok — and whether an AI agent could then complete a purchase from you, in the same audit: what each engagement includes.

How to Validate Your Schema Works

After deploying schema markup, check that machines read it the way you meant:

1. Google Search Console → Performance → Filter by "Search Appearance" to see rich results
2. Ask AI engines about your facts — Ask ChatGPT or Perplexity what your product costs or what your return terms are. If the answer is wrong or missing, check that the values in your markup match the page
3. Monitor over 2-4 weeks — Schema takes time to flow through knowledge graphs. Don't expect instant results
4. Don't judge it by AI citations — the controlled test says markup will not move them much. Judge it by whether engines and agents state your facts correctly

How to Automate It

Once you've implemented schema on your core pages, the ongoing work is keeping it true — updating dateModified, adding new FAQ entries, keeping Product prices in step with the page. A LoudPixel audit answers two separate questions: whether an AI agent can read your prices, terms and identifiers, and which of 6 AI engines name you. Schema answers only the first.

Ready to find out which of the 6 engines name you? See what each engagement includes.

Key Takeaways

• Schema markup does not earn AI citations. On the best controlled test it moved them within noise on ChatGPT and AI Mode, and down on AI Overviews.
• It earns its place for agents: your price, currency, stock, return terms and product identifiers, stated exactly instead of inferred from your layout.
• Five schema types are worth adding: Organization (who you are), FAQPage (answers as clean pairs), HowTo (steps in order), BlogPosting (author and dates), and Product (price, stock and identifiers).
• Start with Organization + BlogPosting, then add Product on anything you sell, and FAQPage and HowTo where the page already has questions or steps.
• Always validate. Invalid schema is worse than no schema. Use Google's Rich Results Test and Schema.org's validator before deploying.
• What engines quote is decided by your words. Direct answers, specific facts and the other GEO optimizations do that work; an llms.txt file and structured data make sure machines can reach your pages and read your facts right.
• For indie hackers and SaaS founders, the first block worth writing is SoftwareApplication on the pricing page: it states the price any comparison needs.

FAQ

Does schema markup directly help you rank in AI search engines like ChatGPT and Perplexity? No, not on the best evidence available. Ahrefs compared 1,885 pages that added JSON-LD with 4,000 matched pages that did not: AI citations moved +2.4% on Google AI Mode and +2.2% on ChatGPT, neither significant, and fell 4.6% on AI Overviews. Schema earns its place differently: it lets AI agents read your prices, terms and identifiers exactly, instead of guessing them from the page.

Which schema types matter most for Answer Engine Optimization (AEO)? Five carry the facts engines and agents most often need: Organization (who you are), FAQPage (questions and answers as clean pairs), HowTo (steps in order), Article/BlogPosting (author and dates), and Product or SoftwareApplication (price, currency, availability and identifiers, the one agents depend on most). Implement them as JSON-LD in your page's <head> section.

Can I just use a schema generator tool or do I need to write JSON-LD manually? Both work. Manual JSON-LD gives you full control and is recommended for custom implementations — the code snippets in this guide are ready to copy-paste. Schema generators like Schema.org's markup helper or Merkle's Schema Generator can speed up the process. The key is validation: always test your markup with Google's Rich Results Test and Schema.org's validator to ensure it parses correctly before deploying.

See where you stand: send your site and three buyer questions — I will tell you within a day whether an audit is worth your money, and sometimes the answer is no.

Written with AI assistance and reviewed by LoudPixel for accuracy.