Home › Blog › Shopify priceValidUntil and sale pricing schema

Shopify priceValidUntil and sale pricing schema: why AI shopping agents show stale prices (and how to fix it)

2026-06-11 — ~15 min read — priceValidUntilSale schemaPriceSpecificationShopify LiquidAI shopping

Your flash sale ended two weeks ago. ChatGPT Shopping is still quoting the sale price. Customers click through expecting a 30% discount and find the regular price — and they leave. This is not a ChatGPT bug. It is a missing priceValidUntil property in your Product JSON-LD, and 84% of Shopify stores on sale have the same gap.

Why AI agents show stale prices

AI shopping agents — ChatGPT Shopping, Perplexity, Google AI Mode — do not browse your store in real time when a user asks "how much is this?". They query a cached index of structured data that was built during a crawl that may have happened days or weeks ago. When that crawl ran, your product was on sale at $49. Today the price is $69. But your Product JSON-LD had no expiry signal, so the agent's index still holds the $49 price as valid.

This creates three compounding problems:

1. Incorrect pricing in AI result cards. Google AI Mode and Perplexity Shopping surface price directly in their result cards. A user sees "$49" and clicks through to a $69 product page. The expectation mismatch kills conversion and damages trust in your store.
2. Filtering exclusions. A user queries "running shoes under $60" — your product is now $69, but the AI's cached data still says $49 and includes your product in the filtered results. The user clicks, sees the real price, and bounces. This inflates AI-sourced bounce rates, which some agents use as a negative engagement signal for future ranking.
3. Review loop delays. Google's product review system can flag your product for "price mismatch between structured data and live page" — a penalty that can take weeks to clear, suppressing your organic rich result appearance even after you fix the JSON-LD.

The fix is simpler than most merchants expect: a single property, priceValidUntil, on the Offer object in your Product JSON-LD tells every AI agent exactly when your price expires. When the expiry passes, the agent treats the price as unverified and either re-crawls or withholds the price from result cards — both outcomes are better than quoting stale data.

priceValidUntil: the most overlooked Offer property

priceValidUntil is a schema.org property on Offer that specifies the date after which the listed price is no longer valid. Its intended use is exactly the stale-price problem: it gives AI agents, search engines, and price comparison tools a machine-readable expiry date so they know when to stop trusting the cached price.

The format is ISO 8601: a full date-time string including timezone offset. Examples:

• "2026-07-04T23:59:59-05:00" — US Central Time, midnight on the 4th of July
• "2026-12-26T00:00:00+00:00" — UTC midnight, Boxing Day sale end
• "2026-11-29T23:59:59-08:00" — US Pacific Time, Black Friday sale end

A date-only value ("2026-07-04") is accepted by schema.org but is ambiguous about timezone — most AI crawlers interpret it as midnight UTC, which may expire your price before your actual sale ends in your local timezone. Use the full date-time string with offset.

Here is the minimal Offer that correctly signals a sale price expiring at midnight US Eastern on July 4, 2026:

{
  "@type": "Offer",
  "price": "49.00",
  "priceCurrency": "USD",
  "availability": "https://schema.org/InStock",
  "url": "https://catalogscan.com/products/running-shoes",
  "priceValidUntil": "2026-07-04T23:59:59-05:00"
}

That single addition — priceValidUntil — eliminates the indefinite stale-price window. When that date passes, AI agents know the $49 price is no longer valid and will not surface it in results until they re-crawl and find a new price (or no price, if the sale has ended).

The four Shopify pricing scenarios and their correct schema

Shopify stores have four distinct pricing states, and each requires a different structured data pattern. Getting these right eliminates all the major AI pricing signal gaps.

PriceSpecification for sale events: SalePrice vs. ListPrice

The priceSpecification property on Offer accepts an array of PriceSpecification objects. Each specification has a priceType property that tells AI agents and search engines what kind of price they are looking at. This is the correct way to represent a "was $69, now $49" sale in structured data.

The two priceType values for sale pricing come from the PriceTypeEnumeration:

Here is the complete Offer for an active sale — a product normally priced at $69.00, currently on sale at $49.00 through July 4:

{
  "@type": "Offer",
  "price": "49.00",
  "priceCurrency": "USD",
  "availability": "https://schema.org/InStock",
  "url": "https://catalogscan.com/products/running-shoes",
  "priceValidUntil": "2026-07-04T23:59:59-05:00",
  "priceSpecification": [
    {
      "@type": "PriceSpecification",
      "price": "49.00",
      "priceCurrency": "USD",
      "priceType": "https://schema.org/SalePrice",
      "validFrom": "2026-06-20T00:00:00-05:00",
      "validThrough": "2026-07-04T23:59:59-05:00"
    },
    {
      "@type": "PriceSpecification",
      "price": "69.00",
      "priceCurrency": "USD",
      "priceType": "https://schema.org/ListPrice"
    }
  ]
}

The validFrom on the SalePrice specification is optional but recommended — it lets AI agents understand when the promotion started, which helps them detect when a cached price pre-dates the current promotion period. The ListPrice has no validFrom or validThrough because it represents the stable regular price that exists before and after the sale.

Liquid implementation for Dawn themes

The core challenge in Shopify is that Liquid does not expose a native "sale end date" variable — Shopify's promotions system handles discounts at checkout, not through product metafields. You have two paths for implementing dynamic priceValidUntil:

