AI Visibility for Ecommerce: The Product Data AI Answers Use

AI visibility for an online store depends on product data that engines can read and match: price, stock, identifiers, ratings, shipping and returns, in your page markup and your product feeds. Most stores get the basics right and miss the rest. On 46 store product pages with product markup, every one stated price and availability. Only 15 carried a GTIN, 9 a return policy and 6 shipping details.

Those missing fields are what shopping questions filter on: "under $50 with free returns", "best rated", "ships to Canada". By the end of this post you'll know which product fields AI shopping answers rely on, where your store stands, how page markup and feeds fit together, and what to fix first. A script checks any product page in a few seconds.

Data used: 60 Shopify stores found in a random sample of 6,000 domains from the Tranco list (ranks 1,001–200,000, seed 20261010), one product page each, fetched as plain HTML without JavaScript on 2026-10-29. 52 product pages loaded; 46 had Product structured data. Stores aren't named. All stores in the sample run on one platform, so treat platform defaults as part of the finding.

How AI Shopping Answers Get Product Facts

Engines answer product questions from two sources: the product pages they crawl and the product feeds merchants submit. Both matter, and they should say the same thing.

• Pages. When an engine searches the web for "best trail running shoes under $120", it reads product and review pages. Structured data on a product page states the price, stock, identifiers and policies in fields a machine can't misread. Google's documentation on merchant listing structured data lists shipping details and return policy among the recommended properties.
• Feeds. Google takes product data through Merchant Center, with a product data specification that includes identifiers such as GTIN. OpenAI's commerce documentation describes a structured product feed so ChatGPT can index and display products with up-to-date price and availability; its feed format has fields for GTIN, shipping, returns and reviews.

A product that's only described in prose, or whose page and feed disagree on price, gives an engine less to work with than a competitor whose data is complete and consistent.

What 46 Product Pages Actually Exposed

Here's how often each field appeared in the Product structured data of the 46 pages that had it:

The pattern is clear. Fields the store theme fills in automatically (price, stock, image, description) are universal. Fields the merchant has to supply or connect (identifiers, review data, policies) are mostly absent. One store in 46 had all eight.

Three more results from the same 52 pages:

• 6 of 52 product pages had no Product structured data at all.
• 47 of 52 showed a price in the raw HTML text, readable without running JavaScript.
• 2 of 52 stores blocked an AI crawler in robots.txt (GPTBot on both, ClaudeBot and Google-Extended on one). None blocked OAI-SearchBot or PerplexityBot, the crawlers used for search answers.

💡 Rule of thumb: if a shopping question has a filter in it ("under $50", "free returns", "in stock"), the product that states that fact in a field beats the one that states it in a paragraph.

The Gaps That Cost Shopping Answers

Four gaps cover most of what's missing, and each maps to a kind of question your products can't currently qualify for.

GTIN: two-thirds of products can't be matched

A GTIN (the barcode number) lets an engine recognise that your listing and a review site's page describe the same item. Without one, the engine has to match on title text, and similar product names get confused. If you resell branded goods, the GTIN already exists on the box. If you make your own products, Google's feed specification explains when an item has no GTIN and what to send instead.

Returns and shipping: the policies live on a separate page

Every store has a returns page and a shipping page. Only 9 and 6 of 46 connected them to the product in structured data. Google documents return policy markup at the organisation level, so one block on your site can cover every product. It's one of the cheapest fixes on this list.

Ratings: reviews exist, the markup doesn't

Most stores collect reviews through an app. Only 16 of 46 product pages exposed an aggregate rating in markup, and 5 included individual reviews. If your review app renders reviews in the browser only, an engine reading raw HTML sees none of them. Our guide to Product aggregateRating schema covers the markup, and Google's rules on self-serving reviews.

Feeds that disagree with pages

This one doesn't show in a page crawl, but it's where errors come from. A sale price in the feed and a full price on the page, or "in stock" in one and "sold out" in the other, gives an engine two answers. In our own brand's AI accuracy audit, every error engines made was about price or plans. Generate the page markup and every feed from the same product database.

Fix Product Data in This Order

Start with the fixes that cover every product at once, then work product by product on your best sellers.

