Install Retouchable in ChatGPT Retouch your product photos from a ChatGPT chat. Install in ChatGPT
  1. Turn on Developer mode

    In ChatGPT, open Settings → Security and login and switch on Developer mode.

  2. Copy the address, open ChatGPT

    https://api.retouchable.ai/api/mcp

    Copy & open ChatGPT ↗
  3. Create the app

    On ChatGPT's Plugins page, select + and choose Create MCP App. Name it Retouchable, paste the address, set authentication to OAuth and create it.

  4. Sign in to Retouchable

    ChatGPT opens our sign-in. New to Retouchable? That starts your 14-day free trial, no card.

Then, in a chat, choose Retouchable under Developer mode and ask: “Grade the photos on my store” or “Put my product photo on white.”

Needs ChatGPT Plus, Pro, Business, Enterprise or Edu, on the web. Menus look different? OpenAI's steps

Product Image Structured Data for Merchant Listings

The image in your Product markup is a required field for Google's merchant listings — here is how to get it right for every product and every variant.

|e-commerce SEO image optimization product image requirements

Google will not show a product page as a merchant listing — the rich result with price, availability and a product photo in Search and the Shopping tab — unless the page's Product structured data includes an image. It is one of the few required properties, alongside the product's name and an offer with a price. Product image structured data is therefore not a nice-to-have SEO extra: a missing or broken image field takes the page out of the richest result type Google offers a store.

Most stores already output some Product markup, because their platform or theme generates it. The problems are quieter: one image where there should be several, a variant page that still points at the default colour's photo, a markup image that no longer matches the photo in the Merchant Center feed, or an image URL Google can't crawl. This guide covers what Google actually reads from the image field, how variants change the picture, and how to check that the markup describes the photos shoppers really see.

If you need the basics of Product schema first — the minimum JSON-LD block and where it goes — start with our product image SEO guide. This post assumes that block exists and focuses on getting the image part of it right.

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 snippetMerchant listing
Meant forAny page about a product (reviews, editorial)Pages where a shopper can buy the product
Where it showsSearch results: ratings, price under the linkSearch, the Shopping tab, Images, product knowledge panels
Image required?NoYes
Search Console reportProduct snippetsMerchant 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.

Structured data and Merchant Center are two doors

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.
50KMinimum pixels (w × h) Google recommends
3Aspect ratios suggested: 16:9, 4:3, 1:1
1stArray slot most surfaces use as the thumbnail

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:

  1. 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.
  2. The variant's URL should open on that variant. If ?variant=sage loads the page showing the cream mug, the image in the markup and the image on the page disagree.
  3. 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.
Pro Tip

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_link points 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_link and 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 replacedWhat Google seesRisk
New image uploaded, new URL, old one removedNew URL in markup on next crawl; old URL starts returning 404Low, if the page is recrawled
New image uploaded, old one left as the featured imageMarkup still leads with the old photoHigh: the new photo never becomes the thumbnail
File overwritten at the same URLSame URL; Google may keep its cached copy for a whileMedium: slow to update
Feed updated, page not (or the reverse)Markup and feed disagreeHigh: 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.
Check for duplicates first

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.

  1. 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".
  2. 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.
  3. 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.
  4. 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?
A practical review cadence
After a theme or app change
Same day
After a photo re-shoot
Within a week
Merchant listings report
Monthly
Full image spot-check
Quarterly

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.

CheckPass looks like
Image field presentEvery product page has image in its Product markup
First image is the heroFront view, product alone, plain or clean background
All angles listedEvery distinct product photo in the array, no banners or charts
Images crawlableURLs load for Googlebot; not blocked by robots.txt
ResolutionAt least 50,000 pixels; ideally well above
VariantsEach colour or style has its own image tied to its SKU
ConsistencyFeatured image = first markup image = feed image_link
One Product entityRich Results Test finds one Product per page, not two
Search ConsoleNo 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.

Frequently Asked Questions

Is an image required in Product structured data?

For Google merchant listings — the rich result for pages where a product can be bought — yes, image is a required property along with the product name and an offer with a price. For product snippets (ratings and price under a search result) it is recommended but not required.

Should the structured data image match my Merchant Center image?

Yes. Google uses both sources to build merchant listings and expects them to agree. The simplest rule is that the product's featured image, the first image URL in the markup, and the feed's image_link are the same photo.

How do I mark up images for product variants?

Use a ProductGroup for the parent product with variesBy naming the attributes that change (such as colour or size), and list each variant as a Product under hasVariant with its own sku, image and offer. Each variant should point to a photo of that specific variant.

How many images should I include in Product markup?

Include every distinct photo of the product — front, side, back, detail — and put the best hero shot first, since surfaces that show one image tend to use the first. Leave out size charts, banners and logos, which are not images of the product.

Why does Search Console say my product image is missing when the page shows one?

Usually because the markup and the visible page come from different sources: the image may be injected by JavaScript after the markup is generated, blocked to Googlebot, or missing from a second Product block added by an app. Test the live URL in URL Inspection and the Rich Results Test to see what Google actually extracts.

Give Google a product photo worth showing

Turn phone photos into consistent studio shots and push them back to your Shopify products as the featured image, with filename and alt text set.

Try Retouchable Free No credit card required