1. Metafield approach (recommended): Create a product metafield (custom.sale_end_date, type: date_time) and populate it whenever you start a sale. The Liquid snippet reads this metafield and conditionally outputs priceValidUntil.
2. Theme setting approach: For store-wide sales (Black Friday, site-wide clearance), add a global theme setting that stores the sale end date. The snippet reads settings.global_sale_end_date and applies it to all products where compare_at_price > 0.

This snippet uses the metafield approach, with a fallback to a theme setting for store-wide sales. Place it in your snippets/product-structured-data.liquid snippet, replacing or extending your existing Offer block:

{% comment %}
  Sale pricing signals for Product JSON-LD.
  Requires: product.metafields.custom.sale_end_date (date_time metafield)
  Optional: settings.global_sale_end_date (theme setting, date_time)
{% endcomment %}

{% assign sale_price = product.selected_or_first_available_variant.price | money_without_currency %}
{% assign compare_price = product.selected_or_first_available_variant.compare_at_price | money_without_currency %}
{% assign is_on_sale = false %}
{% if product.compare_at_price_max > product.price_min %}
  {% assign is_on_sale = true %}
{% endif %}

{% comment %} Resolve sale end date from metafield, then theme setting {% endcomment %}
{% assign sale_end_raw = product.metafields.custom.sale_end_date.value %}
{% if sale_end_raw == blank and settings.global_sale_end_date != blank %}
  {% assign sale_end_raw = settings.global_sale_end_date %}
{% endif %}

{
  "@type": "Offer",
  "price": "{{ sale_price }}",
  "priceCurrency": "{{ shop.currency }}",
  "availability": "https://schema.org/{% if product.available %}InStock{% else %}OutOfStock{% endif %}",
  "url": "{{ shop.url }}{{ product.url }}"
  {% if is_on_sale %}
  ,"priceValidUntil": "{% if sale_end_raw != blank %}{{ sale_end_raw | date: '%Y-%m-%dT%H:%M:%S%z' }}{% else %}{{ 'now' | date: '%s' | plus: 2592000 | date: '%Y-%m-%dT%H:%M:%S+00:00' }}{% endif %}"
  ,"priceSpecification": [
    {
      "@type": "PriceSpecification",
      "price": "{{ sale_price }}",
      "priceCurrency": "{{ shop.currency }}",
      "priceType": "https://schema.org/SalePrice"
      {% if sale_end_raw != blank %}
      ,"validThrough": "{{ sale_end_raw | date: '%Y-%m-%dT%H:%M:%S%z' }}"
      {% endif %}
    },
    {
      "@type": "PriceSpecification",
      "price": "{{ compare_price }}",
      "priceCurrency": "{{ shop.currency }}",
      "priceType": "https://schema.org/ListPrice"
    }
  ]
  {% endif %}
}

Notes on the Liquid snippet

• The 30-day fallback — when no sale end date is set but the product has a compare_at_price, the snippet sets priceValidUntil to 30 days from now (now | date: '%s' | plus: 2592000). This is intentionally conservative: it tells AI agents the sale price expires within 30 days, which prevents indefinite stale-price caching while you set up the proper metafield. Update this fallback interval to match your typical promotion length.
• Metafield setup in Shopify admin — create the metafield at Settings → Custom data → Products → Add definition. Set the namespace to custom, key to sale_end_date, and type to Date and time. You can then bulk-fill it via the Bulk editor or a CSV import when running promotions.
• The %z Liquid date filter — Shopify's date filter supports %z for timezone offset since Liquid 4.0.0 (available in all current Shopify themes). If your theme uses an older Liquid version, replace %z with a hardcoded offset matching your store's primary market timezone.
• Theme setting for site-wide sales — add the global_sale_end_date setting to your config/settings_schema.json under a "Promotions" section with "type": "text" and a placeholder "placeholder": "YYYY-MM-DDTHH:MM:SS+00:00". This allows you to set a single end date for Black Friday, Boxing Day, or other store-wide sales without touching every product's metafield.
• money_without_currency — the price property in schema.org Offer expects a decimal number string without currency symbol or thousands separator. Shopify's money_without_currency filter outputs "49.00", which is the correct format. Using money (which outputs "$49.00") will cause validation errors in schema.org and Google Rich Results Test.

Five mistakes that break pricing schema

Testing and validation

After adding priceValidUntil and PriceSpecification to your theme, validate with these tools:

1. Google Rich Results Test

Enter a product URL that is currently on sale. In the Product result, expand the offers block and confirm priceValidUntil appears with the correct ISO 8601 date-time string. Expand priceSpecification and verify both SalePrice and ListPrice entries appear. If you see "Value of type Date is expected" errors, check that your Liquid date filter output exactly matches ISO 8601 format.

2. schema.org validator

The schema.org validator (validator.schema.org) catches type mismatches that Google's tool sometimes accepts. Pay attention to warnings on priceType — the full URL form (https://schema.org/SalePrice) is required; the short form (SalePrice) may produce warnings depending on validator version.

3. Live page vs. JSON-LD price consistency check

Compare the price value in your JSON-LD (view source → search for application/ld+json) against the price shown on the product page. They must match exactly. Discrepancies indicate a theme caching issue — usually caused by Shopify's theme preview caching static JSON-LD in a snippet while the live price is dynamically rendered. See our complete guide on Shopify structured data audit tools for the exact workflow.

4. CatalogScan

CatalogScan's AI readiness scan checks whether sale products include priceValidUntil and validates the price consistency between your JSON-LD and the live page price. The scan also flags products where the JSON-LD price is higher than the live page price — a sign of stale structured data from a prior sale. For context on how AI agents evaluate pricing signals alongside availability and other offer properties, see our overview of Shopify availability states for AI shopping agents.

FAQ