Schema Markup That Actually Gets You Cited in AI Answers

Schema Matters More to LLMs Than to Google

Google has been quietly deprecating rich results. FAQ rich results for most sites disappeared in 2023. HowTo rich results narrowed further. The traditional case for schema, “install it to earn SERP real estate,” got weaker every year.

The case for schema got stronger anyway. Not because of Google. Because of LLMs.

Large language models parse structured data more reliably than they parse prose. When ChatGPT or Perplexity or Google’s Gemini synthesises an answer that cites a product, the citation logic weights machine-readable signals heavily. A page that declares “brand: Powder Room Guys, aggregateRating: 4.8, offers: $2400 AUD, merchantReturnPolicy: 30 days” gets parsed correctly. A page that says the same information in a paragraph of marketing copy gets parsed unreliably.

The founders we work with who get cited most consistently in AI answers all have one thing in common. They shipped schema properly, not partially. That is what this piece is about, and it is the structural layer under every GEO engagement we run.

The Three Schema Types Every Shopify Store Needs

Not fifteen. Not a schema-for-every-page audit. Three types, done well, on the right pages.

Product schema on every product page. This is where the money conversion happens. AI shopping surfaces (ChatGPT’s product carousels, Perplexity’s shopping mode, Google’s AI Overviews for commercial queries) all parse Product schema to decide what to cite. If your Product schema is missing or broken, you are not in the pool.

Organization schema on your homepage. This is the entity anchor. It tells every crawler and every LLM who you are, how to spell your brand, what category you sit in, and how to link back to your primary URLs. Without it, mentions of your brand elsewhere on the web do not resolve cleanly to your domain.

FAQ schema on your top three collection pages and top three content pages. Even without the rich result, FAQ schema is one of the most reliably-parsed structures for LLM citation. It gives you six pages worth of structured Q&A that AI systems can lift directly into their answers.

Three types. Six to fifteen pages, depending on catalogue size. That is the whole stack for most sub-$1M DTC brands.

The Two Properties Most Stores Miss

Every Shopify audit we have run in the last twelve months has surfaced the same two Product schema gaps.

brand. Should be a nested Brand object, not a string. "brand": { "@type": "Brand", "name": "Your Brand" }. Half the stores we audit have it as a plain string. LLMs parse the nested object more reliably as an entity. This is the difference between “your brand is mentioned” and “your brand is understood as a distinct entity.”

merchantReturnPolicy. This is a required field for Google Merchant Center compliance since 2023 and, more importantly, a heavily-weighted trust signal for AI shopping surfaces. It should include returnPolicyCategory (typically MerchantReturnFiniteReturnWindow), merchantReturnDays, and returnFees. Most Shopify apps generate schema without it. Most Shopify stores are consequently invisible in AI shopping citations even when their products would otherwise qualify.

Add these two. Test the difference. We have watched citation rates double for stores that fixed nothing else.

The Block We Ship On Every Audit

This is the Product schema block we install on every Shopify audit. Copy it, adapt it, ship it.

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Product Name",
  "image": ["https://cdn.shopify.com/.../product-1.webp"],
  "description": "Full product description here.",
  "sku": "SKU-001",
  "brand": {
    "@type": "Brand",
    "name": "Your Brand"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://yourstore.com/products/product-slug",
    "priceCurrency": "AUD",
    "price": "89.95",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition",
    "hasMerchantReturnPolicy": {
      "@type": "MerchantReturnPolicy",
      "applicableCountry": "AU",
      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
      "merchantReturnDays": 30,
      "returnFees": "https://schema.org/FreeReturn"
    },
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingRate": {
        "@type": "MonetaryAmount",
        "value": "9.95",
        "currency": "AUD"
      },
      "deliveryTime": {
        "@type": "ShippingDeliveryTime",
        "handlingTime": {"@type": "QuantitativeValue", "minValue": 1, "maxValue": 2, "unitCode": "DAY"},
        "transitTime": {"@type": "QuantitativeValue", "minValue": 2, "maxValue": 5, "unitCode": "DAY"}
      }
    }
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "127"
  }
}

