Conflicting product data is the same product stated differently in two places your site controls. The page says one price, the markup says another. The feed says in stock, the page says out of stock. The category page lists the old name, the product page lists the new one. A shopper can usually tell which version to trust by looking at the page. An AI system cannot. It reads all of them, finds no single answer, and either picks one at random, drops the product, or quotes a fact that is wrong at checkout. Fixing the conflict means finding every place the fact lives, picking one source of truth, and making every other place render from it.
Google states the rule behind this work in its general structured data guidelines: your structured data must be a true representation of the page content, and you should not mark up content that is not visible to readers of the page. A price in the markup that the page does not show is not a second opinion. It is a violation of that rule, and it is the conflict an AI system trips over first.
Where conflicts come from
Most conflicts are not typos. They are systems. A store rarely has one place that states a price. It has several, and each one was set up at a different time by a different tool.
The theme and an app both emit markup. The theme writes one Product block, and a reviews app or SEO app writes a second one, with a different price. The page source then holds two competing sets of facts. This is the most common source of conflicting markup, and it is easy to miss, because each block looks correct on its own.
The markup is generated from a different feed than the page. The page renders from the catalog, and the JSON-LD renders from a cached copy, a search index, or a feed that updates on a different schedule. The two agree at launch and drift apart with every price change.
The sale price and the regular price swap places. The page shows the sale price with the original struck through. The markup holds the original price in the price field and the sale price in a priceSpecification, or the other way around. Google documents the correct pattern in its merchant listing guide: the active price, the price a shopper pays now, goes in offers.price, and the original price goes in a priceSpecification with priceType set to StrikethroughPrice. A swap here is a conflict between the page and the markup, even when both numbers appear somewhere.
The feed disagrees with the site. Google says that providing both structured data and a Merchant Center feed maximizes eligibility and helps it correctly understand and verify your data, and that some experiences combine data from both sources. When the feed and the markup disagree, the combination has no clean answer. The feed and the site must be generated from the same catalog data.
Category and search pages state facts the product page contradicts. A category tile says in stock, the product page says out of stock. A search result snippet shows the old price, the product page shows the new one. These pages are usually cached or generated from an index, and they lag behind the product page.
Currency and condition get mixed in. One place shows the price in USD and another shows the same digits with no currency, or one place says new and another says refurbished. A number without a currency is not the same fact as a number with one, and a condition is part of the offer, not decoration.
Step 1: list every place the fact lives
Pick one product and trace its price, its availability, its name, and its SKU through every surface. Check each of these:
- The product page, as a shopper sees it, including the price, the sale price, the stock badge, and the variant selector.
- The page source, searching for every script tag of type application/ld+json. Count the Product blocks. Note which system emits each one.
- The category page and the search results page where the product appears.
- The product feed, if you submit one to a merchant center, and any feed a marketplace or shopping surface reads.
- The llms.txt file, if it lists the product, and any other machine-readable file that states the price or the stock status.
- The variant URLs, if the product has variants, loading each one directly.
Write down what each place says, in one list, before you change anything. A conflict you have not written down is a conflict you will fix in one place and miss in another.
Step 2: pick one source of truth
One system owns each fact, and every other place renders from it. For most stores, the catalog is the source of truth for name, SKU, and base price, and the inventory system is the source of truth for availability. The page, the markup, the feed, and the category tile all render from those two systems, in the same change, from the same values.
If two systems both claim to own the price, pick one and demote the other to a reader. A price that lives in the catalog and in a pricing app, with no rule for which wins, will conflict again at the next sale. The same applies to markup: one system owns the Product block. If the theme and an app both emit one, disable one of them. Keeping both and trying to keep them in sync is the conflict, not the fix.
Step 3: fix the markup first, because it is the loudest conflict
The markup is the place an AI system reads first, and it is the place a duplicate hurts most. Work through the page source:
- If there are two Product blocks for the same product, keep one and remove the other. Do not merge them by hand. Remove the emitter that should not own the block, so the next price change does not recreate the duplicate.
- If the remaining block disagrees with the visible page, fix the block to match the page, not the other way around. The visible page is what the shopper can check. Generate the block from the same data that renders the page.
- If the block holds a sale price, check the pattern. The active price goes in offers.price. The original price goes in a priceSpecification with StrikethroughPrice. The sale end goes in validThrough or priceValidUntil, and a past end date must be removed when the sale ends.
- If the block holds a variant price, check that each variant has its own Offer with its own price and availability. A single Offer with a price range is not a variant. See our guide to marking up product variants.
Here is the shape a corrected block takes, for a kitchen store. In the example, [yourdomain.com] is a placeholder, replacing yourdomain.com with your actual domain. The store and the product are fictional, and the values are teaching samples for your own store. The point of the sample is the single, consistent set of facts, not the numbers.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Copper Kettle Cast Iron Skillet",
"image": [
"https://[yourdomain.com]/images/copper-kettle-skillet.jpg"
],
"description": "Pre-seasoned cast iron skillet with a helper handle and a pouring spout.",
"sku": "CK-SKILLET-12",
"brand": {
"@type": "Brand",
"name": "Copper Kettle Kitchen"
},
"offers": {
"@type": "Offer",
"url": "https://[yourdomain.com]/products/copper-kettle-skillet",
"price": "58.00",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition"
}
}
</script>
One Product block, one Offer, one price, one currency, one availability value, all matching the visible page. That is the target state. Everything else in this guide is how to get there and keep it there.
Step 4: fix the feed and the listing pages
The feed is the next place to check, because it is the place a shopping surface reads when the page is not in front of it. Generate the feed from the same catalog data as the page, on the same schedule, and check the fields that conflict most often: price, sale price, availability, condition, and the product URL. A feed URL that points at a different page from the markup URL is a conflict, even when the price matches.
Category and search pages are usually an index problem. If the index updates on a schedule, shorten the schedule for price and stock, or make the tile render from the live catalog value instead of the indexed copy. A tile that says in stock for a product that sold out is a conflict a shopper discovers at the product page, and an AI system discovers in the same way, by reading both.
Step 5: validate, then check by hand
Two free tools, no signup, and they check different things:
- Google's Rich Results Test: paste a product URL and it shows which product fields Google detects, with errors and warnings per field. Run it after every fix, because it shows how many Product blocks Google sees, not just whether one of them is valid.
- The Schema Markup Validator: checks the JSON-LD against the schema.org vocabulary itself, which catches typos in property names that Google's tool may not flag.
Neither tool will tell you the price in the markup is different from the price on the page, or that the feed disagrees with both. That check is a hand check. Open the page, read the price and the stock badge, read the markup in the page source, and read the feed entry for the same product. All three must agree. Then pick one product on sale, one out-of-stock product, and one variant product, and repeat the same three-way read. The pattern of the conflict usually repeats across the catalog.
Say you run a kitchen store with two prices
Say you run a small kitchen store, and your cast iron skillet shows 58.00 on the product page. The page source holds two Product blocks: the theme says 58.00 and InStock, and a SEO app says 64.00 and InStock, because the app cached the price from before a sale. The feed says 58.00. An AI system reading the page has two prices and no way to know which one the shopper will pay.
The fix is not to edit the app block to 58.00. The fix is to disable the app's Product output, keep the theme as the single owner, and generate the theme block from the same catalog value that renders the page. Then the next sale changes the page and the markup together, and the conflict does not come back. The feed already agrees, so it stays as it is, and the category tile is checked against the same catalog value.
Common mistakes
Fixing one copy and leaving the other. The markup is corrected, the feed still holds the old price, and the next AI answer uses the feed. Fix every surface in the same change, or the conflict moves instead of ending.
Adding a third block to override the first two. A new block does not cancel the old ones. A system reading the page sees three sets of facts instead of two. Remove the emitters that should not own the block.
Treating the cache as the fix. Clearing a cache makes the page and the markup agree for one load, and then the next price change recreates the drift, because the two are still generated from different data. The fix is one source of truth, not a faster cache clear.
Assuming the validator proves the facts are right. A validator checks that the JSON-LD parses and that the property names are valid. It does not check that the price matches the page, that the stock status matches inventory, or that the feed agrees. Those checks are yours.
Leaving a stale sale in place. A sale ends, the page returns to the regular price, and the markup still holds the sale price with a past end date. Update the price, the sale fields, and the feed in the same change.
What this guide does not cover
This guide covers finding and fixing conflicts between the places your site states product facts. It does not cover writing the Product block itself, which is our product schema guide, or the price and availability fields in detail, which is our guide to marking up prices and availability, or the variant structure, which is our guide to marking up product variants, or the review fields, which is our guide to review schema. It also does not cover keeping facts accurate over time as prices and inventory change, which is monitoring work, or turning a recommendation into a completed purchase, which is the transaction layer.
Check your own brand now
Run the free scan. It takes seconds, no signup, and shows whether AI crawlers can read your product pages today: aizii.ai/aeo-scan
Run the free scanSources
- Google Search Central, General structured data guidelines (specific): https://developers.google.com/search/docs/guides/sd-policies
- Google Search Central, Merchant listing structured data (specific): https://developers.google.com/search/docs/appearance/structured-data/merchant-listing
- Google Search Central, Product structured data (specific): https://developers.google.com/search/docs/appearance/structured-data/product
- Schema.org, Product type (general standard): https://schema.org/Product
- Google Rich Results Test (general docs): https://search.google.com/test/rich-results
- Schema Markup Validator (general docs): https://validator.schema.org/
Note: links marked specific point to the page that supports the claim in this guide. Links marked general docs point to the vendor's general docs section for that topic, not to a page that proves every step. Check the vendor docs for the current path before relying on a menu name or click path in this guide.
