Review Schema for a Dropshipping Store

I use review schema to mark up 1 review or the average of many. Google can read the rating and may show it as stars in search results. On a Shopify dropshipping store, it works when one source writes the markup and only your shoppers' reviews feed it.

I've run a niche-products Shopify store, and the star rating under a product title is the first thing I check on any store.

This guide helps you trace those stars to their source. You'll publish a rating Google can read without overstating the reviews you've earned.

Key takeaways

What is review schema?

Review and AggregateRating markup sits inside a Product object alongside its offers. Google's review snippet guidelines require the marked-up reviews to represent what shoppers can see and submit on the page.

Review schema describes one review or a combined rating in a format Google can read. A Review covers one person's opinion. An AggregateRating summarizes several ratings or reviews, while Google decides whether valid markup earns stars and other review details in search.

Both types sit inside the Product schema for the item being reviewed. A Review needs an author and reviewRating. An AggregateRating needs ratingValue plus either ratingCount or reviewCount.

The two types handle different levels of review information:

‍

Markup describes review content that shoppers can already see. If a page has no visible review, neither type has an honest rating to describe.

Why dropshipping stores get review stars wrong

Your theme, review app, and custom code can each publish a rating for the same product. An import app may also bring in supplier reviews. The result is accurate when one source writes the rating and counts eligible reviews.

That division of labor is easy to miss because the stars can look correct in the browser. The page source may contain a different rating or count. A second Product block can carry another count. Imported reviews can also make the score describe feedback your store didn't collect.

I start the audit with the visible widget because it shows what a shopper sees. Page source identifies which theme, app, or custom script made the markup. A store that uses one source and collects every review itself avoids most of this problem. Other stores should record every Product and aggregateRating block before changing one.

The Star-Source Audit

The Star-Source Audit fixes review markup through five stages, from finding its writer to checking Google's reports. Each stage produces the information the next stage needs.

The audit follows this order:

1. Find: Identify every block that writes review markup.
2. Keep: Choose one source and disable the duplicate.
3. Count: Remove reviews that came from another website.
4. Match: Align the rating and count with the visible page.
5. Test: Validate the result and monitor indexed pages.

Start with the code your store publishes today.

Stage 1: Find what writes your review markup

Visible stars and readable rating markup are separate parts of a Shopify product page. Dawn can display the standard Shopify rating field, while its Product JSON-LD comes from Shopify's structured_data filter. Shopify's documented filter output lists product and offer fields but no rating field.

Shopify tells rating apps to update the standard reviews.rating field and tells themes to use it for the average shown on the page. Those instructions explain how stars can appear even when that theme's Product block has no aggregateRating.

Run the source check on a product page that already shows stars:

1. Open the product page in a browser.
2. Use the page-source view because the Elements panel shows changed code.
3. Search for ld+json and count the script blocks.
4. Search for aggregateRating and note which block contains it.
5. Record its writer and the rating count it publishes.

The writer may be your theme, review app, or custom code. Themes differ, and Shopify can change its filter, so your page source settles the question for your store.

Stage 2: Keep one source writing the ratings

Choose one source for the product and rating markup, then disable the other source. Judge.me documents a switch for its schema when another search engine optimization app provides the code. Loox also tells Yoast users to disable Loox SEO to avoid conflicts.

Two Product blocks can disagree on the rating, count, or offer. When they publish different values for the same property, at least one conflicts with the visible page. Google requires structured data to represent the page truthfully. Because Google gives no selection rule for conflicting blocks, I publish one accurate block.

Use one shared rule to decide. Keep the app's output when it contains the visible offer, rating, and count. Disable it when another block already contains those correct values:

• Disable Judge.me schema when another source already provides it.
• Disable Loox SEO when Yoast provides the structured data.
• Keep the block whose rating and offer match the visible details.

Imagine your theme prints the price in one Product block. Your review app prints a 4.6 rating and 38 reviews in another. The source shows which setting controls each block. If each block holds only part of the truth, ask a developer for one Product graph that contains the visible offer and eligible rating. The finished page should disable the extra output.

Stage 3: Count only eligible reviews

Count ratings your shoppers gave on your site, and leave reviews copied from another website out of the markup. Google says ratings must come directly from users and bars sites from aggregating reviews from other websites.

AliExpress imports come from another website, so I apply Google's rule against aggregating reviews from other sites.

Judge.me marks AliExpress imports as unverified and excludes them from its Google Shopping ratings feed. Verify the page markup directly. Export or filter the app's reviews by origin, count the reviews collected on your store, and compare that total with reviewCount.

Use the source of each review to set the eligible count:

‍

Google also makes store-controlled reviews under Organization or LocalBusiness ineligible for stars. It bars fake and undisclosed incentivized reviews too. A real customer review of the product on its product page is a different case.

Our guide to ecommerce product reviews covers whether to import or collect reviews and how to handle disclosure. The practical limit is simple. If you can't prove your shopper left the review on your site, don't feed it into the product rating markup.

Stage 4: Match the markup to the page

Publish one aggregate rating that equals the visible score and count, then add individual reviews only alongside that aggregate. Google requires marked-up reviews to be available on the page. It also requires an aggregate rating when you include several individual reviews.