Ship it as a JSON-LD script block in the product page template. Every Shopify theme supports this. Most themes ship something close to it and get the details wrong.

How To Verify It Works: The Three-Step Test

Installing schema is half the work. Verifying it works is the other half. The founders who skip the verification step routinely have schema that looks correct in the code and silently fails validation.

Step one: Google’s Rich Results Test. Paste the URL. Read the report. Every error and every warning. Errors mean the schema is invalid. Warnings usually mean a required-for-optimal-parsing field is missing. Fix both.

Step two: Schema.org validator. Google’s tool is opinionated toward its own rich result requirements. Schema.org’s validator is the pure specification. Run the URL through both. A schema block should pass both.

Step three: A live LLM query test. Open ChatGPT. Search for a query that should match your product. “Best natural sunscreen for sensitive skin in Australia” or your category equivalent. Note what gets cited. If you are not cited, note what the cited sources have that you do not.

That third step is the one nobody runs. It is the only step that tests the thing that actually matters. The rich results test verifies the syntax. The LLM query test verifies the outcome.

The Powder Room Guys Case Study

An AU home services brand we worked with in 2025 had schema installed by a previous developer. The Product schema was present. The Organization schema was present. FAQ schema was on the primary category pages.

None of it was passing validation cleanly. Product schema was missing brand as a nested object and had no merchantReturnPolicy. Organization schema had two conflicting sameAs arrays. FAQ schema had unescaped quotes in three questions that broke the JSON.

We spent one afternoon fixing all three. No new content. No new pages. No new backlinks. Just clean schema.

Over the following four months, the brand went from zero AI citations across their category test queries to being cited in four out of five. Their reported result was a 4x lift in AI citation frequency. Not because we changed what they said. Because we made what they said readable.

The FAQ Schema Argument

There is a debate in SEO circles about whether FAQ schema still matters. Google deprecated the rich result for most sites in 2023. Some agencies stopped installing it. Our position is straightforward.

FAQ schema still matters because LLMs still parse it. Perplexity, ChatGPT, Claude, and Gemini all lift structured Q&A directly into answer generation. The mechanism is not the rich result. It is the structured Q&A itself. Removing FAQ schema from your top pages because Google stopped showing the rich result is throwing away one of the highest-leverage GEO signals available.

Keep it. On the pages where it belongs. Ship it clean.

The Order To Ship In

If you are starting from zero, here is the order that produces the fastest citation lift in our experience.

Week one. Audit current schema with the Rich Results Test on your top three product pages and your homepage. Note every error.

Week two. Ship the Product schema block above on every product page. Test each URL. Fix warnings until clean.

Week three. Ship Organization schema on the homepage. Verify sameAs links point to your active social profiles, Trustpilot, Google Business Profile, and any category-specific directories in your vertical.

Week four. Ship FAQ schema on your top three collection pages and top three high-traffic content pages. Test each.

Week eight. Re-run the live LLM query test. Note improvements. Iterate.

The whole play is four weeks of work at maybe five hours per week. It costs less than one month of Meta ads. It pays back across every AI surface for years. And it compounds with the other GEO work we cover in The 2026 State of AI Overviews for Shopify.

The One Thing To Not Do

Do not install schema you cannot maintain. Every schema field is a promise. If your aggregateRating claims 4.8 stars and your actual reviews average 3.2, the mismatch will get caught. If your merchantReturnPolicy claims 30 days and your policy page says 14, someone will notice.

Ship schema that reflects reality. Update it when reality changes. That is the entire discipline.

The founders who win at GEO ship structured signals honestly and consistently. The founders who lose ship them once, forget them, and wonder why their citation rate is flat. Schema is not a set-and-forget install. It is a maintained representation of your business. Treat it that way. If you want a live schema audit, book a 30 min diagnostic.

If you’re an AU or US Shopify founder stuck at the CVR plateau this post describes, we run a free 30 minute diagnostic call. No pitch. No email gate. Just a look at what’s actually breaking in your funnel. Book here.