Skip to content
50% OFF $299 $599
Lock in
§ 3.7 ARTICLE
Published VerifiedEvery 6 weeks Sources3 named Authored bySquareRank Team

Schema · § 3.7 · How-to

Review and AggregateRating schema on Squarespace

Google's review-snippet policy1 is unambiguous: when the entity being reviewed controls the reviews about itself, the page is ineligible for star snippets. That rule disqualifies most Squarespace reviews — testimonials on a service page, Squarespace Commerce's native reviews, Google Reviews embedded on the home page — from triggering the visible star result. The fix is integration with an independent third-party review platform (Yotpo, Stamped.io, Judge.me, Trustpilot for services) whose reviews count as independent. Without that, AggregateRating markup parses cleanly but produces no SERP enhancement.

This leaf is the honest version of every “add review schema to your Squarespace site” post. The technical install is straightforward; the policy reality is that most installs fail to trigger stars because the underlying reviews don't qualify as independent. We name the policy upfront, ship the install pattern for the cases where it does qualify, and recommend skipping the markup where it doesn't.

What Review and AggregateRating are

Review is the Schema.org type for an individual review of a thing — a product, a business, a book, a course, an event. AggregateRating is the type for a summary rating across many reviews. The two often ship together: a Product carries an AggregateRating (4.7 stars from 132 reviews) plus several Review objects (individual customers' reviews with names, dates, ratings, body text). Both attach as properties of the reviewed entity, not as top-level schema blocks.

The shape: itemReviewed names the thing being reviewed (a reference to a Product, LocalBusiness, etc.); reviewRating contains a Rating object with ratingValue and bestRating; author names the reviewer; reviewBody carries the review text. AggregateRating skips the per-review detail and reports ratingValue, reviewCount (or ratingCount), and bestRating.

The self-serving rule: who controls the reviews

Google's canonical review-snippet documentation states the disqualifier plainly: if the entity that's being reviewed controls the reviews about itself, the entity's pages are ineligible for the star review feature. Self-serving reviews are reviews collected, edited, displayed, or moderated by the business itself on its own properties. Independent third-party reviews are reviews collected and displayed by an unaffiliated platform — a separate company that runs the reviews system.

The rule traces to a 2019 policy change that Google has progressively tightened. Pre-2019, a business could collect testimonials on its own site and mark them up with Review schema for stars. Post-2019, that pattern is disqualified. The intent is to prevent self-promotion via fabricated reviews; the side effect is that genuine self-collected reviews are also excluded.

When to use Review and AggregateRating schema

Use AggregateRating on a Product or LocalBusiness only when the reviews feeding the rating are independent third-party reviews and the page displays the rating visibly. Use Review for individual quoted reviews under the same independence rule. Skip both when the reviews are self-collected — the markup parses but produces no SERP benefit and adds maintenance burden. Supported parent types per Google's documentation: Product, LocalBusiness, Book, Course, Event, Movie, Recipe, SoftwareApplication, plus a handful of CreativeWork subtypes.

A common edge case: a business that displays its Google Business Profile rating on its own site. The reviews are independent (Google collected them; the business cannot edit them), but the rating is being re-displayed on the business's own site. Per Google's guidance, the re-displayed rating still counts as self-serving in that context because the page hosting the schema is controlled by the reviewed entity. The cleaner approach: link to the Google Business Profile, do not mark up the embedded rating.

Rich-results status in 2026

The review-snippet rich result is active in 2026 for supported parent types and independent reviews. The visible enhancement: golden stars (or a numeric rating) appearing inline in the search result card. Self-serving reviews on a business's own site do not trigger the stars regardless of how well-formed the schema is. Independent product reviews on a third-party platform's domain (a Yotpo widget hosted on yourstore.com) generally pass the independence test if the platform owns the data and the business cannot edit reviews.

The honest framing for a Squarespace site without third-party review integration: AggregateRating markup produces no visible Google enhancement, and the technical install is wasted effort. Recommend the third-party integration as the actual fix; ship the schema only after that integration is live.

Review schema in 2026

No

self-serving reviews on a business's own site are not eligible for star snippets per Google's documentation.

Google Search Central · 2025-12-10
8+

supported parent types: Product, LocalBusiness, Book, Course, Event, Movie, Recipe, SoftwareApplication, and CreativeWork subtypes.

Google Search Central · 2025-12-10
5

rating value (out of 5) most commonly used for ratingValue. bestRating defaults to 5 if omitted.

Schema.org · 2026-03-19

Required and recommended fields

For AggregateRating: ratingValue (required), reviewCount or ratingCount (required), bestRating (recommended; defaults to 5 if omitted), worstRating (recommended). For Review: author (required, a Person or Organization), reviewRating (required, a Rating object with ratingValue), itemReviewed (required when ambiguous — usually inferred from the parent entity), datePublished (recommended), reviewBody (recommended, the review text). Both must attach to a supported parent type and reflect visible content on the page.

  • AggregateRating.ratingValue — required. The numeric average (e.g. "4.7").
  • AggregateRating.reviewCount — required (or ratingCount). The number of reviews behind the average.
  • AggregateRating.bestRating — recommended. The scale's maximum (typically 5).
  • Review.author — required. A Person or Organization object.
  • Review.reviewRating — required. A Rating object with ratingValue.
  • Review.itemReviewed — required when ambiguous. Usually inherited from parent entity.
  • Review.datePublished — recommended. ISO 8601 date.
  • Review.reviewBody — recommended. The review text.

Copy-paste JSON-LD example

The block below extends a Product entity with AggregateRating (the summary) and a single representative Review. The example assumes the reviews are coming from an independent platform — Yotpo, Stamped.io, Judge.me — that surfaces the aggregate rating and lets you template review data into the page. Replace ratingValue, reviewCount, author, and reviewBody with real data from your platform.

JSON-LD AggregateRating + Review on a Product (independent platform reviews assumed) 
 <script type="application/ld+json"> { "@context": "https://schema.org", "@type": "Product", "name": "Coastal Vase No. 3", "aggregateRating": { "@type": "AggregateRating", "ratingValue": "4.8", "reviewCount": "47", "bestRating": "5" }, "review": [ { "@type": "Review", "author": { "@type": "Person", "name": "Eleanor M." }, "reviewRating": { "@type": "Rating", "ratingValue": "5", "bestRating": "5" }, "datePublished": "2026-04-22", "reviewBody": "Glaze is even more beautiful in person. Arrived wrapped carefully — no chips." } ] } </script>

Where to paste it on Squarespace

Review and AggregateRating are properties of a parent entity (Product, LocalBusiness, Service) — not top-level schema blocks. The install pattern: update the existing Product or LocalBusiness JSON-LD on the relevant page to include aggregateRating and review fields. On Squarespace, this lives in Page Settings > Advanced > Page Header Code Injection for per-page entities (Product) or Settings > Advanced > Code Injection > Header for site-wide entities (LocalBusiness).

For Squarespace Commerce stores running a third-party review platform (Yotpo, Stamped.io, Judge.me), the platform's integration usually injects the AggregateRating schema automatically via a snippet you paste into Site-wide or Page-level Code Injection. Read the platform's Squarespace integration guide first — you may not need to hand-author the JSON at all.

Validation steps

Run the page URL through Google's Rich Results Test. Confirm the parent entity (Product, LocalBusiness, etc.) is detected with aggregateRating and review properties. The expected output: either 'eligible for Review rich result' (independent third-party reviews on a supported parent type) or 'page eligible for [parent type] rich result, review fields detected but page is self-serving' (own-site reviews). The latter outcome means the markup is structurally valid but won't trigger stars.

A second check worth running for ecommerce: confirm the visible review content on the page matches the schema. If the schema reports 47 reviews and the page displays 12, Google's validator may flag a content mismatch — the schema should reflect what users see.

Common gotchas on Squarespace

Three gotchas catch most Review schema installs. First: installing AggregateRating for self-serving reviews and expecting stars — the markup parses, no stars appear, and the owner spends weeks debugging a non-existent problem. The fix is integrating a third-party review platform first. Second: re-displaying Google Business Profile reviews on the home page and marking them up with AggregateRating — Google treats this as self-serving when it lives on the business's own pages. Third: schema/visible mismatch — claiming 47 reviews in the schema while the page shows 12.

A fourth, subtler gotcha: review schema on Service pages. Google's documentation lists supported parent types but is silent on plain Service. Layering AggregateRating on a Service is structurally valid but unlikely to trigger stars even with independent reviews — the supported types are Product, LocalBusiness, Book, Course, Event, Movie, Recipe, SoftwareApplication, plus CreativeWork subtypes. For a service business, AggregateRating belongs on the LocalBusiness entity (site-wide), not on individual Service pages.

Review and AggregateRating are dependent on a parent entity. The most common parents on a Squarespace site are Product (for Commerce stores) and LocalBusiness (for service-area businesses). Organization can also carry an AggregateRating in narrow cases. BreadcrumbList belongs alongside the parent entity on every page.

  • Product schema — the most common parent for AggregateRating on a Squarespace Commerce site.
  • LocalBusiness schema — the typical parent for service businesses.
  • Organization schema — carries AggregateRating in narrow cases (the business as a whole, not a specific product).

Keep reading · § 3.7