Aizii Learn · AI Search
← Back to Learn

How to update AI models when you change prices

When you change a price, your job is to make the new price the only price an AI system can find. Update the price in every place it appears at the same time: the product page, the structured data on that page, and the product feed if you run one. Then let the crawlers come and read the new page. No vendor publishes a fixed time for an AI model to pick up a price change, and this guide does not claim one. What you control is whether the new price is consistent everywhere a model can look.

Price changes are a marketer-led job with one developer check. The marketer owns the price itself, the sale start and end, and the words on the page. The developer owns the structured data and the feed, and confirms the new price appears in both. If you are both people, do the page first, then the markup, then the feed, in that order, before you announce the sale anywhere.

Where it goes wrong

Stale prices in AI answers almost always trace to one of these failures, not to a model choosing an old price on purpose.

  • The page changed, but the markup did not. The visible price says one thing and the structured data block still carries the old price. An AI system that reads the markup quotes the old price.
  • The feed changed, but the page did not, or the other way round. Google Merchant Center holds the feed price, and the landing page holds the page price. When they disagree, Google documents that its crawler compares the price in the data source with the price on the page or in the structured data. A mismatch is a disapproval risk for Shopping, and a wrong answer risk everywhere else.
  • The sale price went up, but the old sale price still sits in a guide, a comparison page, or a blog post. The product page is current, but the rest of the site still teaches the old price.
  • The old price lives in a cached copy, a marketplace listing, or a review roundup. You cannot edit those, but you can make your own pages agree, so the current price is the one your own site states everywhere.
  • The price changed, but the availability did not. A product marked in stock at the old price, then sold out during the sale, keeps getting recommended until the stock status catches up. Price and availability drift together, so update them together.
  • The sale ended, but the sale price stayed. A discount that ended on the page but still shows in the markup or the feed keeps getting quoted until someone removes it from every place.

The steps

Step 1. Change the price on the page first. The marketer edits the price in the product editor, on the product page itself, and checks the live page in a browser. The price, the options, and the stock status should be visible without clicking, and the price should match the checkout. If the product has options with different prices, set the price for each option, not only for the product as a whole. State the sale terms in plain words on the page: what the sale price is, what the regular price is, and when the sale ends. Do not rely on a banner alone. A banner can disappear while the page still shows the old price.

Step 2. Update the structured data to match. The developer opens the live product page, views the page source, and finds the structured data block. Change the price, the currency, and the availability in the block to match the visible page exactly, then recheck the page. Google documents that its automatic updates can correct price, sale price, availability, and condition from the structured data on the landing page, and that those corrections are enabled by default. Google also says those corrections are not a replacement for regular updates of your product data, so do not rely on them as the update itself. Fix the markup first, and let the automatic correction stay a safety net. Validate a sample of changed pages, including one with option-level pricing and one out-of-stock product.

Step 3. Update the product feed the same day. If you run a Google Merchant Center feed, the marketer or the developer updates the price and availability rows for every changed product, using the same values as the page. Google documents that its product data specification requires price and availability for every product, and that the price must match the landing page. Keep the feed and the page in agreement on every product, not only the ones on sale. If your feed updates on a schedule, such as a daily fetch, a price changed after the fetch still waits for the next one, so plan sale launches around the feed schedule you actually run. For catalogs that change often, Google points to the Merchant API for scheduled product uploads.

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 if it mentions a price. Update each one or remove the price from it. A guide that names a price becomes wrong the day the price changes, so prefer guides that link to the product page for the current price instead of printing it. Check the store search too. A search result that shows the old price teaches the shopper, and the assistant, the wrong number.

Step 5. Check what the assistants say, and fix the source. After the page, the markup, and the feed agree, ask the assistants themselves what they say about your changed products, using the questions your customers ask. If an assistant still quotes the old price, look at what it cites. The gap is usually in the facts: a page that still shows the old price, a feed row that was missed, or a marketplace listing you do not control. Fix the source you own first. Do not try to correct the model directly. There is no submission step that tells a model a price changed. The model learns it by reading the updated page, the updated markup, or the updated feed.

Step 6. Close the sale the same way you opened it. When the sale ends, the marketer removes the sale price from the page, the developer removes it from the markup, and the feed is updated the same day. Check the page after the sale ends to confirm the regular price is the only price showing. A sale price left behind after the sale ends is the most common way a store keeps quoting a price it no longer honors.

The machine-readable piece

This is the Offer block for a product page after a price change. Replace the placeholders with your own values. The fields come from the schema.org Offer type and the Google Product structured data page. The price, the currency, and the availability must match the visible page exactly.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Example running shoe",
  "offers": {
    "@type": "Offer",
    "price": "119.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://[yourdomain.com]/products/example-running-shoe"
  }
}
</script>

For the Merchant Center feed, the matching row carries the same price and availability. The required fields below come from the Google product data specification: id, title, description, link, image_link, availability, and price. This is a tab-delimited row, with tabs between the values. Replace every placeholder with your own values.

id	title	description	link	image_link	availability	price
example-shoe-01	Example running shoe	Plain description of the shoe	https://[yourdomain.com]/products/example-running-shoe	https://[yourdomain.com]/images/example-shoe.jpg	in_stock	119.00 USD

Check both after every price change. View 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. If the two disagree, fix the one that is wrong. Do not add a field you cannot fill with a true value, and do not guess a value to fill a row.

What it looks like when it works

On the page, a shopper sees the current price next to the size options, the regular price crossed out beside it while the sale runs, the sale end in plain words, and the stock status in words. Under the surface, the structured data block carries the same price, and the feed row carries the same price and availability. Nothing on the page looks different to a human reader. The change is that every place a machine can look states the same number.

Say you run a running shoe store, selling road shoes, trail shoes, and racing flats, with prices that change for seasonal sales. The marketer drops the price on a road shoe for a sale, edits the page to show the sale price, the regular price, and the sale end in plain words, and tells the developer the same day. The developer updates the structured data block to match and rechecks the page source. The marketer updates the feed row for that shoe, then 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 instead of printing it. A shopper asks an assistant for a road shoe under a set budget. The assistant reads the page, the markup, and the feed, finds the same price in all three, and quotes the sale price. When the sale ends, the marketer restores the regular price on the page, the developer restores it in the markup, and the feed is updated the same day, so the sale price stops being quoted.

The fundamentals

These mechanics are shared across every engine and covered in full in their own guides:

What this guide does not cover

This guide covers keeping prices current in the places AI systems read. It does not cover the full technical audit that checks every crawler and every page, the transaction layer that lets an agent complete a purchase, or the per-engine playbooks for getting each assistant to find you. It does not cover pricing strategy, discount design, or keeping prices accurate in marketplaces you do not control. Those are separate jobs, and this guide is 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.