Adsentry
IT EN
Sign in Sign up free
Italiano English
Sign in Sign up free
MERCHANT CENTER • PRICE/AVAILABILITY • FIX WORKFLOW

Price or availability mismatch:
why it happens and how to fix it

This is one of the most common Merchant Center issues because it’s rarely “one bug”. It’s a consistency problem across product page, structured data and feed — amplified by variants, cache/CDN, dynamic pricing and duplicated schema.org Product/Offer. Here’s a workflow to isolate the cause and fix it without random changes.

Read ~10 min Updated March 2026 Technical level: intermediate
In this guide you’ll learn:
🧭 Where Google gets the “truth” (page vs schema vs feed) and why mismatches can be intermittent
🧩 Why variants and caching break consistency (the two biggest mismatch drivers)
🛠️ A fix workflow to isolate variables and avoid “try everything” loops
✅ Verification tests before requesting a review (so it doesn’t come back)
Key terms (glossary)
Price/availability mismatchGoogle Merchant CenterProduct pageProduct feedSchema ProductOfferVariantsCache/CDNCurrency switcher

Common symptoms (and why this is so frequent)

“Price mismatch” and “availability mismatch” are often reported as a single error, but the cause varies. The core pattern is the same: Merchant Center sees one value while users (or structured data) show another. Because validation happens over time and from different contexts (bots, caches, locations), it can look “random”.

  • Price mismatch: feed price differs from the product page price, or from Offer.price.
  • Availability mismatch: feed says in stock while the page (or Offer.availability) says otherwise.
  • Variant-only mismatch: base product is correct, but certain sizes/colors/memory options are wrong.
  • Geo/currency mismatch: pricing differs by country/currency while feed/markup stays fixed.
  • Intermittent mismatch: appears after promos start/end, inventory syncs, or cache warm-ups.
Rule of thumb: this is almost always a consistency problem across page, structured data and feed — at the same moment.

Where Google gets the “truth” (page vs schema vs feed)

Merchant Center doesn’t trust a single source. Your feed is the primary input, but Google still verifies what users see on the landing page and what structured data declares. When these diverge, mismatches happen.

Product page (visible)
Displayed price, currency, promotions and stock messaging. If values change dynamically, alignment becomes harder.
Structured data
schema.org Product + Offer. Duplicate JSON-LD or stale values are a top mismatch driver.
If the UI updates via JavaScript after load, but JSON-LD stays server-rendered with old values, Google can read the JSON-LD and consider it authoritative — even if users see something else.

Root causes (9 patterns that create mismatches)

Treat this like debugging: identify the pattern, confirm it on a small sample, then apply a controlled fix.

01
Cache/CDN serving stale HTML
Full-page cache isn’t purged correctly, so Google sees old price/stock on the landing page.
02
Variants don’t update JSON-LD
Selecting a variant changes visible price/stock but structured data stays on the default offer.
03
Duplicated schema markup
Theme + SEO plugin/app + ecommerce plugin output multiple Product/Offer blocks with different values.
04
Dynamic pricing via JS
Final price depends on scripts, rules or location, but markup (and/or feed) doesn’t follow.
05
Currency switchers / geo pricing
The page converts currency on the fly while the feed remains in a single currency (or vice versa).
06
Promotion timing windows
Sale starts/ends but feed or cache updates later, creating temporary mismatch windows.
07
Inventory sync latency
ERP/warehouse updates stock but storefront/feed lags (or updates in the wrong order).
08
Bundles / configurators
Price is computed later in the flow; Merchant Center expects a stable price on the landing page.
09
Wrong URL mapping
Feed links to the wrong variant/product (redirects/canonical conflicts), so comparisons are inconsistent.
Fast prioritization: fix schema duplication + cache first. They create “random” mismatches and waste review cycles.

Shopify: where consistency breaks

On Shopify, mismatches often come from theme scripts, apps that alter prices, multi-currency configurations, and multiple apps injecting structured data.

🧪 Shopify quick check
  • Open a product with variants; select 3 variants.
  • View page source and search for application/ld+json.
  • If you see multiple Product objects or an Offer that never changes, you have a mismatch risk.

WooCommerce: plugins and caching that cause trouble

WooCommerce often stacks multiple layers affecting price/stock/markup: caching, SEO, schema plugins, multi-currency, discount rules and builders.

If prices are personalized (geo, membership, coupons), caching must be configured very carefully. A cached page can be “correct” in one context and wrong in another.

schema.org Product/Offer: duplication and dynamic JS

The most dangerous pattern is simple: the UI shows Price A while JSON-LD declares Price B. Merchant Center reads structured data and compares it to your feed — even if customers see different values.

If your catalog relies heavily on variants, consider stable per-variant URLs (or consistent canonical rules) so each URL represents one stable offer.

Fix workflow (step-by-step, one variable at a time)

Avoid broad changes. Use a small set of products, isolate variables and confirm with repeatable tests.

01
Build a small test set
Pick 3 products: one simple, one with variants, one on promotion. Note URL, expected price, expected stock, and tax/currency assumptions.
02
Validate the landing page (clean context)
Incognito session. Check visible price/stock. Switch variants and note what changes.
03
Validate structured data
Inspect application/ld+json. Confirm a single coherent Product/Offer and matching values.
04
Neutralize caching variables
Purge cache/CDN, retest from a second browser/network. If it “fixes itself” after purge, caching is the culprit.
05
Fix root cause, then align the feed
Stabilize page + schema first (variants/duplication), then update feed and reprocess a small sample before bulk changes.
Sequence matters: stabilize page + schema first, then update feed attributes. This reduces review loops.

Verification tests (before requesting a review)

Don’t request a review until you’ve tested from different contexts. Mismatches often come back because they were fixed only in one cache layer or one location.

  • Two browsers: Chrome + another browser (fresh session).
  • Two networks: home + mobile hotspot to reveal CDN/geo differences.
  • Variant test: at least 3 variants must match both visible UI and Offer values.
  • Hard refresh: verify no stale price remains after forced reload.
If you still see intermittent differences after purge + warm-up, solve caching or geo pricing before re-submitting.

Final checklist (fast pass)

Use this before requesting a review or after major catalog changes.

💰 Price
  • Visible price matches Offer.price and feed price.
  • sale_price logic is consistent with promo timing and cache.
  • Currency strategy is coherent (or multi-currency is fully aligned).
  • Cache/CDN does not serve stale prices.
📦 Availability
  • Visible stock matches Offer.availability and feed availability.
  • Variants update both UI and markup (or you use stable per-variant URLs).
  • Inventory sync windows don’t create mismatch gaps.

Want to detect these inconsistencies automatically before requesting a review?

Generate a report: landing page checks, schema duplication, cache risk, and price/stock alignment — your “pre-review” fast pass.

Get 1 free report Log in