91.6% of Shopify Stores Ship No FAQ Schema. That's a Problem for AI Shopping

We scanned 2,704 live Shopify storefronts for our State of AI Shopping Readiness study, and the single starkest number in the whole dataset was this: 91.6% of stores ship no FAQPage structured data at all. Not incomplete FAQ schema, not slightly-wrong FAQ schema. None. It was the highest-missing machine-readable signal we measured, ahead of even the gaps in product schema and trust markup.

That does not mean nine in ten stores have no FAQ content. Plenty of them have a visible FAQ page, a shipping policy, a returns page, a product accordion answering whether the thing is vegan or machine washable. The content exists. What's missing is the layer that turns that content into data a machine can read without guessing. And as more shoppers ask an assistant instead of clicking through your site, that gap stops being a tidy-house SEO nicety and starts being the difference between an agent answering confidently from your page and an agent shrugging.

Here's why agents lean on FAQ markup, the difference between an FAQ page and FAQPage JSON-LD, and exactly how to close the gap on Shopify with a metaobject in about half an hour.

What an assistant does when a shopper asks "is this vegan?"

Picture the actual moment. A shopper is in ChatGPT or Gemini or a shopping agent, looking at your product, and they type "is this vegan, and can I return it if it doesn't fit?" The assistant has your product page. Now it has to find the answer.

If your "vegan" answer lives in a paragraph three scrolls down, inside a tab labeled "Details" that only renders its contents after a click, the assistant is working with whatever made it into the server-rendered HTML, parsed as undifferentiated prose. It has to infer that a sentence somewhere is the answer to that specific question. Sometimes it gets it right. Sometimes it hedges. Sometimes it pulls a contradictory line from a marketing block and tells the shopper something wrong.

Now picture the same page with FAQPage JSON-LD. The assistant doesn't infer anything. It reads:

{
  "@type": "Question",
  "name": "Are these shoes vegan?",
  "acceptedAnswer": {
    "@type": "Answer",
    "text": "Yes. The uppers are recycled polyester and the glue is plant-based. No animal products are used anywhere in the shoe."
  }
}

That's a labeled question paired with a labeled answer. No inference, no scraping prose, no guessing which sentence applies. The same logic holds for shipping ("do you ship to Canada?"), returns ("what's the return window?"), and care ("can I machine wash this?"). These are exactly the purchase-blocking questions that decide a sale, and they're the ones assistants get asked constantly.

You're not changing what your store says. You're changing whether a machine can read it without working for it.

An FAQ page is not FAQPage schema

This is the distinction the 91.6% number is really about, and it trips up a lot of merchants who swear they "have an FAQ."

A visible FAQ is the human-facing thing: a page or an accordion with questions and answers that a person reads. Most stores have one somewhere.

FAQPage JSON-LD is a <script type="application/ld+json"> block describing those same questions and answers in Schema.org vocabulary, so a machine reads them as structured data. Almost no stores have this, which is the whole finding.

A visible FAQ without the schema is readable by people and parsed-with-effort by machines. The schema without a visible FAQ is invalid and a manual-action risk (more on that below). What you want is both, generated from one source so they always match. Theme builders rarely emit FAQPage markup on their own, which is most of why the number is so high. The content is there; nobody wired up the data layer. We walked through the mechanics in depth in our guide to FAQ schema on Shopify; this post is about why the gap is so universal and how to close it cleanly with a metaobject.

Why it's the highest-missing signal in the study

A few signals in the study were missing on a majority of stores. FAQPage was missing on the overwhelming majority, and there are concrete reasons it lands worse than product or organization markup.

Themes do emit some product schema. Most Shopify themes ship at least a partial Product JSON-LD block, so even neglected stores clear a low bar there. Almost no theme emits FAQPage on its own, because FAQ content isn't a native Shopify object the way a product or collection is. There's nothing for the theme to auto-render.

FAQ content is unstructured by default. A merchant types answers into a rich-text page or a metafield blob. That's prose, not a list of question-and-answer pairs, so there's no clean structure to project into JSON-LD even if the theme wanted to.

The 2023 rich-result cutback killed the incentive. Google showed FAQ rich results everywhere, then pulled them back hard in 2023. A lot of people concluded FAQ markup was dead and stopped adding it. The Google blue-link rich result did mostly go away. The value moved to assistants, which read the same markup and quote answers directly, but that shift was quiet and the habit of adding the schema never recovered.

Put those together and you get a signal that no theme adds for you, that your content isn't structured to support, and that the SEO world stopped caring about right when AI shopping started caring more. That's how you end up at 91.6%.

Build product FAQs as a metaobject

