Merchant listings vs product snippets: why the image field matters
Google documents two separate rich result types for product pages, and they have different requirements:
| Product snippet | Merchant listing | |
|---|---|---|
| Meant for | Any page about a product (reviews, editorial) | Pages where a shopper can buy the product |
| Where it shows | Search results: ratings, price under the link | Search, the Shopping tab, Images, product knowledge panels |
| Image required? | No | Yes |
| Search Console report | Product snippets | Merchant listings |
A store's product page qualifies for both, and Search Console reports them separately. That is why a page can look healthy in the Product snippets report while the Merchant listings report flags it with "Missing field 'image'" — the snippet doesn't need a photo; the merchant listing does.
The merchant listing is also where the photo does its selling. In the Shopping tab and image results, the image is the listing: shoppers compare thumbnails before they read a title. The markup is how you tell Google which photo belongs to which product, offer and variant, rather than leaving it to guess from whatever images are on the page.
Google builds merchant listings from both your on-page structured data and, if you have one, your Merchant Center feed. They are not alternatives you pick between: when both exist, Google expects them to agree. A store with no Merchant Center account can still appear in free listings from structured data alone, which makes the markup's image field the only image signal Google has.
What Google reads from the image property
The image property on a Product accepts a single URL, an array of URLs, or ImageObject entries. For a product page, an array of plain URLs covering every distinct photo is the most useful form:
<script type="application/ld+json">
{
"@context": "https://schema.org/",
"@type": "Product",
"name": "Stoneware Mug, Cream Glaze, 350 ml",
"sku": "MUG-CRM-350",
"image": [
"https://example.com/images/stoneware-mug-cream-front.jpg",
"https://example.com/images/stoneware-mug-cream-side.jpg",
"https://example.com/images/stoneware-mug-cream-base.jpg"
],
"offers": {
"@type": "Offer",
"price": "32.00",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"url": "https://example.com/products/stoneware-mug-cream"
}
}
</script>
Google's guidance on the image field is short, and each line of it is a common failure point:
- The URLs must be crawlable and indexable. An image blocked by robots.txt, served only after a login, or behind a hotlink rule that refuses Googlebot counts as missing.
- The image must show the marked-up product. A lifestyle banner, a size chart or a brand logo in the first slot is not an image of the product.
- Size and shape. Google recommends high-resolution images of at least 50,000 pixels (width × height), and supplying the photo in 16:9, 4:3 and 1:1 aspect ratios so each surface can pick the one that fits.
The order of the array matters in practice. Surfaces that show one image tend to take the first, so the first URL should be your cleanest, most recognisable shot — usually the front view on a plain background — not a detail crop or an in-context scene. On most platforms the first image in the markup is simply the product's featured image, so fixing the order means fixing which photo is featured.
Variants: one photo per colour, not one photo per product
Variants are where image markup goes wrong most often. A product sold in five colours frequently ships markup that lists the default colour's photo for all five, so a shopper searching for the green one is shown the cream one. Google supports variant markup directly: a ProductGroup describes the parent, variesBy names the dimensions that change, and each variant is a Product under hasVariant with its own image and offer.
{
"@context": "https://schema.org/",
"@type": "ProductGroup",
"name": "Stoneware Mug, 350 ml",
"productGroupID": "MUG-350",
"variesBy": ["https://schema.org/color"],
"hasVariant": [
{
"@type": "Product",
"sku": "MUG-CRM-350",
"color": "Cream",
"image": "https://example.com/images/stoneware-mug-cream-front.jpg",
"offers": { "@type": "Offer", "price": "32.00", "priceCurrency": "USD",
"url": "https://example.com/products/stoneware-mug?variant=cream" }
},
{
"@type": "Product",
"sku": "MUG-SGE-350",
"color": "Sage",
"image": "https://example.com/images/stoneware-mug-sage-front.jpg",
"offers": { "@type": "Offer", "price": "32.00", "priceCurrency": "USD",
"url": "https://example.com/products/stoneware-mug?variant=sage" }
}
]
}
Three rules keep variant images honest:
- Every variant gets its own photo. If a colour has never been photographed, that is a photography gap, not a markup problem — and the markup will expose it.
- The variant's URL should open on that variant. If
?variant=sageloads the page showing the cream mug, the image in the markup and the image on the page disagree. - Variant photos should match each other. Same angle, same framing, same background. In a grid of colour options, a sage mug shot at a different angle and scale from the cream one reads as a different product.
Shooting one colour and generating the rest is common for apparel and homewares. If you do it, make sure each generated colour is a real, sellable variant with its own SKU, and that the colour in the photo matches the colour the shopper receives. Markup that ties a photo to a SKU makes a colour mismatch a product-data error, not just a returns problem.
Keeping markup, feed and page in agreement
Google compares what it finds in three places: the structured data, the visible page, and your Merchant Center feed if you have one. Price mismatches are the best-known cause of disapprovals, but image mismatches cause quieter trouble — the wrong photo in the Shopping tab, or a listing that keeps showing last season's image.
Where they drift apart
- Theme markup lists the featured image; the feed's
image_linkpoints at an old upload - Photos re-shot and replaced on the page, but the feed is a CSV exported months ago
- A third-party feed app crops or resizes the image and hosts its own copy
- The markup lists lifestyle images the feed was told not to use
How to keep them aligned
- One source of truth: the product's image list in your platform
- Feed and markup both generated from that list, never edited by hand
- The same first image in the markup and in
image_link - Extra angles in
additional_image_linkand later array slots
The simplest rule is that the featured image on the product, the first URL in the markup, and the feed's image_link should all be the same photo. If you need help with what Merchant Center will and won't accept in that slot — no watermarks, no promotional overlays, the product clearly visible — our Google Merchant Center image requirements guide covers the policy side.
Image sitemaps are the third piece. Structured data tells Google what an image represents; a sitemap helps it find the image in the first place, which matters for images loaded by script or on pages deep in a catalog. We cover that in image sitemaps for product discovery.
What happens when you replace product photos
Stores re-shoot. A supplier photo gets replaced with your own, a whole catalog moves to a consistent white background, a hero image is swapped after an A/B test. Each replacement touches the markup, and how you replace the photo decides how quickly Google catches up.
| How the photo is replaced | What Google sees | Risk |
|---|---|---|
| New image uploaded, new URL, old one removed | New URL in markup on next crawl; old URL starts returning 404 | Low, if the page is recrawled |
| New image uploaded, old one left as the featured image | Markup still leads with the old photo | High: the new photo never becomes the thumbnail |
| File overwritten at the same URL | Same URL; Google may keep its cached copy for a while | Medium: slow to update |
| Feed updated, page not (or the reverse) | Markup and feed disagree | High: mismatched listing |
A new URL with the new image set as featured is the cleanest change: the markup updates the next time the page is crawled, and the old URL drops out. After a batch replacement, request indexing for a handful of the most important product pages in Search Console's URL Inspection tool rather than waiting for the crawl to come round.
If you use Retouchable with Shopify, pushing a finished image back to a product lets you set its position, filename and alt text in the same step. Position 1 makes it the featured image — which, on most themes, is the photo that leads the product's structured data and appears in collection grids. That keeps "replace the photo" and "replace the photo Google reads" as one action rather than two. Our post on Shopify image metadata covers why order and alt text matter beyond search.
Where your platform's markup comes from
Few merchants write JSON-LD by hand. It usually comes from one of three places, and knowing which one owns your markup tells you where to fix it.
- The theme. Most modern storefront themes, including Shopify's, output Product markup on the product template, built from the product's title, price and media. Its image field is normally the featured image or the full media list. If the photos are wrong in the markup, they're usually wrong in the product's media order.
- An SEO or reviews app. Apps often add their own Product block to attach ratings. The result can be two Product entities on one page — one from the theme, one from the app — with different images. Google may merge them or pick one; neither is something you control.
- A headless or custom build. Markup is generated in code, so the image logic is whatever a developer wrote. Variant images are the part most often left out.
Before editing anything, view the page through the Rich Results Test and count how many Product items it finds. Two Product entities with different image lists is a common cause of the "wrong photo in Shopping" problem, and the fix is removing one, not editing both.
Whichever source owns it, the input is the same: the product's image list, in order. Tidy that list — the right featured image, every variant photographed, no banners or size charts mixed in among the product shots — and generated markup improves without anyone touching code.
Validating product image structured data (with a checklist)
Validation happens at two speeds: one page now, and the whole catalog over time.
- Rich Results Test, one page. Paste a product URL. It shows which rich result types the page is eligible for, lists the image URLs it extracted, and flags errors (blocking) and warnings (recommended fields missing). Check that "Merchant listings" appears as a detected type, not only "Product snippets".
- URL Inspection, the live page. In Search Console, test the live URL and view the rendered HTML. This shows what Googlebot sees after scripts run, which matters if your markup or images are injected by JavaScript.
- Merchant listings report, the catalog. Search Console's Merchant listings report groups errors across every product page: missing image, invalid image URL, missing price. Fix by issue, then use "Validate fix" to have Google recheck the affected pages.
- Spot-check the images themselves. Open the first image URL from the markup for a sample of products. Does it load? Is it the product, on its own, at a decent size? Is it the photo you'd choose as the thumbnail?
The tools only check that the markup is well formed and the image is reachable. They can't tell you the photo is good. A dim phone snapshot of a mug on a kitchen counter passes every validator and still loses the click to a competitor's clean studio shot in the same Shopping grid. The markup gets your photo onto the surface; the photo has to do the rest.
A checklist for product image markup
Run through this for a sample of products across your catalog — a bestseller, a product with many variants, something recently added and something old.
| Check | Pass looks like |
|---|---|
| Image field present | Every product page has image in its Product markup |
| First image is the hero | Front view, product alone, plain or clean background |
| All angles listed | Every distinct product photo in the array, no banners or charts |
| Images crawlable | URLs load for Googlebot; not blocked by robots.txt |
| Resolution | At least 50,000 pixels; ideally well above |
| Variants | Each colour or style has its own image tied to its SKU |
| Consistency | Featured image = first markup image = feed image_link |
| One Product entity | Rich Results Test finds one Product per page, not two |
| Search Console | No open image errors in the Merchant listings report |
Most failures on this list trace back to the product's image set rather than the code: a variant that was never photographed, a featured image chosen years ago, a supplier photo that doesn't match the rest. Fix the photos and their order, and the structured data your platform generates follows.