# Shopify Product Review Score Import: Add Star Ratings as Metafields

> How to import aggregate star ratings and review counts into Shopify as standard product metafields, preserving historical review data when migrating platforms or switching review apps.

- Published: 2026-11-04
- Author: Importier Team
- Category: Import Guides / Variants & Quality
- Canonical: https://www.importier.app/blog/shopify-product-review-score-import

---

A Sydney homewares retailer migrated 450 products from WooCommerce to Shopify. Three years of review data came with them: average ratings per product, review counts, and verified purchase flags. After migration, all of that data sat in a CSV export from WooCommerce, unused. Their new Shopify store showed no star ratings anywhere on product pages.

The reviews app they chose, Judge.me, was installed and running. But it had no historical data to display. The 450 products each had a blank rating field in Shopify, regardless of how many reviews the product had accumulated before the migration.

This is a solvable problem. Shopify has a standard product rating metafield type that review apps write to and themes render natively. That metafield can be populated via import. This article covers how.

## Why Review Scores Belong in Metafields, Not Descriptions

A product description that says "our most highly rated coffee grinder" is marketing copy. A `reviews.rating` metafield containing `4.8` is structured data that a theme renders as five stars, that Google Shopping reads for rich result snippets, and that a review app updates automatically as new reviews come in.

The distinction matters because:

**Google Shopping rich results**: Google's [product structured data specification](https://developers.google.com/search/docs/appearance/structured-data/product) supports `aggregateRating` for star display in search results. Shopify's standard `reviews.rating` metafield maps to this field when the theme renders JSON-LD. A rating stored only in description prose cannot appear in a product snippet.

**Review app compatibility**: Judge.me, Yotpo, Okendo, and Stamped all read from and write to the same standard Shopify metafields: `reviews.rating` (type: Rating) and `reviews.rating_count` (type: Integer). Pre-populating these fields before the app goes live gives new installs historical data to display from day one, rather than starting from zero.

**Theme rendering**: Dawn and most modern Shopify themes include a star rating display component that reads `product.metafields.reviews.rating`. An empty metafield shows nothing. A populated metafield shows the star widget without any additional theme customisation.

<Callout>
Shopify has a native Rating metafield type (decimal, min 0.0, max 5.0) specifically designed for product star ratings. It is not a text field containing "4.8/5": it is a structured decimal value that themes and apps read programmatically. Import the right type and the star widget works automatically.
</Callout>

## Shopify's Standard Review Metafields

Shopify's product metafield namespace for reviews uses two fields:

- **`reviews.rating`**: type `rating`. A decimal value between 0.0 and 5.0. The Rating type includes a minimum and maximum scale; Shopify enforces this at the metafield definition level. Review apps write this value as the product's average rating.
- **`reviews.rating_count`**: type `integer`. The total number of ratings the average is calculated from. Review apps write this value whenever a new review is submitted.

