How to Make Product Reviews Machine Readable for Shopping Agents

To make product reviews machine readable for shopping agents, publish them three ways: schema markup on the product page, Google's product reviews feed, and the review aggregates in assistant product feeds. Our position is that the page markup, the part a review widget handles for you, is the smallest of the three jobs. The other two are files with their own entry rules, and all three should be generated from a single export so the counts agree wherever an agent looks.

Where do shopping agents get review data?

How to make product reviews machine readable for AI shopping agents in 2026 depends on where each agent takes its data, and both Google and OpenAI document that. Google said on May 20, 2025 that shopping in AI Mode brings Gemini together with its Shopping Graph, which it put at "more than 50 billion product listings" carrying "details like reviews, prices, color options and availability."

OpenAI's side is a feed. The file upload product feed reference from OpenAI has two optional product review columns, review_count and star_rating, and states that "Raw review entries and question-and-answer lists are not part of this discovery contract." Review text has no column. Access is limited too: the getting-started guide from OpenAI opens with the notice "Onboarding product feeds in ChatGPT is currently available to approved partners."

Review data is one input among several. The content and sourcing work sits in our guide on how to get cited by ChatGPT, and measuring whether assistants name you is the subject of what AI share of voice means.

What does review markup on a product page need?

Machine-readable product reviews in schema markup, whether the reader is an AI shopping agent or a search crawler, mean a schema.org Product with aggregateRating and review nested inside it. The review snippet documentation from Google Search Central sets out what each object must hold:

• aggregateRating needs a ratingValue and at least one of ratingCount or reviewCount. When it is nested, the parent product's name identifies the item.
• Each review needs an author with a valid name shorter than 100 characters and a reviewRating with a ratingValue. datePublished is recommended, in ISO 8601 format.
• Numbers are read on a 5-point scale unless you declare bestRating and worstRating, and decimals take a dot in place of a comma (4.4).

A hypothetical product, with offers and other properties left out for space:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Ridgeline Trail Shoe",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.4,
    "reviewCount": 318
  },
  "review": [{
    "@type": "Review",
    "author": { "@type": "Person", "name": "Dana R." },
    "datePublished": "2026-09-14",
    "reviewRating": { "@type": "Rating", "ratingValue": 5 }
  }]
}

For pages that sell the product, the merchant listing documentation from Google Search Central lists both properties as recommended and adds a delivery note for merchants optimizing for all types of shopping results: "we recommend putting Product structured data in the initial HTML for best results." It warns that dynamically generated markup "can make Shopping crawls less frequent and less reliable," a problem it ties to fast-changing content such as price and availability. If your review widget writes its JSON-LD in the browser, render the aggregate on the server from the same data.

Which rules get review markup ignored?

Valid syntax is the easy part. The same review snippet guidelines carry content rules that Google says the Rich Results Test cannot identify, and they decide whether the markup counts.

• Visible on the page. Marked-up review content has to be "readily available to users from the marked-up page", and a shopper should be able to see the aggregate rating you declare. An aggregate rating that lives only in JSON-LD fails this rule.
• Your own reviews. The guideline reads "Don't aggregate reviews or ratings from other websites." Google defines ratingCount as "The total number of ratings for the item on your site." Marketplace and syndicated ratings stay out of the number.
• One specific item. Review information has to describe a single product, which rules out a blended rating on a category or list page.
• An aggregate with individual reviews. If you mark up several reviews, include their aggregate rating as well.
• Honest collection. Fake reviews are out, and so are incentivized reviews whose incentive is not clearly and prominently disclosed.
• A real author name. Google's example of an invalid reviewer name is "50% off until Saturday".
• No self-awarded store stars. When a business controls the reviews about itself, its pages using LocalBusiness or Organization markup are ineligible for the star feature. Product ratings belong on Product.

Breaking these has a specific cost. Google may take manual action against a site that violates the guidelines, and it states, "If you received a structured data manual action against your page, the structured data on the page will be ignored (although the page can still appear in Google Search results)." Following every rule buys eligibility and nothing further, because "Google does not guarantee that features that consume structured data will show up in search results."

What does Google's product reviews feed require?

