How to Get Your Store Recommended by AI Engines (Structured Data Guide)

You've installed a review app. You've collected 50+ reviews with a 4.7-star average. You ask ChatGPT to recommend products in your niche, and your store is nowhere. Perplexity skips you entirely. Google AI Overview mentions a competitor instead. Meanwhile, that competitor has the exact same number of reviews as you. The difference? Their structured data actually works.

Here's what most store owners miss: structured data is not just about getting star ratings in Google search results. It's the language AI engines use to understand what you sell, how customers rate you, and whether to recommend you. When ChatGPT, Perplexity, Google AI, or Gemini evaluate your store, they parse your JSON-LD markup to build a picture of your products. Without valid structured data, they're guessing. And AI engines that have to guess tend to skip you entirely.

In our data from 1,200+ store audits, 43% of stores that have a review app installed are not outputting valid review schema markup. The app is collecting reviews and displaying them on the product page, but the structured data that tells AI engines about those reviews is missing, malformed, or invalid. That's nearly half of all stores with reviews, invisible to AI for a completely fixable reason.

Why Structured Data Is the Foundation of AI Visibility

Traditional search engines used structured data as a bonus, a way to generate rich snippets. AI engines treat it differently. For ChatGPT, Perplexity, Gemini, and Google AI, structured data is primary input. It's how these systems determine facts about your products: the name, price, availability, brand, and customer satisfaction.

Think about it from the AI's perspective. When someone asks “what's the best leather wallet under $100?”, the AI engine needs to compare products across thousands of stores. It can try to read your product descriptions and parse meaning from marketing copy. Or it can read your JSON-LD and instantly know: this product costs $59, it's in stock, it has 127 reviews with a 4.7-star average, and it's made by a specific brand. Which source do you think the AI trusts more?

Structured data gives AI engines machine-readable facts. Everything else on your page is interpretation. Stores with complete, valid structured data are giving AI engines exactly what they need to make confident recommendations. Stores without it are hoping the AI figures things out on its own.

What Valid AggregateRating Schema Looks Like

