Products disapproved in Google Merchant Center: the on-page price mismatch trap

You open Merchant Center expecting a quiet dashboard and instead find a wall of red: dozens of products disapproved, reason given as "inconsistent value" or "price mismatch." Nothing changed on your end — no new promo, no manual edit. And yet Google insists the price on your page doesn't match the price in your feed.

It usually does match. The problem is that your page is quietly telling Google three different prices at once, and Merchant Center is only looking at one of them — the wrong one.

Why this happens: Google reads your page, not just your feed

Merchant Center doesn't only trust the price you submit in your product feed. Google's crawlers also perform "automatic item updates" — they visit the live page, read the price out of the structured data (Product JSON-LD) and the Open Graph tags (og:price:amount), and compare that against your feed. If any of those three sources disagree, Google assumes the feed is stale and either overrides it or disapproves the listing outright for showing an "inconsistent value" to shoppers.

That means a Shopify store can have a perfectly correct Shopify product price and still get disapproved, because one of the other two signals — the JSON-LD or the Open Graph tag — is out of sync.

Where the divergence actually comes from

A half-applied sale. A discount app updates the displayed price on the page but never touches the JSON-LD block, which keeps rendering the pre-sale figure. Shoppers see the sale price; Google's structured-data reader sees the old one.

A pricing or currency-conversion app. Multi-currency and localization apps are the single biggest source of this bug. They rewrite the price a visitor sees based on geolocation or a currency switcher, but they frequently don't touch the underlying cart.currency.iso_code or the JSON-LD price/currency fields — those keep reporting the shop's base currency and price. Google then reads two different currencies or two different amounts for the same offer, which is exactly the "currency_mismatch" / "price_mismatch" pattern that trips Merchant Center's inconsistency check.

A hardcoded price left over from a theme edit. Someone customized a promotional banner or a custom section and typed a price directly into the Liquid template instead of pulling it from the product object. It looks fine at launch and quietly goes stale the next time you change the price in Shopify admin — nothing on the page updates to match, because it was never wired to live data in the first place.

Duplicate schema from an app. If a review app or a second SEO app injects its own Product block alongside your theme's native one, you can end up with two different prices declared on the same page — the "conflicting_products" failure. Google has to arbitrarily pick one, and if it picks the stale one, that's what gets compared to your feed.

The fix: one single source of truth, in Liquid

The rule that fixes essentially all of these cases: every price shown anywhere on the page — the visible price, the Open Graph tag, and the JSON-LD offers.price — must be pulled from the same Liquid variable, live, at render time. In practice:

"offers": {
  "@type": "Offer",
  "price": "{{ product.selected_or_first_available_variant.price | divided_by: 100.0 }}",
  "priceCurrency": "{{ cart.currency.iso_code }}",
  "availability": "{% if product.available %}https://schema.org/InStock{% else %}https://schema.org/OutOfStock{% endif %}"
}

No hardcoded numbers, no values duplicated from a separate app config, no currency assumed from the shop's default market. If you run Shopify Markets or a currency-conversion app, cart.currency.iso_code needs to reflect the converted currency the shopper is actually seeing — check that the app writes to that value rather than only restyling the displayed number with CSS or a client-side script.

Availability deserves the same discipline: if the schema says InStock while the real variant stock is empty (or vice versa), that's its own disapproval risk, and it should also be driven from product.available rather than hardcoded or set once and forgotten.

How to audit this yourself

1. Open the disapproved product on your storefront and open browser dev tools (or just view source) to find the <script type="application/ld+json"> block. Note the price and priceCurrency.
2. Search the same page's source for og:price:amount and og:price:currency — these should match exactly.
3. Compare both against the price your shopper actually sees on the page, and against the price in your Merchant Center feed.
4. If you run a multi-currency or localization app, repeat this check from a session simulating a different country/currency — this is where divergence is most common, since the visible price often switches while the schema and Open Graph tags stay in the shop's base currency.
5. If any two of those four numbers disagree, you've found your mismatch. Trace which app or template edit owns the value that's wrong, and route it through the single Liquid variable above.

This is exactly the kind of failure that produces zero visible symptoms for weeks — the storefront looks completely normal, sales keep coming in, and the only signal is a slow bleed of disapproved SKUs in a Merchant Center tab most merchants don't check daily. Of the 77 Shopify stores we scanned in July 2026, 27% had at least one critical technical SEO issue — without knowing it.

Run your own check. We compare your displayed price, JSON-LD, and Open Graph tags across your catalog automatically — read-only, no admin access, about 2 minutes. → free scan