Aizii Learn · AI Search
← Back to Learn

How to fix AI showing the wrong price for your products

When an AI system shows the wrong price for your product, the price is wrong somewhere a system can read it. The page may be right and the markup wrong. The markup may be right and the feed wrong. The feed may be right and an old guide wrong. The assistant is not choosing a wrong price on purpose. It is reading a copy that disagrees with the price you charge, and quoting the copy it trusts most.

The fix is to find every copy of the price, make them agree, and check the result with the assistants themselves. Do not try to fix the model itself. No submission step exists that tells a model a price has changed. The model learns the right price by reading updated pages, updated markup, or an updated feed.

Where it goes wrong

A wrong price in an AI answer almost always traces to one of these failures, and each one points at a different copy to fix.

  • The visible price and the markup disagree. The page says one price and the structured data block still carries the old price. An AI system reading the markup will quote the price it finds there, even when it is old.
  • The active price and the strikethrough price are swapped. The sale price was written into the price field, and the regular price was written as the sale price, or the other way round. Google documents that the active price is the amount currently offered, and that the strikethrough price is the higher regular price shown during a sale. Swap them, and the assistant quotes the wrong one.
  • The discount price went into priceSpecification, and the active price stayed old. Google documents that if you use both offers.price and offers.priceSpecification to encode an active price, Google will use the price provided through offers.price. A discount written only into priceSpecification, with the old price still in offers.price, will not change the price an assistant quotes.
  • The priceValidUntil points to a past date. Google documents that a listing may not display if priceValidUntil indicates a past date. A sale that ended, with its end still in the markup, can hide the listing or keep the old sale price circulating.
  • The feed and the page disagree. Merchant Center holds the feed price, and the landing page holds the page price. When they disagree, Google's own docs say its crawler compares the price in the data source with the price on the page or in the structured data. A mismatch risks a Shopping disapproval, and a wrong answer everywhere else.
  • The wrong price lives somewhere you do not control. A marketplace listing, a review roundup, or a cached copy still shows the old price. You cannot edit those listings, but you can make your own pages agree, so the current price is the one your own site states everywhere.
  • The price is per variant, and only one variant was fixed. A product with options at different prices needs the price fixed for each option, not only for the product as a whole. A shopper who picks a size and sees a different price has been misled, even if the product page as a whole says the right thing.

The steps

Step 1. Write down the price you actually charge. The marketer opens the live product page in a browser where they are not logged in, and writes down the price a shopper pays, the regular price if there is a sale, the currency, and the stock status, for each variant. That is the truth the other copies must match. If the checkout shows a different price from the page, fix the checkout first. The page, the markup, and the feed must all match the checkout, not each other.

Step 2. Check the markup against the page. The developer opens the live product page, views the page source, and finds the structured data block. Compare the price, the currency, and the availability in the block with the visible page, line by line. Check whether priceValidUntil points to a past date, and whether the active price and the strikethrough price are the right way round. If the block still shows the old price, fix the template so it reads from the same record as the visible price. Do not paste a second block on top of the stale one. One clean block, from one source, is the goal.

Step 3. Check the feed against the page. The marketer or the developer opens the feed export and finds the row for the product. Compare the price, the sale price, and the availability in the row with the page. Google documents that the price in the feed must match the landing page, and that the sale price must be submitted in addition to the price field set to the non-sale price. If the feed updates on a schedule, a price changed after the last fetch still waits for the next one, so check the export, not the schedule. Regenerate the feed from the product record after the fix, and confirm the new price is in the export.

Step 4. Sweep the rest of the site for the old price. The marketer searches the store for the old price and the old sale wording: guides, comparison pages, collection descriptions, blog posts, and the shipping and returns page where it mentions a price. Fix each one, or take the price out of it. A guide that prints a price goes stale the moment the price moves, so guides should link to the product page for the current price rather than printing it. Check the store search as well. A search result that still shows the old price teaches shoppers and assistants the wrong number.

Step 5. Ask the assistants what they say, and fix the source they cite. After the page, the markup, and the feed agree, ask the assistants themselves what they say about the product, using the questions your customers ask. If an assistant still quotes the wrong price, look at what it cites. The gap is usually in the facts themselves: a page that still shows the old price, a feed row that was missed, or a marketplace listing you do not control. Start with the source you own. Do not try to fix the model itself. No submission step exists that tells a model a price has changed.

Step 6. Keep a price change log, and check it after every change. The marketer keeps a short log: the product, the old price, the new price, the date the change was made, and whether the page, the markup, and the feed were all updated. Check the log after every price change, and after every sale ends. The usual reason a store keeps quoting a price it no longer charges is a sale price left in place after the sale ended.

The machine-readable piece

This is the Offer block for a product after a price fix, with the active price and the strikethrough price the right way round. Swap the placeholders for your own values. Those fields come from the schema.org Offer type and the Google Product structured data page. The active price is the price a shopper pays, the regular price is marked as the strikethrough price, and the price, the currency, and the availability must match the visible page exactly. Do not mark the active price with a priceType.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Example coffee grinder",
  "offers": {
    "@type": "Offer",
    "price": "149.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "priceSpecification": {
      "@type": "UnitPriceSpecification",
      "price": "179.00",
      "priceCurrency": "USD",
      "priceType": "https://schema.org/StrikethroughPrice"
    },
    "url": "https://[yourdomain.com]/products/example-coffee-grinder"
  }
}
</script>

If there is no sale, leave the priceSpecification out entirely, and state only the active price. A strikethrough price with no sale is a second wrong price waiting to be quoted. Check the block after every price change. Open the page source and confirm the block carries the new price, then open the feed and confirm the row carries the same price and availability. Where the two disagree, fix the one that is wrong.

What it looks like when it works

On the page, a shopper sees the price they pay next to the options, the regular price crossed out beside it while a sale runs, and the stock status in words. Under the surface, the structured data block carries that same price, and the feed row carries the same price and availability. To a human reader, nothing on the page looks different. What changes is that every place a machine can look states the same number.

Say you run a coffee gear store, selling grinders, brewers, and kettles, with a grinder whose price was cut for a sale and then restored. The marketer writes down the price a shopper pays, checks the page, and finds it right. The developer checks the markup and finds the old sale price still in offers.price, with the regular price written into priceSpecification. He fixes the template so the block reads from the same record as the visible price, and rechecks the page source. The marketer checks the feed and finds the row still carries the sale price, regenerates the feed, and confirms the new price in the export. She searches the site and finds the old price still printed in a comparison guide, and changes the guide to link to the product page for the current price. A shopper asks an assistant for a coffee grinder under a set budget. The assistant reads the page, the markup, and the feed, finds the same price in all three, and quotes it.

The fundamentals

These mechanics are shared across every engine, and their own guides cover them in full:

What this guide does not cover

This guide covers finding and fixing a wrong price in the places AI systems read. It leaves out the full technical audit across every crawler and every page, the transaction layer that lets an agent finish a purchase, and the per-engine playbooks for each assistant. It does not cover pricing strategy, or keeping prices accurate in marketplaces you do not control. Those are separate jobs, and this guide is only the map, not the whole trip.

Check your own store now

Run the free scan. One click, no signup, and it shows whether AI crawlers can read your store today: aizii.ai/aeo-scan

Run the free scan

Sources

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.