Why Shopping Agents Get Prices Wrong, and What Fixes It
When an AI shopping agent quotes the wrong price, the cause is usually an old price, not a misread one. This guide shows how fast prices move on real data, with a demo, and the check that keeps an agent honest.
Wrong prices from AI shopping agents have a cause that is easy to miss. When an assistant quotes the wrong price, it is tempting to blame the model for misreading a number. In most cases the number was read correctly. It was simply old. A price that was right a week ago is the answer an agent gives if it remembers the price instead of checking it, and shoppers act on that answer. This guide explains where wrong prices come from, shows on real data how quickly a remembered price goes stale, and describes the check that fixes it. It matters most for agents that recommend what to buy, because a price is usually the first thing a shopper tests. The demo below uses prices last pulled November 17, 2026.
Where a wrong price comes from
Four things produce most wrong prices, and only one of them is the model making a mistake.
The first three are the same problem: the price was true when it was read and false when it was used. Our post on handling out-of-stock and price-changed offers covers what to do when the change is found. This guide is about how often there is one to find.
Check a remembered price against today’s
The demo below uses real daily prices from the Price History API. Pick a product and pick when an agent last checked its price: yesterday, a week ago, a month ago or two months ago. The first tile is the lowest in-stock price on that day, which is what the agent would quote. The second is the lowest in-stock price today. The chart shows the last 90 days with both marked. The page holds a rotating set of products that is rebuilt every night, and it offers three of them, a different three on most visits.
Prices fall as well as rise, and the demo shows both. A quote that is too low sends a shopper to a checkout that costs more than they were told. A quote that is too high does the opposite harm: the agent may steer a shopper away from a price that has dropped. Neither is a model error. Both come from skipping a check that takes one request.
How far prices moved
We compared the same daily prices on November 12, 2026 for the six products in that day’s set. The price an agent would have quoted a week ago was different from today’s for four of the six. Going back a month, four of the six were different. The largest move over a month was on the Razer DeathAdder Essential mouse, from $24.98 to $14.97.
This table is fixed to November 12, 2026. The demo above is rebuilt every night with a different set of products, so its figures will change. Treat the table as a record of one day.
A handful of products is a small sample and not a market study. Each figure is the lowest in-stock price across the stores that reported the product on that day, in US dollars. A product that did not move is as informative as one that did, since an agent cannot tell which kind it has without checking.
What fixes it
The fix is unglamorous: check the price when the answer is given, and show the date with it. Four habits make an agent reliable about prices.
Fetch the price at answer time. Use the barcode to ask for the product, and read today’s price from the response. This is one request, and the demo shows it under the tiles. Barcode search explains why the barcode is the right key.
Keep the date with the price. A price with no date cannot be judged. If the agent has to reuse an older price, it should say how old it is.
Say which window you mean. “Lowest price” needs a period. Showing readers a product’s lowest recent price walks through the label, and how price history helps a reader trust a deal covers why shoppers respond to it.
Let code, not the model, hold the numbers. A model writes the sentence. A small function decides whether the old price still stands. Here is one that does.
// remembered: { barcode, price, checkedAt } the agent saved earlier
// listings: the data array of a fresh price history response (include_series false)
function checkQuote(remembered, listings) {
const inStock = listings.filter(l => l.product.availability === "InStock");
if (!inStock.length) return { status: "out_of_stock" };
const today = Math.min(...inStock.map(l => l.stats.current.final_price));
const gap = Math.round((today - remembered.price) * 100) / 100;
return {
status: gap === 0 ? "still_right" : gap > 0 ? "price_rose" : "price_fell",
quote: remembered.price,
today,
gap
};
}
The result goes back to the model as structured fields. The model never decides whether a price is current, so it cannot be talked into believing an old one. LLM product data API covers how to hand a model data in a form it uses well.
What a good price answer looks like
The check is half of the fix. The other half is how the answer is written. A shopper reading “it costs $89” has no way to tell whether that is today’s price or last month’s. A shopper reading “it costs $89 at one store, checked just now, and its lowest price in the last 90 days was $79” can decide for themselves.
Three details make the difference. The answer names the store, because a price belongs to a seller. It says when the price was read, even if only as “just now”. And it gives a reference point, such as the lowest price in the window, so that the number means something. All three come straight from the response of the request below, so the agent does not need to invent any of them.
This also makes errors visible. If a price turns out to be wrong, a dated answer shows whether the price changed after it was read or was read incorrectly. An undated answer leaves nothing to investigate, and the team is left guessing at the cause.
The request that does it
The re-check is a Price History API request for one barcode. Setting include_series to false asks for the summary of each store and leaves out the daily series, which keeps the response small enough to place in a prompt. stats.current holds each store’s current price, and product.availability says whether it is in stock.
POST https://api.affiliate.com/v1/products/price-history
{
"target_type": "barcode",
"target_ids": ["606449166422"],
"currency": "USD",
"include_series": false,
"include_stats": true,
"include_product": true,
"per_page": 25
}
One barcode per request, and up to 25 stores per page. An agent that already knows the barcode from an earlier search makes this one call instead of a new search. Through MCP the same request is the get-price-history tool with the same arguments. MCP integration for AI shopping shows how to connect it.
Getting started in three steps
Moving from the demo to an agent that checks its prices takes three steps.
- ✓One request re-checks a price by barcode
- ✓Stock and current price for every store that sells it
- ✓The same check as an MCP tool or a REST request
{
"target_type": "barcode",
"target_ids": [
"606449166422"
],
"currency": "USD",
"include_series": false,
"include_stats": true,
"include_product": true,
"per_page": 25
}