Beyond schema.org AggregateRating and Review structured data on the Product page, Google takes product reviews and ratings through a Merchant Center reviews feed, a machine-readable XML file that makes ratings eligible to show as stars on Shopping ads. The eligibility page in Google Merchant Center Help gives the terms of the Product Ratings program:

• Submit through a supported reviews aggregator, or sign up and upload through Merchant Center yourself.
• "You must have a minimum of 50 reviews across all of your products."
• Upload the data source at least once a month, with updated reviews.
• The domains in each <product_url> must match the domain registered in your Merchant Center account.
• Reviews typically go live 2 to 4 weeks after a successful data quality and policy review.

The XML schema reference from Google supports version 2.4 only. Each <review> must carry a <review_id>, a <reviewer> name, a <review_timestamp>, the <content>, a <review_url>, an <overall> rating with min and max attributes, and at least one <product> with its <product_url>. Optional flags record verified purchases, incentives, spam and the collection method. GTINs give the strongest match between a review and a product, and brand and MPN are used for matching only as a pair.

Two rules matter before the first upload. The file is always complete: "Our system always expects a full feed. Any reviews previously submitted, but not included in your next full feed will be deleted." You also may not curate it. The Product Ratings policies in Google Merchant Center Help say "you are required to share all your product reviews with Google, including low-star reviews, unless specifically instructed otherwise." Those policies require that you collect and own the reviews, refuse reviews syndicated from other sources, require the <is_incentivized_review> flag whenever an incentive was offered, and disallow reviews primarily generated by an automated program or AI application.

Which review fields does OpenAI's product feed take?

OpenAI's is the assistant feed specification we read for this piece, and its file upload reference takes aggregates only. review_count is a whole number of product reviews, where zero means no reviews and an empty value means unknown, with the instruction "Exclude seller and store reviews." star_rating is the average on a 0 to 5 scale, to two decimal places. The reference adds, "The count and rating must describe the same review population." For variants that share reviews on one product page, each row carries the same group aggregate, and the reference says "do not sum it again across rows." Store-level columns exist (store_review_count and store_star_rating), but they are marked "Optional; requires setup", and adding the columns to a standard upload does not switch them on.

One export, three outputs

A hypothetical example shows why a single source matters. A footwear store sells the Ridgeline Trail Shoe in six variants that share one product page and one pool of 318 reviews collected on its own site, averaging 4.4.

The store schedules a nightly export from its review platform: a row per review with its ID, the GTINs it applies to, the rating, text, display name, timestamp and source, plus the verified, incentivized and spam flags. Three jobs read that export:

1. Page. The server computes 4.4 and 318 and writes them twice, into the visible rating block and into the JSON-LD.
2. Google feed. All 318 reviews go into the XML, each listed once with the identifiers and URLs of every variant it covers, low-star reviews included. The job runs weekly, inside the monthly requirement.
3. OpenAI feed. Each of the six variant rows carries review_count 318 and star_rating 4.40. Summing across rows would report 1,908 reviews for a product that has 318.

The source column earns its place when a platform also displays reviews syndicated from a manufacturer or another retailer. Those rows stay out of the Google outputs, since the markup guidelines and the feed policies both exclude them. A final check compares four numbers per product: the visible count, reviewCount, the number of <review> elements and review_count. When they drift, your own channels publish different facts about the same product, the inconsistency we cover in LLMs cite the brand that agrees with itself.

Readable review data supports the comparison work in our guide to raising share of voice in AI category comparisons and does not replace it. For help with the export and its three outputs, our AI search optimization service is the place to start, and the AI visibility checker is a further resource on the measurement side. Our advice is to begin with the count: once the number on the page, in the markup and in each feed agree, most of what remains is formatting.

Sources

• Google Search Central, Review snippet (Review, AggregateRating) structured data
• Google Search Central, Merchant listing (Product, Offer) structured data
• Google, Google Product Review Feeds, XML Schema Reference
• Google Merchant Center Help, Product Ratings eligibility
• Google Merchant Center Help, Product Ratings policies
• OpenAI, Products feed reference (Stable view)
• OpenAI, Get Started, Agentic Commerce
• Google, Shop with AI Mode, use AI to buy and try clothes on yourself virtually (May 20, 2025)