1. Return policy and shipping at the organisation level. One structured-data block each, site-wide, per Google's shipping policy and return policy documentation. Covers every product. None of the 46 pages used organisation-level shipping markup.
2. GTINs in the product data. Add them to the catalogue, then let theme markup and feeds pick them up.
3. Ratings in the raw HTML. Make sure your review app outputs the aggregate rating server-side, not only after JavaScript runs.
4. Feeds. Submit a complete Merchant Center feed, and add an OpenAI product feed where it's available to you, from the same source as the pages.
5. Buying guides for your categories. "Best [product] for [use]" pages with real specs and prices answer the comparison questions engines get, and give them your products to cite. List pages decide many shortlists, as our listicle data shows.
6. Check AI crawler access, especially if you use a firewall or bot-protection service. Two stores in our sample blocked a model-training crawler; that's a choice, but blocking a search crawler removes you from that engine's answers.

Check a Product Page Yourself

This script fetches one product page and lists the Product structured-data fields present and missing, whether the price is visible as text without JavaScript, and which AI crawlers robots.txt blocks for that URL. Standard library only.

#!/usr/bin/env python3
"""What does one product page tell AI shopping answers? Lists the Product structured-data fields
present and missing in the raw HTML (no JavaScript), checks the price is visible as text, and
whether robots.txt lets the main AI crawlers in.

Usage: python3 product_ai_check.py https://shop.example/products/blue-mug
"""
import json, re, sys, urllib.request, urllib.robotparser
from html import unescape
from urllib.parse import urlsplit

UA = "Mozilla/5.0 (compatible; product-ai-check/1.0)"
FIELDS = [  # (label, pattern in the Product JSON-LD, why it matters)
    ("price + currency", r'"price(Currency)?"', "every shopping answer quotes it"),
    ("availability", r'"availability"', "'in stock' filters"),
    ("brand", r'"brand"', "brand + product questions"),
    ("GTIN", r'"gtin(8|12|13|14)?"\s*:\s*"?\d', "matches the item across feeds and sellers"),
    ("SKU or MPN", r'"(sku|mpn)"', "identifies variants"),
    ("ratings", r'"aggregateRating"', "'best rated' questions"),
    ("reviews", r'"review"', "quotable buyer experience"),
    ("return policy", r'MerchantReturnPolicy|"hasMerchantReturnPolicy"', "'free returns' questions"),
    ("shipping", r'"shippingDetails"|OfferShippingDetails|hasShippingService', "'free shipping' and delivery questions"),
]

def get(url):
    req = urllib.request.Request(url, headers={"User-Agent": UA})
    with urllib.request.urlopen(req, timeout=20) as r:
        return r.read(3_000_000).decode("utf-8", "replace")

def main(url):
    html = get(url)
    blocks = re.findall(r"<script[^>]+application/ld\+json[^>]*>(.*?)</script>", html, re.I | re.S)
    product = [b for b in blocks if re.search(r'"@type"\s*:\s*\[?\s*"(Product|ProductGroup)"', b)]
    blob = " ".join(product)
    text = re.sub(r"\s+", " ", unescape(re.sub(r"(?s)<[^>]+>", " ", re.sub(r"(?is)<(script|style)[^>]*>.*?</\1>", " ", html))))
    print(f"Product structured data: {'found' if product else 'MISSING'} ({len(product)} block(s))")
    missing = []
    for label, pat, why in FIELDS:
        ok = bool(re.search(pat, blob if label not in ("return policy", "shipping") else html))
        print(f"  {'✓' if ok else '✗'} {label:<17} {why}")
        missing += [] if ok else [label]
    priced = re.search(r"([$€£₹]|USD|EUR|GBP)\s?\d", text)
    print(f"Price visible as text without JavaScript: {'yes' if priced else 'NO'}")
    origin = f"{urlsplit(url).scheme}://{urlsplit(url).netloc}"
    rp = urllib.robotparser.RobotFileParser(origin + "/robots.txt"); rp.read()
    blocked = [b for b in ("OAI-SearchBot", "GPTBot", "PerplexityBot", "ClaudeBot", "Google-Extended") if not rp.can_fetch(b, url)]
    print("AI crawlers blocked for this URL: " + (", ".join(blocked) or "none"))
    if missing:
        print("\nAdd to the page markup and to your product feeds: " + ", ".join(missing))

