Feed Price Mismatch in GMC: 7 Causes and Fixes (2026)

A feed price mismatch is a GMC disapproval that fires when the price your product feed sends to Google does not match the price Google's crawler reads on the product landing page. It is one of the most common technical disapprovals after missing identifiers, and a recurring pattern we see. This guide covers the 7 root causes and gives platform-specific fixes for Shopify, WooCommerce, and custom builds.

What "price mismatch" actually means

Google calls the policy "price and availability" [1]. The check compares three values:

1. The price attribute in your product feed
2. The price in the page's Product JSON-LD (offers.price) [3]
3. The visible price the crawler reads from the rendered HTML

Any disagreement between these three triggers a disapproval. Note that even formatting differences cause flags: "29.99" vs "29.9" vs "29.99 USD" can all be read as mismatches by Google's strict comparison logic.

The 7 causes

1. JavaScript-only price rendering

One of the most common patterns we see. The price is rendered client-side via JavaScript, and Google's crawler either does not execute the script or executes it inconsistently, so the canonical HTML the crawler reads has no price (or a stale placeholder price). Fix: render the price in server-side HTML or in Product JSON-LD with a hard-coded value.

2. Multi-currency app interference

Shopify and WooCommerce multi-currency apps convert prices to the visitor's currency client-side. The feed sends store-base-currency prices, but the landing page displays converted prices. Google reads both, fails the equality check, and flags the SKU. Fix: use Shopify Markets (native multi-currency that updates the feed correctly) instead of third-party currency apps. For WooCommerce, configure the multilingual+multicurrency setup to send currency-matched feeds.

3. Sale price not applied consistently

The sale price runs in your store but the feed has not synced yet, or the sale ended on the site but the feed still has the sale price. Both situations trigger a mismatch. Fix: use sale_price + sale_price_effective_date in the feed and ensure those values match the on-site sale schedule exactly.

4. Decimal/currency formatting differences

Feed says "29.99", page shows "29,99" (European decimal format), or feed says "USD 29.99", page shows "$29.99". Google's parser is strict on currency and decimal formatting. Fix: standardize formatting in both the feed and on the page. Stick to "29.99" with period separator in feeds (most platforms default to this) and ensure JSON-LD uses the same value.

5. Cached page serves stale price

Cloudflare or Vercel cache serves a price from before your last update. The site reflects the new price; the cached HTML the crawler reads does not. Fix: purge cache on any product page after a price change. Configure cache invalidation hooks tied to your product-update events. For Shopify, cache invalidation is automatic. For custom builds, set up an explicit cache-purge step.

6. Tax-inclusive vs tax-exclusive mismatch

VAT countries require tax-inclusive pricing in the feed. If the feed sends ex-VAT prices and the page shows inc-VAT prices (or vice versa), the mismatch fires. Fix: for VAT regions, ensure both feed and page show tax-inclusive prices. For US/non-VAT regions, both show pre-tax prices.

7. Subscription / billing-frequency confusion

For subscription products, the feed sends the per-unit price but the landing page advertises the discounted-subscription price. Google reads the lower price and flags the higher feed price as misleading. Fix: use unit_pricing_measure and unit_pricing_base_measure in the feed, and clearly indicate subscription discount on the landing page with structured data.

How to diagnose which cause hits your store

Test each in order:

1. View the page as Googlebot. In Search Console, use URL Inspection [4] → Live Test → View tested page → HTML. Search for the price. If it is missing or wrong, it is a server-side rendering or caching issue.
2. Run the page through Rich Results Test [5]. Check the Product schema's offers.price value. Compare with the feed.
3. Test in incognito with no currency cookies. Confirm the page shows the same price the feed sends.
4. Check feed sync frequency. If a sale ran for 2 hours and the feed syncs every 24 hours, expect mismatches during sale windows. Increase sync frequency or skip short sales.

Fixes by platform

Shopify

The Google & YouTube channel handles most of this correctly out of the box. Common gotchas: third-party currency converters override the channel's price logic; theme updates change schema rendering; bulk-edit imports without the price column wipe sale prices. Test after every theme update and after installing any pricing-related app.

WooCommerce

The Google Listings & Ads plugin syncs prices. If you use a third-party multilingual or multicurrency plugin (WPML, Polylang, WooCommerce Currency Switcher), confirm the plugin updates the feed price correctly for each currency. Test in an incognito session with each currency selected.

Custom builds

Render the canonical price server-side. Emit Product JSON-LD with the same value. Use a single source of truth (your database) and never compute prices in client-side code that affects the rendered output.

Preventing future mismatches

1. Render prices server-side. Eliminate any client-side price logic that affects the visible value.
2. Add a price-parity test to your deployment pipeline: fetch a sample of 5 product pages as Googlebot, compare with the feed, fail the deploy if any mismatch.
3. Schedule feed syncs to run at least every 30 minutes during sale windows.
4. Subscribe to GMC product status webhooks (or the new Merchant API Notifications sub-API) and act on price-mismatch flags within hours, not days.
5. Audit installed apps quarterly. Remove currency / pricing apps you do not actively need.

Bottom line

Feed price mismatch is mechanical. Google compares three numbers and flags any disagreement. These 7 root causes cover nearly every mismatch we have seen, and the fix is almost always to move price rendering server-side. Once that is in place, mismatches become rare, transient events triggered by sale-window timing rather than persistent structural problems.