Both are part of [Shopify's standard metafield definitions](https://shopify.dev/docs/apps/build/custom-data/metafields/definitions/list-of-standard-definitions), which means they are pre-registered in the Shopify metafield registry. The theme can reference them without custom code, and review apps recognise them without manual configuration.

A third optional field:
- **`reviews.rating_count`** distinguished from `reviews.review_count`: Some apps store the total number of written reviews (with text) separately from the total number of ratings (which include star-only ratings). For most migration use cases, importing only `reviews.rating` and `reviews.rating_count` is sufficient.

## Setting Up the Metafield Definitions

Before importing, create the metafield definitions in Shopify Admin under Settings > Custom data > Products.

For `reviews.rating`:
- Namespace: `reviews`
- Key: `rating`
- Type: Rating
- Name: Rating (or "Product Rating")
- Minimum: 0.0
- Maximum: 5.0

For `reviews.rating_count`:
- Namespace: `reviews`
- Key: `rating_count`
- Type: Integer (whole number)
- Name: Rating Count

If you are installing a review app that uses these standard fields (Judge.me, Yotpo, Okendo), the app creates these definitions automatically on install. In that case, skip this step and let the app create them first. Attempting to create a definition that already exists in the namespace will return an error from Shopify.

If you are migrating from a platform with no review app yet installed on the Shopify side, create the definitions manually before running the import.

![Five printed star rating badges of different values arranged in a row on a white card surface representing structured aggregate rating data for product import.](/blog/shopify-product-review-score-import/01.jpg)

<Divider label="Building the Import File" />

## The Import File Structure

The import CSV needs two additional columns beyond the standard product data:

<table>
  <thead>
    <tr>
      <th>Handle</th>
      <th>Title</th>
      <th>reviews.rating</th>
      <th>reviews.rating_count</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>conical-coffee-grinder-manual</td>
      <td>Manual Conical Coffee Grinder</td>
      <td>4.8</td>
      <td>312</td>
    </tr>
    <tr>
      <td>pour-over-coffee-dripper-v60</td>
      <td>V60 Pour Over Coffee Dripper</td>
      <td>4.6</td>
      <td>187</td>
    </tr>
    <tr>
      <td>kitchen-scale-precision-3kg</td>
      <td>Precision Kitchen Scale 3kg</td>
      <td>4.3</td>
      <td>94</td>
    </tr>
  </tbody>
</table>

The column headers must match the exact metafield key format: `namespace.key`. For the standard review fields that is `reviews.rating` and `reviews.rating_count`.

In Importier's column mapping step, map:
- `reviews.rating` → the `reviews` / `rating` metafield (Rating type)
- `reviews.rating_count` → the `reviews` / `rating_count` metafield (Integer type)

If the metafield definitions are not yet created in Shopify, Importier's column mapping step will not show them as available destinations. Create the definitions first.

## Sourcing the Rating Data

For a platform migration (WooCommerce, BigCommerce, Magento), the aggregate rating data is in the platform export. WooCommerce exports include average rating and review count per product in the standard product CSV. BigCommerce includes similar fields in the product export. The column names differ by platform:

<table>
  <thead>
    <tr>
      <th>Platform</th>
      <th>Average rating column</th>
      <th>Review count column</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>WooCommerce</td>
      <td><code>average_rating</code></td>
      <td><code>review_count</code></td>
    </tr>
    <tr>
      <td>BigCommerce</td>
      <td><code>rating_total</code> / <code>rating_count</code> (compute average)</td>
      <td><code>rating_count</code></td>
    </tr>
    <tr>
      <td>Squarespace</td>
      <td>Not in standard export; use review app CSV export</td>
      <td>Not in standard export</td>
    </tr>
    <tr>
      <td>Review app (Judge.me)</td>
      <td>Judge.me CSV export: <code>average_rating</code></td>
      <td>Judge.me CSV export: <code>number_of_reviews</code></td>
    </tr>
  </tbody>
</table>

For BigCommerce, the export provides total rating points and rating count separately. Compute the average in a spreadsheet: `=rating_total / rating_count`. Round to one decimal place (e.g., 4.8 not 4.76923).

For products with no reviews (new products, products with zero reviews in the source platform), leave the `reviews.rating` and `reviews.rating_count` columns blank. Importier treats blank metafield cells as "do not set" rather than "set to zero." A blank rating is correct; a zero rating displayed as "0 stars" is not.

![A printed spreadsheet with product names and star rating values in two columns showing the import file structure for review score data.](/blog/shopify-product-review-score-import/02.jpg)

## The Six-Step Import Workflow

<Steps items="Create metafield definitions: In Shopify Admin, create reviews.rating (Rating type, 0.0-5.0) and reviews.rating_count (Integer) under Settings > Custom data > Products. Skip if a review app has already created them. | Prepare the rating data: Export aggregate ratings from your previous platform or review app. For WooCommerce: use average_rating and review_count columns. Compute averages for BigCommerce. Leave blank for products with no reviews. | Add columns to your import file: Add reviews.rating and reviews.rating_count as new columns in your product CSV. Match product rows by Handle or SKU. For variant-based products, the rating applies to the parent product, not individual variants; put it on the first row (the row with the Title). | Upload to Importier and map columns: In the column mapping step, map reviews.rating to the reviews / rating metafield destination and reviews.rating_count to reviews / rating_count. The preview table shows the values before they reach Shopify. | Review and push: Check a sample of high and low rated products in the preview table. Verify the decimal values display as expected. Push the import batch. | Verify theme rendering: Visit a product page for a product with a populated rating. If the theme includes a star rating component, it should display immediately from the metafield. If not, the data is in Shopify and available for the theme to render; a theme developer can wire it in." />

![Six numbered wooden blocks arranged in a linear sequence on a white surface representing the six-step import workflow process.](/blog/shopify-product-review-score-import/03.jpg)

## After the Import: What Changes

The homewares retailer pushed 450 products with their historical ratings. After the import:

Judge.me installed with historical data already in place. When the Judge.me widget loaded on product pages, it read `reviews.rating` and `reviews.rating_count` from the metafields and displayed the historical average correctly without needing to re-import reviews individually through the Judge.me panel. The star widgets appeared on product pages on day one.

Google Shopping picked up the structured data within the standard crawl cycle. Products with high review counts and high averages (above 4.5 stars with 50+ reviews) became eligible for star snippets in Google Shopping results. This change required no additional setup: the JSON-LD the theme generated from the standard `reviews.rating` metafield matched Google's aggregateRating schema.

For the AI description generation pass that followed the rating import, the merchant used Importier to generate descriptions for products that still had supplier copy. For their highest-rated products (4.7+ average, 100+ reviews), they configured the AI description generation to use the Social Proof style, which references validation signals in the opening lines. Products below 3.8 average used the Benefits-First style instead, since leading with a low rating reference would work against conversion.

![Two product display shelves with identical items showing different amounts of price and quality information tags representing before and after structured data population.](/blog/shopify-product-review-score-import/04.jpg)

<Compare
  withoutTitle="Migration without rating import"
  withTitle="Migration with reviews.rating import"
  withoutItems="All 450 products show no star rating on day one; trust signals reset to zero | Review app installs with no historical data to display; months before ratings rebuild | Google Shopping product snippets have no aggregateRating; reduced rich result eligibility | No differentiation between top-selling products with 300+ reviews and new products with none | Historical platform review effort lost; conversion support of three years of social proof gone"
  withItems="450 products display historical star ratings from day one after migration | Review app reads metafields on first load; historical average visible immediately | Google Shopping aggregateRating populated; star snippet eligible from first crawl | High-rated products identifiable for AI description Social Proof style configuration | Three years of review accumulation preserved as structured data in the new store"
/>

<PullQuote>
Review scores are product data. Importing them as structured metafields treats them the same way as dimensions, materials, or certifications: machine-readable, app-compatible, and renderable without custom code.
</PullQuote>

The [product reviews and AI shopping signals guide](https://importier.app/blog/shopify-product-reviews-ai-shopping) covers how those same `reviews.rating` values affect product visibility in AI shopping agents (Perplexity, ChatGPT Shopping, Google AI Mode). The import step puts the data in place; the signals guide explains what that data does once it is there.

For the broader metafield import structure for product specifications, the [product metafields import guide](https://importier.app/blog/shopify-product-metafields-guide) covers the namespace and key naming conventions and how Importier's column mapping handles custom vs standard metafield destinations.

<TipBox />

Products with more than 100 reviews at 4.5 or higher benefit most from the structured rating import at migration time. These products already carry social proof that took years to build; losing that signal during a platform switch (and rebuilding it slowly through the new review app) is a conversion cost that the import step avoids entirely.

Try Importier free at [importier.app](https://importier.app).