Review schema uses the AggregateRating type within a Product schema object. It tells any system reading it: “This product has X reviews with an average rating of Y out of 5 stars.” Here's the JSON-LD structure that both Google and AI engines expect:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Classic Leather Bifold Wallet",
  "image": "https://yourstore.com/wallet.jpg",
  "description": "Handmade full-grain leather wallet",
  "brand": {
    "@type": "Brand",
    "name": "Your Brand"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "127",
    "bestRating": "5",
    "worstRating": "1"
  },
  "offers": {
    "@type": "Offer",
    "price": "59.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

The critical fields inside aggregateRating are ratingValue (the average score), reviewCount (the total number of reviews), and bestRating/worstRating (the scale). All four must be present and valid. Miss one, and AI engines may discard the entire block.

This is the minimum for review data, but it's not the only structured data that matters for AI Visibility. More on that below.

How Major Shopify Review Apps Handle Schema

Each review app handles schema differently. Understanding how your specific app works is the first step to diagnosing why AI engines can't see your reviews.

Judge.me

Judge.me injects JSON-LD schema automatically on product pages. It adds both the AggregateRating and individual Review objects. For most stores, Judge.me's schema works out of the box, making it one of the most AI-ready review apps available.

Common issue: If you also have Shopify's built-in product schema (from your theme), you can end up with duplicate Product schema blocks on the same page. One from the theme (without reviews) and one from Judge.me (with reviews). AI engines may parse the one without reviews, or discard both due to the conflict.

Fix: Judge.me has a setting under “Display > SEO Snippet” where you can choose whether Judge.me injects its own Product schema or adds the aggregateRating to your existing theme schema. If your theme already has Product schema, select the “Append to existing” option to avoid duplication.

Loox

Loox focuses on photo reviews and handles schema through its widget. When the Loox widget is active on a product page, it adds AggregateRating data to the page's schema.

Common issue: Loox's schema injection depends on the widget being present and loaded on the page. If you've customized your theme and the Loox widget isn't rendering (even if reviews show via API), the schema may not be injected. This is the “app installed but schema missing” scenario. Reviews appear visually, but AI crawlers can't see them.

Fix: In your Loox dashboard, go to Settings > SEO and confirm that “Add SEO Rich Snippets” is enabled. If it's enabled but schema still isn't appearing, check whether the Loox widget block is actually present in your theme's product template. Theme updates or template changes can remove app blocks without warning.

Stamped.io

Stamped provides schema through both its widget and a separate SEO snippet feature. The SEO snippet is a separate piece of code from the visible review widget.

Common issue: Stamped's SEO snippet must be installed separately from the review widget. Many store owners install the visible widget (star ratings and reviews you can see) but skip the SEO snippet installation (the invisible schema code). The result: reviews display on the page, but no structured data exists for AI engines or Google to read.

Fix: Follow Stamped's documentation to install the SEO snippet code, which is separate from the main widget. It goes in your theme's product template and adds the JSON-LD schema. After installation, verify with the Rich Results Test.

Yotpo

Yotpo handles schema server-side for stores on their paid plans. The schema is injected based on review data stored on Yotpo's servers, not generated client-side by JavaScript.

Common issue: Yotpo's free plan may not include schema markup. It's a paid feature on some plan tiers. Additionally, Yotpo's schema can conflict with theme-generated Product schema, creating duplicate objects similar to the Judge.me issue described above.

Fix: Check your Yotpo plan to confirm schema is included. If it is, use the Rich Results Test to verify it's appearing correctly. If you have duplicates, you'll need to either disable your theme's built-in Product schema or configure Yotpo to merge its data into the existing schema rather than creating a separate block.

The Three Most Common Schema Problems

1. App Installed but Schema Missing

This is the most common problem: the review app displays reviews on the page, but no structured data is present in the page's source code. We see this in 27% of stores that have review apps installed.

Why it happens: The review widget loads via JavaScript, but the schema markup was never installed, was removed during a theme update, or requires a separate installation step that was skipped. Some apps render reviews client-side (in the browser via JavaScript) but need the schema injected server-side (in the HTML source) to be visible to AI crawlers.

How to diagnose: View the page source (Ctrl+U or Cmd+U) and search for "aggregateRating". If you can see reviews on the page but this string doesn't appear in the source code, your schema is missing. AI engines like ChatGPT and Perplexity rely on this data during their crawl passes, so if it's not in the HTML, it effectively doesn't exist for AI recommendation purposes.

2. Duplicate Product Schema

Your theme outputs one Product JSON-LD block (without reviews), and your review app outputs another Product JSON-LD block (with reviews). Google and AI engines see two conflicting Product objects for the same page. They may use the one without reviews, or discard both as unreliable.

Why it happens: Shopify themes (especially Dawn-based themes) include their own Product structured data in the theme code. Review apps also inject Product structured data to include the aggregateRating. Neither knows about the other, creating duplication.

How to diagnose: In the page source, search for "@type": "Product" or "@type":"Product". If you find it more than once, you have duplicate Product schema. Count the occurrences. There should be exactly one.

How to fix: The cleanest solution is to remove the Product schema from your theme code and let the review app handle it entirely (most review apps output complete Product schema, not just the rating). In your theme, look for the JSON-LD script in product.liquid, main-product.liquid, or a structured-data.liquid snippet file. Comment it out and verify that the review app's schema covers all required Product fields.

Alternatively, configure your review app to append its aggregateRating to the existing theme schema instead of creating a new block. Judge.me and some other apps support this option in their settings.

3. Invalid or Incomplete Schema

The schema exists but contains errors: missing required fields, wrong data types, or invalid values. Both Google and AI engines ignore invalid schema entirely, so even a small error means you're invisible.

Common errors we find:

• ratingValue is “0” or empty (product has no reviews yet but schema still outputs)
• reviewCount is “0” (same issue: outputting an AggregateRating with zero reviews is invalid)
• ratingValue exceeds bestRating (e.g., ratingValue is “4.7” but bestRating is missing, defaulting to “1”)
• price is missing or “0.00” in the associated Offer schema
• The @context field is missing or misspelled

How to fix: The schema should only output aggregateRating when a product has at least 1 review. Most review apps handle this correctly, but some inject the schema structure with empty values on products with no reviews. If this is happening, check the app's settings for a “minimum reviews for schema” option, or contact the app's support team.

Beyond Reviews: Structured Data That Makes Your Entire Store AI-Readable

Review schema is critical, but it's only one piece of the AI Visibility puzzle. AI engines don't just want to know about your ratings. They want to understand your entire store: what you sell, who you are, what questions you answer, and how your site is organized. Here are the other schema types that directly impact whether AI engines recommend you.

Product Schema

The Product schema wrapping your AggregateRating is itself a powerful signal. Complete Product schema includes name, description, image, brand, SKU, price, currency, and availability. When Perplexity or ChatGPT needs to recommend a specific product, this schema gives them everything required to make that recommendation with confidence. Incomplete Product schema forces AI engines to scrape and interpret your page content, which is slower, less reliable, and less likely to result in a recommendation.

Organization Schema

Organization schema tells AI engines who you are as a business: your name, logo, URL, social media profiles, contact information, and founding date. This helps AI engines distinguish your brand from competitors and builds the entity profile that AI systems use when deciding which stores to cite. Without it, you're a faceless URL. With it, you're a recognized brand.

FAQ Schema

FAQPage schema is a direct pipeline to AI responses. When someone asks ChatGPT a question that matches one of your FAQs, properly structured FAQ data makes it trivially easy for the AI to pull your answer and cite your store. Add FAQ schema to product pages (addressing common questions about materials, sizing, shipping) and to dedicated FAQ pages. This is one of the fastest ways to increase your AI Visibility.

BreadcrumbList Schema

BreadcrumbList schema tells AI engines how your store is organized: Home > Category > Subcategory > Product. This helps AI systems understand your product taxonomy and category relationships. When an AI engine needs to recommend stores that sell a specific product type, your breadcrumb data helps it categorize you correctly. Most Shopify themes include this by default, but it's worth verifying.

The pattern is clear: every schema type you add gives AI engines more structured facts about your store. More facts mean more confidence. More confidence means more recommendations. Stores that treat structured data as an AI Visibility strategy (not just an SEO checkbox) are the ones showing up in AI responses.

Testing Your Structured Data

Google's Rich Results Test at search.google.com/test/rich-results is the starting point for validating your schema. Enter a product page URL and it shows you exactly what structured data it finds, whether it's valid, and what errors exist.

Step-by-Step Validation Process

1. Go to the Rich Results Test and enter a product page URL (pick a product that has reviews).
2. Wait for the test to complete. It renders the page as Google sees it, including JavaScript-generated content.
3. Look for a “Product” result in the detected items. Click on it to expand the details.
4. Verify that aggregateRating appears with the correct ratingValue and reviewCount.
5. Check for any warnings (yellow) or errors (red). Warnings won't prevent rich results but are worth fixing. Errors will block rich results and signal invalid data to AI crawlers too.
6. If the Product item shows no aggregateRating, your review schema is not being detected by Google or AI engines.

Important for AI Visibility: The Rich Results Test renders JavaScript, so it will see schema that's injected client-side. However, AI crawlers (like those powering ChatGPT and Perplexity) may not always execute JavaScript when indexing. For maximum AI Readiness, your schema should be in the server-rendered HTML source (view page source), not only injected by JavaScript after page load. This is also a factor when considering your broader Shopify SEO and AI Visibility setup.

Also Test with Schema Markup Validator

Google's Schema Markup Validator at validator.schema.org checks the technical validity of your schema against the Schema.org specification. The Rich Results Test checks whether Google can generate a rich result from your data. The Schema Markup Validator checks whether the underlying structure is technically correct. Use both, because AI engines rely on the Schema.org spec to parse your data.

Schema for Products Without Reviews

Should you add review schema to products that don't have any reviews yet? No. Google's guidelines explicitly state that AggregateRating should only be present when there is at least one review. Outputting an aggregateRating with a reviewCount of “0” violates structured data guidelines and can result in penalties. It also signals unreliable data to AI engines, which hurts your broader AI Visibility.

Your Product schema should still be present for products without reviews. It just shouldn't include the aggregateRating property until the first review comes in. Most review apps handle this correctly by conditionally including the rating data only when reviews exist. Verify this by testing a product URL that has no reviews in the Rich Results Test.

Advanced: Adding Review Schema Manually

If your review app doesn't handle schema correctly and you can't switch apps, you can add review schema manually to your Shopify theme. This requires editing your theme's Liquid code.

In your product template (usually sections/main-product.liquid or templates/product.liquid), locate the existing Product JSON-LD block. Add the aggregateRating property using Liquid to pull data from your review app's metafields or API.

The approach depends on your review app. Most apps store review data in product metafields. Judge.me, for example, stores the rating in product.metafields.judgeme.rating. You can reference these metafields in your Liquid code to build the schema dynamically.

Warning: Manual schema requires maintenance. If you change review apps, the metafield references break. If you edit the schema incorrectly, you could introduce errors that prevent all structured data from being recognized by Google and AI engines alike. Only go this route if your app's built-in schema is genuinely broken and the app's support team can't fix it.

Structured Data Checklist for AI Readiness

Use this checklist to verify your structured data is working for both search engines and AI engines:

• Your review app's SEO/schema setting is enabled.
• Rich Results Test shows a valid Product result with aggregateRating for a product with reviews.
• There is exactly one Product JSON-LD block per product page (no duplicates from theme + app).
• ratingValue matches the actual average rating displayed on the page.
• reviewCount matches the actual number of reviews displayed.
• Products with zero reviews do NOT output aggregateRating.
• The schema includes bestRating (“5”) and worstRating (“1”).
• The schema includes valid offers with price, priceCurrency, and availability.
• Organization schema is present on your homepage with brand name, logo, and contact info.
• FAQ schema is present on product pages and FAQ pages.
• BreadcrumbList schema is present across your store.
• All schema is server-rendered in the HTML source, not only injected by JavaScript.
• Schema Markup Validator shows no errors.

Check Your AI Visibility

Structured data problems are invisible by definition. You can't see them by browsing your store. Your reviews look fine on the product page, your site looks great on mobile, everything seems to work. But under the hood, the data that AI engines actually read might be missing, broken, or conflicting with itself.

Our free AI Visibility audit checks your structured data automatically. It scans every product page for valid review schema, detects duplicates, flags invalid values, and tells you exactly what to fix for your specific review app. You'll see your AI Visibility Score and know precisely where you stand compared to competitors.

Most stores can fix their structured data issues in under an hour. The impact lasts as long as your store is online.

The Competitive Advantage of AI-Optimized Structured Data

Here's the reality: 43% of Shopify stores with review apps have broken schema. Most stores have no Organization schema, no FAQ schema, and no strategy around structured data beyond whatever their theme shipped with by default. That's the current state of AI Readiness in ecommerce.

This is your opportunity. Stores with complete, valid structured data are speaking the language that AI engines understand natively. When ChatGPT needs to recommend a product, it reaches for stores where the data is clean, complete, and trustworthy. When Perplexity compares options for a shopper, it cites stores where the facts are machine-readable. When Google AI generates an overview, it pulls from stores with proper schema.

The 20-35% increase in click-through rate from Google rich results is just the beginning. The bigger prize is being the store that AI engines recommend by name. And that starts with structured data that actually works.

If you've been collecting reviews but AI engines don't know about them, fix this today. The investment is an hour of your time. The return is every AI recommendation you've been missing, and every Google search click on top of that.