Multilingual SEO

How to Translate Shopify Store Customer Reviews Using Structured Data for International Trust and SEO

Star ratings in Google search results can meaningfully lift click-through rates — and if your schema markup is in English while the rest of your German product page is in German, you are almost certainly leaving that opportunity on the table. Getting shopify multilingual customer reviews structured data right is one of the most technically specific wins available in international SEO, and most Shopify stores skip it entirely.

Why Review Schema and Language Alignment Both Matter

Google's rich results system uses Product, Review, and AggregateRating schema to surface star ratings in search snippets. But schema correctness is only half the problem. Google's own review snippet documentation states that structured data must accurately represent what is on the page. If a shopper lands on your /de/products/laufschuhe page and the visible reviews are in German, your schema should reflect the same content — in German, with an inLanguage property set to de.

This has two practical consequences:

  • Trust: A German shopper who sees a review snippet in Google written in their own language converts at a higher rate than one confronted with English social proof. Research consistently shows that buyers read reviews in their native language before purchasing cross-border.
  • AggregateRating accuracy: Google's guidelines require the ratingCount or reviewCount in your schema to match the reviews actually visible on that page. If you surface only German reviews on your German page but your schema counts all 340 reviews across every language, you risk a manual action or rich result suppression. Always count only the reviews rendered for that locale.

If you have not yet tackled the broader structured data picture, How to Translate Shopify Structured Data and Schema Markup for International SEO is the right starting point before diving into review-specific implementation.

How Shopify Stores Reviews and Why It Complicates Multilingual Schema

Shopify's native review storage (via apps or metafields) does not have a built-in concept of translated review text. Reviews submitted in English stay in English. This means you have three realistic strategies:

Strategy 1: Machine-translate review text into metafields

Use an AI translation layer to produce translated versions of review body text, then store them in locale-specific metafields (e.g., reviews.body_de, reviews.body_fr). Your theme Liquid then reads the correct metafield based on the active locale and outputs translated review text alongside the original.

Strategy 2: Surface only reviews written in the target language

If you have enough review volume, filter by reviewer locale and display only native-language reviews on each translated storefront. This is the cleanest solution for schema accuracy: your reviewCount in schema matches exactly the reviews rendered on the page.

Strategy 3: Display translated reviews with a clear disclosure

Show machine-translated review text with a small label like "Translated from English". This is what major marketplaces do. It maintains trust while expanding reach.

For a deeper look at the conversion and trust-building side of these decisions, see How to Translate Shopify Product Reviews to Build Trust in Every Market and How to Handle Multilingual Product Reviews and Social Proof When Selling Across Borders.

Implementing Locale-Aware Review Schema in Shopify

Step 1: Audit your current schema output

Open your product page source (View Source, not DevTools) and search for application/ld+json. Verify:

  • Is @type set to Product?
  • Is there a nested AggregateRating block?
  • Is there a Review array?
  • Is there any inLanguage property? (Almost certainly not — this is the gap.)

Step 2: Add inLanguage to your Review objects

inLanguage is a valid schema.org property on Review (see schema.org/Review). Add it to each review object to signal which language the review text is written in:

{
  "@type": "Review",
  "inLanguage": "de",
  "author": { "@type": "Person", "name": "Maria S." },
  "reviewRating": { "@type": "Rating", "ratingValue": "5", "bestRating": "5" },
  "reviewBody": "Hervorragende Qualität, sehr schnelle Lieferung."
}

Do not use translationOfWork on Review objects — that property is not defined for Review in the schema.org specification and will not be understood by Google's parser.

Step 3: Gate schema output by locale in Liquid

In your product JSON-LD snippet, use request.locale.iso_code to conditionally output the correct review data. Here is a concrete Liquid example that reads from a locale-keyed metafield namespace:

{% assign locale_code = request.locale.iso_code %}
{% assign reviews_key = 'reviews_' | append: locale_code %}
{% assign locale_reviews = product.metafields.storelingo[reviews_key].value %}

{% if locale_reviews %}
  {% for review in locale_reviews %}
  {
    "@type": "Review",
    "inLanguage": "{{ locale_code }}",
    "author": { "@type": "Person", "name": {{ review.author | json }} },
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": "{{ review.rating }}",
      "bestRating": "5"
    },
    "reviewBody": {{ review.body | json }}
  }{% unless forloop.last %},{% endunless %}
  {% endfor %}
{% endif %}

The key is request.locale.iso_code (not shop.locale, which always returns your store's default language). This ensures the schema block is constructed from the metafield namespace that matches exactly what is rendered on the page for that shopper.

Step 4: Align reviewCount with visible reviews only

{% assign locale_review_count = locale_reviews | size %}
"AggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": "{{ product.metafields.storelingo.avg_rating_de }}",
  "reviewCount": "{{ locale_review_count }}"
}

This is the critical accuracy requirement from Google's guidelines: the count must match what is visible, not your total global review pool.

Step 5: Validate every locale separately

Use Google's Rich Results Test with each of your localized URLs (e.g., yourstore.com/de/products/example). A schema that passes for your English URL can still fail for German if the Liquid conditional is not firing correctly server-side. If you spot coverage gaps across languages, the workflow in Using Google Search Console to Monitor Your Multilingual Store will help you track rich result status per market over time.

Handling Translated Review Text at Scale

Manually translating hundreds of reviews per product per language is impractical. The workable approach is:

  1. Batch translate review bodies using your translation pipeline when a product is first translated.
  2. Store translations in metafields keyed by locale (as shown in Step 3).
  3. Re-translate only when review text changes — the same change-detection logic that avoids re-translating unchanged product descriptions applies here.

StoreLingo (the app behind this guide) translates Shopify metafields as part of its standard workflow, which makes it possible to store locale-specific review translations without building a custom integration. Add StoreLingo on the Shopify App Store →

For the metafield mechanics in more detail, How to Translate Shopify Metafields, Metaobjects and Custom Data walks through the namespace and key structure you will need.

Connecting Review Schema to Your Broader Multilingual SEO Stack

Review schema does not operate in isolation. For rich snippets to fire reliably across markets:

FAQ

Does Google require review schema to be in the same language as the page? Google's review snippet documentation requires that structured data accurately represents the content visible to users on the page. While Google does not explicitly mandate language matching, outputting English schema on a German page where German reviews are displayed creates a mismatch between your markup and your visible content — which conflicts with that core guideline.

Can I count all reviews across languages in my AggregateRating schema? No — not without surfacing all of them on the page. Google's guidelines require the reviewCount in your schema to match the number of reviews a user can actually see. If you show only German reviews on your /de/ product page, your schema's reviewCount must reflect only those German reviews, not your global total.

Will translating review text with AI violate Google's guidelines? Google's guidelines focus on accuracy and non-deception, not on whether a human or machine produced the text. Translated reviews that are clearly labelled as translations and accurately convey the original meaning are consistent with those guidelines. For Google's current position on AI-generated content more broadly, refer to Google's guidance on helpful content.

Choose from 47 languages

StoreLingo translates products, collections, pages and articles with AI — review and approve by default. On paid plans from Starter, auto-translate is off by default and publishes new or updated products automatically. Keep your brand terms consistent.

Add to Shopify →