if __name__ == "__main__":
    main(sys.argv[1]) if len(sys.argv) == 2 else sys.exit(__doc__)

On one store from the sample:

Product structured data: found (2 block(s))
  ✓ price + currency  every shopping answer quotes it
  ✓ availability      'in stock' filters
  ✓ brand             brand + product questions
  ✗ GTIN              matches the item across feeds and sellers
  ✓ SKU or MPN        identifies variants
  ✓ ratings           'best rated' questions
  ✗ reviews           quotable buyer experience
  ✗ return policy     'free returns' questions
  ✗ shipping          'free shipping' and delivery questions
Price visible as text without JavaScript: yes
AI crawlers blocked for this URL: none

Add to the page markup and to your product feeds: GTIN, reviews, return policy, shipping

Return policy and shipping are searched in the whole page, because they're often declared in a separate block. Python's robots parser treats a 401 or 403 on robots.txt as "everything blocked", so check those by hand.

How BugViso Builds an Ecommerce AI Visibility Plan

BugViso's AI Visibility Tracker recognises an online store from its site and tailors the "what to do" plan to it. The store plan's product-data item covers a complete Merchant Center feed (GTINs, attributes, price and stock), page markup that matches the feed, product reviews and Q&A, and AI shopping feeds where available. It points to Product, Offer, AggregateRating and MerchantReturnPolicy markup, to store review sites such as Trustpilot and Google seller reviews, and to the YouTube reviews, Reddit threads and buying guides that answer comparison questions.

Each item is tied to a number from your own report: the shopping questions where rivals were named instead of you, the sources those answers cited, and any wrong prices engines stated about your products. The fact check compares what engines say with your own site. The store plan is part of the AI visibility tracker.

Ecommerce AI Visibility Mistakes

Trusting the theme's markup. It covers price and stock. It doesn't cover identifiers, policies or reviews, which is where the shopping filters are.

Reviews that only exist after JavaScript. If the rating isn't in the raw HTML, assume crawlers reading raw HTML don't see it.

A feed and a page that disagree. Generate both from one source, and recheck after every sale.

Blocking AI crawlers by accident. Bot-protection services can block search crawlers you meant to allow. Check the live response, not just robots.txt.

No buying guides. Product pages answer "what is this"; guides answer "which should I buy". Engines need both to recommend you.

Frequently Asked Questions

How do I get my products recommended by ChatGPT?

Make your product data complete and consistent: price, availability, brand, GTIN, ratings, shipping and returns in page markup and in your product feeds. OpenAI documents a product feed for ChatGPT. Then publish buying guides and earn reviews on the sites engines cite for your category.

Does product schema help AI search visibility?

It makes your product facts unambiguous to any system that reads them, including search engines and AI answers that use search. In our sample, every product page with markup stated price and stock, but most lacked the fields shopping filters use: GTIN, returns, shipping and ratings.

Do AI shopping answers use Google Merchant Center data?

Google uses Merchant Center data for its shopping experiences, and ChatGPT accepts a separate product feed described in OpenAI's commerce documentation. Keep both feeds and your page markup in sync, from the same product database.

What product information do AI engines need?

The facts buyers filter on: price and currency, stock, brand, an identifier such as GTIN, ratings and reviews, shipping costs and destinations, and the return policy. Only 1 of 46 product pages in our sample stated all of them in structured data.

Should an online store block AI crawlers?

Not the search crawlers if you want to appear in AI answers. In our sample, 2 of 52 stores blocked a model-training crawler such as GPTBot and none blocked OAI-SearchBot or PerplexityBot. Decide crawler by crawler, then check your firewall doesn't override robots.txt.

Fill the Fields Shopping Questions Filter On

Price and stock are table stakes; GTINs, return and shipping policies and server-rendered ratings are what let a product qualify for filtered shopping questions, so add them site-wide first and keep feeds in sync with pages. BugViso's AI visibility tracking shows which shopping questions name rivals instead of your store and what to fix, product data first.