The right way to fix this on Shopify is a metaobject, not a copy-pasted JSON-LD snippet hardcoded into your theme. Hardcoded schema rots the moment someone edits the visible answer and forgets the markup. A metaobject keeps the content in one editable place and lets both the visible accordion and the structured data read from it, so they can't drift.

Define an FAQ metaobject. In Settings → Custom data → Metaobjects, create a definition called Product FAQ with two fields:

• question: single line text
• answer: multi-line text (or rich text if you want formatting, though plain text parses most cleanly)

Then add a metafield on the Product so each product can point at a list of these entries. Under Settings → Custom data → Products, add a metafield of type Metaobject (list) referencing your Product FAQ definition, named something like custom.faqs.

Now a merchandiser opens any product, attaches the three or four questions that actually matter for that item, and they're done. Fit and sizing for apparel, compatibility for electronics, ingredients for food and beauty, care instructions for anything washable. No theme code, no developer in the loop for content edits. This is the same metaobject pattern we lean on for richer product data generally, and it pays off the same way: structured content you can render anywhere, including trust signals like warranty and return terms.

Wire the metaobject into FAQPage JSON-LD

With the content structured, the theme work is small. In your product template (main-product.liquid in most Online Store 2.0 themes, or a dedicated snippet you include), render two things from the same metafield: a visible accordion and the JSON-LD block.

The structured data loop looks like this:

{% if product.metafields.custom.faqs.value != blank %}
  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "FAQPage",
    "mainEntity": [
      {%- for faq in product.metafields.custom.faqs.value -%}
        {
          "@type": "Question",
          "name": {{ faq.question.value | json }},
          "acceptedAnswer": {
            "@type": "Answer",
            "text": {{ faq.answer.value | json }}
          }
        }{%- unless forloop.last -%},{%- endunless -%}
      {%- endfor -%}
    ]
  }
  </script>
{% endif %}

Two details that save you from invalid markup. Pipe every dynamic value through the json filter, which escapes quotes, newlines, and special characters so a stray apostrophe in an answer doesn't break the whole block. And guard the whole thing with the if ... != blank check so products with no FAQs emit no empty FAQPage, which would itself be invalid. Render the visible accordion from the exact same for loop right above or below it, so the human-readable section and the schema are literally generated from one list. They cannot disagree.

Validate it, and the honest caveat

Once it's live, validate. Two checks:

1. Schema.org validator confirms the JSON-LD is structurally valid. Paste a product URL and look for a clean FAQPage with your questions parsed as Question and Answer nodes.
2. Google's Rich Results Test confirms Google parses it. It may report that the FAQ result type isn't eligible for a rich result, and that's fine. You're validating that the markup is read correctly, not chasing a blue-link feature Google mostly retired.

Now the caveat, because this topic is flooded with posts promising things they can't deliver. FAQPage schema is not a documented ranking or citation lever for AI assistants. Adding it will not make ChatGPT cite you, will not guarantee an agent quotes your answer, will not move you up a result list. There is no public evidence that any assistant boosts pages for carrying the markup.

What it does, reliably, is make your answers unambiguous to a parser. A labeled question-and-answer pair is easier for a machine to extract correctly than the same words inside a collapsed accordion or a wall of marketing copy. That's the honest claim: better parsing, lower chance of an assistant misreading or missing your answer. It's machine-readable hygiene, the same way you'd want clean product schema with valid offers and GTINs. Direction, not a number. Anyone quoting you a conversion lift from FAQ schema is making it up.

A 30-minute implementation plan

If you want to go from "we're in the 91.6%" to shipped this afternoon, here's the order:

1. (5 min) Create the Product FAQ metaobject definition with question and answer fields.
2. (2 min) Add a custom.faqs metafield of type Metaobject (list) to the Product resource.
3. (10 min) Add the FAQPage JSON-LD loop and a matching visible accordion to your product template, both reading from custom.faqs. Use the json filter and the blank guard.
4. (10 min) Fill in real, page-specific FAQs for your top 10 products. Start with whatever your support inbox answers most. Fit, shipping, returns, compatibility, care.
5. (3 min) Validate one product URL in the Schema.org validator and the Rich Results Test.

Do the top 10 products first, confirm it parses, then roll the rest out over time. The visible FAQ section earns its own keep by answering real pre-purchase questions on the page; the schema is the small extra step that makes those answers machine-readable.

If you're not sure whether your store is in the 91.6% or the 8.4%, the fastest way to find out is to scan it. Our free AI-readiness checker looks for FAQPage markup along with the rest of your structured data and tells you exactly what an assistant sees when it lands on your pages.