Why AI Quotes Your Old Pricing — and How to Signal Which Number Is Current

There are two different pricing problems in AI search, and most advice only covers the first.

The first is visibility: your pricing page is JavaScript-rendered or gated behind "contact us," so the AI can't read it at all. We wrote about that in The Pricing Page Problem. The fix is to make the number readable.

The second problem shows up after you've fixed the first, and it's the one people search for once they've noticed it: your pricing page renders fine, the number is right there in the HTML — and ChatGPT still quotes a price you retired eighteen months ago.

That's not a visibility problem. It's a freshness problem. The AI can see your pricing. It just isn't sure which version of it is true.

The exact question buyers and operators are typing into search looks like this: "how should we format pricing pages so that AI models pull accurate current pricing instead of hallucinating outdated numbers from cached sources?" It's a specific, sophisticated question, and the honest answer has three parts: understand where the stale number comes from, remove the ambiguity a model has to resolve, and stop feeding the old number from your own surfaces.

Where the outdated number actually comes from

When an AI quotes a price that's no longer real, it's usually pulling from one of four places. They call for different fixes, so it's worth being precise about which one you're looking at.

Model memory. Some answers come from the model's training data, not a live fetch. If your $49 tier was $29 two years ago and that number was all over the web during the training window, the model may reproduce $29 from memory even when nothing current says so. You can't edit training data. What you can do is make the current number so consistently present across live-retrievable sources that a retrieval-grounded answer overrides the stale memory.

A cached copy of your own page. Search indexes and retrieval systems don't recrawl on your schedule. If you changed the price last week, the copy a system holds may still be last month's. This resolves on its own as the page is recrawled — but you can accelerate it, and you can stop making it worse.

A stale third-party source. A review site, a "top 10 tools" listicle, or an old comparison post published your previous pricing and never updated it. To a model synthesizing an answer, that page looks as authoritative as yours — sometimes more, because it's independent. This is often the real culprit, and it's the one teams forget to check.

Genuine ambiguity on your own page. Your pricing page shows a promotional price, a legacy grandfathered tier, an annual number and a monthly number, and a "starting from" figure — all without making clear which is the current standard rate. The model picks one, and it may not be the one you'd have chosen.

The important consequence: "my pricing page is correct" does not mean "AI will quote it correctly." Three of those four sources sit outside the page itself. Fixing the page is necessary and not sufficient.

Make the current number unambiguous — to a machine

Start with the surface you fully control. The goal is to leave a retrieval system with exactly one defensible answer to "what does this cost right now."

Put a visible date on the price. Not in a schema field a human never sees — in the actual text of the page. "Pricing effective January 2026" or "Updated August 13, 2026" next to the tiers gives both a buyer and a model a freshness signal it can quote. A page with no date is a page a model can't tell is current.

Mark the current rate as current, in words. If a promotional or legacy price appears anywhere on the page, label the standard rate explicitly: "Standard pricing" versus "Limited-time offer" versus "Legacy plan (no longer available to new customers)." Don't make the model infer which number applies to a new buyer. It will sometimes infer wrong.

Add Offer schema with a priceValidUntil date. Structured data won't override a confidently wrong answer on its own, but it gives an unambiguous machine-readable statement of the price, the currency, and — critically — how long it's valid. Keep it exactly consistent with the visible number; a schema price that disagrees with the on-page price is worse than no schema at all.

Use dateModified honestly. If your CMS stamps dateModified on every deploy regardless of whether the pricing changed, the signal is noise. Reserve a meaningful "last reviewed" date for when the pricing actually changed, so it means something when a system reads it.

Here's what the difference looks like to a crawler. Both pages render identically to a human. Only one is quotable with confidence.

Ambiguous: Pro — $49/mo. Save 40% this month! (Is $49 the current price or the discounted one? Is the discount still on? When does it end?)

Unambiguous: Pro — Standard price $49/month, effective January 2026. Annual billing $490/year. With matching Offer schema carrying price: 49, priceCurrency: USD, priceValidUntil.

Then fix the sources you don't own

This is the step teams skip, and it's often where the wrong number is actually coming from.

Audit the third-party pages that publish your pricing. Search your product name plus "pricing" and "cost" in the answer engines your buyers use. When a stale number appears, note the cited source. A review platform, a comparison article, an old blog post — each has its own correction path, and most will update a factual price if you ask, because a wrong price is bad for them too.

Refresh your review-platform profiles. If your G2, Capterra, or TrustRadius listing carries old pricing, that's a high-authority stale source feeding the exact query you're worried about. Disclosure: I work at G2. The point holds regardless of platform — an independent profile with a wrong price is exactly the kind of source a model trusts.

Prompt a recrawl of your own page. For Bing and Copilot, IndexNow can notify the engine that a URL changed. It doesn't guarantee a recrawl or a ranking, but it shortens the window in which a cached price lingers. For Google, request indexing on the pricing URL in Search Console after a change.

Don't leave the old number live on your own site. Retired pricing pages that still resolve, cached PDFs of old rate cards, help-center articles quoting a legacy plan — these are your own surfaces feeding the stale answer. Redirect or update them.

How to check whether it worked

Freshness is measurable, if you record the conditions. Don't screenshot one answer and call it fixed.

1. Ask the price question directly in each engine your buyers use — "how much does [Product] cost?" — and record the product, mode, date, and the exact number returned. Note the cited source if one is shown.
2. Repeat it. Answers vary between runs. Run the question several times so you know the range before you judge a change.
3. Re-test after each fix, on the same protocol. Change the page, request a recrawl, correct a third-party source — then re-run the same prompts and watch whether the quoted number moves. A wrong price that persists across many runs after you've corrected every source you control usually means model memory or a source you haven't found yet.

The pricing-freshness fix rarely lands in a day, because part of it depends on other people's crawl schedules and other people's pages. But it's tractable, and it targets one of the highest-intent questions a buyer can ask an AI about you: what does this cost? Getting quoted the wrong answer to that question doesn't just lose a click. It anchors a buyer to a number you no longer charge.

If you're not sure which of the four sources is quoting your old price, run an audit first. The fix for a cached page is different from the fix for a stale review profile, and knowing which one you have tells you where to start.

---

This post is a companion to The Pricing Page Problem and draws on the technical AEO chapter of The Citation Economy. One post is about being readable; this one is about being current.