ratingCount counts ratings, while reviewCount counts people who submitted a review with or without a rating. Choose the field that matches what your widget reports. Google sets no minimum count here, so accuracy matters more than size.

This illustrative JSON-LD is a shape to verify inside your chosen source. Use one producer for the final markup. An individual review also needs a valid person or team name for its author.

The example joins the visible product, offer, aggregate rating, and one review:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Heavyweight Pullover Hoodie",
  "offers": {
    "@type": "Offer",
    "price": "54.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "bestRating": "5",
    "reviewCount": "38"
  },
  "review": {
    "@type": "Review",
    "author": {
      "@type": "Person",
      "name": "Jordan Lee"
    },
    "datePublished": "2026-09-18",
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": "5",
      "bestRating": "5"
    },
    "reviewBody": "The fabric feels substantial and the fit matches the size chart."
  }
}

The numbers are illustrative. Replace them with the values shoppers can see. Keep the offer tied to the same product record. When a product has variants, ProductGroup schema puts shared review information on the parent group.

The same review rules apply when aggregateRating supports merchant listings. Use that guide when the page also needs to qualify for Google's shopping results, because the purchase page and product data need their own checks.

Stage 5: Test it, then watch the reports

Run the product page through Google's Rich Results Test, fix critical errors, and monitor its rich result status after indexing. The test reads one page now. The status report shows what Google found across pages it has indexed.

Finish the audit with these checks:

1. Test one reviewed product URL with the Rich Results Test.
2. Fix every critical error and test the page again.
3. Check Search Console's Product snippets report after indexing.

A passing result shows that the test found eligible structured data in the rendered page. Google still decides whether to show stars, and later updates can change the markup. I repeat the source check after a theme publish or review-app update, using one reviewed product and one zero-review product.

What to mark up with zero reviews

Publish Product markup with the offer, but omit Review and AggregateRating until an eligible review exists. Google lets a product snippet qualify through any one of those three properties. A new page can publish useful Product data without inventing a score.

An aggregate needs both a rating value and a count. Google also says marked-up content must be visible to readers, which leaves a zero-review page with no rating to describe. Judge.me follows the same boundary by writing its snippet after a product has at least 1 published review.

Copying the supplier's rating into the empty page would break the eligibility rule from Stage 3. Wait for the first review from your shopper, then let the source you kept in Stage 2 publish the aggregate.

When review schema can't help

Review markup can make a page eligible for stars, while Google controls their display and the underlying reviews stay unchanged. Google gives no guarantee that features using structured data will appear in search.

Markup describes the rating and reviews shown in the widget. A borrowed review, wrong source, or mismatched count stays wrong after you wrap it in JSON-LD. A structured-data manual action removes rich-result eligibility, while ordinary ranking remains outside its scope.

A copied supplier page still needs original buying help, following our broader guide to SEO for dropshipping.

No cited study here reports a disclosed sample and measured traffic or click result for comparable stores. That evidence gap gives me no basis to forecast gains from the markup alone.

I finish the audit only after this completion check passes:

• Keep one source writing the markup.
• Count only reviews that meet Google's rules.
• Match the visible rating and count.
• Clear every critical Rich Results Test error.

Judge visibility later from the status report and actual search impressions.

Which sources govern review markup?

Schema.org defines the Review type for one review. Use it only when the page shows that review.

Its AggregateRating type represents an average across ratings or reviews. The visible count and value must match the markup.

Google's review snippet guide controls the eligible review fields and sources. Follow the full source and visibility rules before testing the page for rich-result eligibility.

Its structured-data policies require markup to represent visible page content. Hidden or misleading ratings fail that test.

Google's product snippet guide adds product-specific review requirements. Keep the reviewed item tied to the correct product.

The merchant-listing guide explains where aggregate ratings fit a purchase page. Offer and review data still need the same product identity across every visible and marked-up field.

Which Shopify and app sources govern the output?

Shopify's structured_data filter shows the platform's product output. Inspect it before adding another JSON-LD block.

Its standard rating metafields define where apps and themes exchange rating data. Compare their stored values with the complete rating and count shown on the storefront.

The Dawn product source shows how Shopify's reference theme implements its product output. Another theme may write the data differently.

Judge.me documents its schema control. Turn it off when another source owns the review markup.

Its AliExpress import rules explain how imported reviews are labeled. That label matters when deciding which reviews can support the marked-up rating and count.

Judge.me's Shopping ratings feed has separate source requirements. Don't assume storefront display makes every review feed-eligible.

Loox documents its SEO setting. Apply each app statement only to that named app and its current configuration.

FAQ

How long until stars show after a fix?

Loox says ratings can take up to 30 days to appear after Google re-indexes a page. That's one app's estimate, while Google gives no display guarantee.

Can customer reviews carry pros and cons?

Google limits the pros and cons search appearance to editorial product review pages. Merchant product pages and customer product reviews aren't eligible for that feature.

Is a Google Shopping ratings feed review schema?

A Google Shopping ratings feed and on-page review schema are separate routes. Judge.me requires at least 50 eligible written reviews for its feed, while page markup follows the visible product review rules.