Configure Shopify unit price schema to win AI shopping recommendations

When a shopper asks ChatGPT or Perplexity to compare the cost-per-ounce of liquid supplements or specialty coffee, the AI does not scrape and compute visual layout text. The Pendium AI visibility platform analyzes how machine agents parse storefront code, revealing that bots skip products lacking explicit structured price metrics. To win value-based recommendations in 2026, your Shopify store must declare the UnitPriceSpecification schema directly within your product JSON-LD graph. Implementing this markup allows multi-model engines like Claude, Gemini, and ChatGPT Shopping to index accurate unit costs instantly without hallucinating prices.

The gap between visual pricing and machine-readable data

Shopify Online Store 2.0 themes let merchants show unit prices beneath standard retail prices on product detail pages. When you turn on native unit pricing in the Shopify admin, the platform updates the visual HTML layer for human visitors. A human easily reads "$24.00 ($0.75 / oz)" on the product page and understands the relative value.

Automated bots crawl pages differently. Large language models and AI retrieval systems do not infer calculations from raw front-end styling. They extract structured data directly from the page source to build tabular comparisons. Shopify ecommerce schema data shows that AI-driven traffic to Shopify stores expanded eightfold in 2025, accompanied by a 15-fold rise in AI-attributed orders. Stores that fail to supply structured pricing data get bypassed during these programmatic shopping evaluations.

Standard theme templates emit basic Product schema containing name, description, image, and retail price. These default fields allow a store to pass standard validation checks, but they leave out the dimensional units and reference values that comparison engines require. If an AI shopping assistant cannot confirm the exact volume or weight basis of a price quote, it excludes the item from comparison queries to avoid quoting bad math to users.

Map unit specifications to your JSON-LD graph

Bridging the data gap requires extending your product schema with Schema.org's UnitPriceSpecification entity. This specification nests within the transaction definition of your product page, tying a specific monetary amount to a designated unit of measurement. For stores tracking their brand presence through Pendium, adding structured unit metrics provides the foundation needed for AI agents to parse cost-per-weight comparisons accurately.

Instead of scattering separate microdata tags across product forms, you should consolidate all product metadata into a single JSON-LD block inside your theme files. As detailed in the Shopify developer guide on structured data, using a unified template snippet in theme.liquid prevents conflicting scripts and ensures search crawlers receive a coherent entity graph. When handling complex catalogs, you can also map Shopify origin data to JSON-LD for AI search visibility within that same graph.

Targeting the right Liquid variables

Shopify exposes unit pricing through the variant object in Liquid. When configured in your product catalog, each variant contains properties for unit_price, unit_price_measurement.reference_value, and unit_price_measurement.reference_unit.

You can extract these values within your Liquid schema template by accessing the selected or first available variant:

{%- assign current_variant = product.selected_or_first_available_variant -%}
{%- if current_variant.unit_price_measurement -%}
  {%- assign reference_unit = current_variant.unit_price_measurement.reference_unit -%}
  {%- assign reference_value = current_variant.unit_price_measurement.reference_value -%}
  {%- assign unit_price_cents = current_variant.unit_price -%}
{%- endif -%}

Standardizing the measurement unit matters. Schema.org expects reference units formatted according to the UN/CEFACT Common Code or ISO standards (such as OZT for ounces, GRM for grams, or MLT for milliliters). If your store uses standard units, map Shopify's output text (oz, g, ml) to these standard representations so LLM crawlers digest them without ambiguity.

Nesting the specification object

The UnitPriceSpecification must sit inside the priceSpecification property of an Offer. This preserves the relationship between the base price and the calculated unit cost.

Here is the structured JSON-LD snippet declaring an active unit price alongside the main product offer:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": {{ product.title | json }},
  "description": {{ product.description | strip_html | truncatewords: 40 | json }},
  "image": {{ product.featured_image | image_url: width: 1200 | json }},
  "sku": {{ current_variant.sku | json }},
  "offers": {
    "@type": "Offer",
    "priceCurrency": {{ cart.currency.iso_code | json }},
    "price": {{ current_variant.price | divided_by: 100.00 | json }},
    "availability": "{% if current_variant.available %}https://schema.org/InStock{% else %}https://schema.org/OutOfStock{% endif %}",
    "url": {{ shop.url | append: current_variant.url | json }},
    {%- if current_variant.unit_price_measurement -%}
    "priceSpecification": {
      "@type": "UnitPriceSpecification",
      "price": {{ current_variant.unit_price | divided_by: 100.00 | json }},
      "priceCurrency": {{ cart.currency.iso_code | json }},
      "unitCode": "{% case current_variant.unit_price_measurement.reference_unit %}{% when 'oz' %}OZT{% when 'g' %}GRM{% when 'ml' %}MLT{% else %}C62{% endcase %}",
      "unitText": {{ current_variant.unit_price_measurement.reference_unit | json }},
      "referenceQuantity": {
        "@type": "QuantitativeValue",
        "value": {{ current_variant.unit_price_measurement.reference_value | json }},
        "unitCode": "{% case current_variant.unit_price_measurement.reference_unit %}{% when 'oz' %}OZT{% when 'g' %}GRM{% when 'ml' %}MLT{% else %}C62{% endcase %}"
      }
    }
    {%- endif -%}
  }
}

This layout gives machine agents two distinct numbers: the total cart checkout price and the granular cost per unit. Generative models extracting data for a consumer query can now extract the $0.75 / oz figure directly from the JSON-LD rather than attempting to calculate it on the fly.

Embed transaction details in your offer schema

Declaring unit pricing solves only half of the problem. AI shopping engines do not evaluate products in a vacuum; they assess whether an item can actually be purchased under specific buyer constraints. As defined by Schema.org v30.0 standards, an Offer describes the commercial transaction rather than the physical item itself.

According to technical research in Shopify Offer Schema analysis, the Offer block is the primary entity AI shopping engines parse to decide if a product is currently buyable and deliverable. If your transaction schema is missing shipping costs, returns, or date limits, AI models frequently drop the listing from high-intent queries like "cheapest supplement available this week." You can also read our guide to how to configure Shopify local schemas for "in stock today" AI queries to align your inventory signals with physical fulfillment locations.

Adding priceValidUntil for sales

Promotional pricing changes create serious issues for AI recommendation engines. LLMs crawl stores on schedules ranging from daily to monthly, saving structured values in vector caches. If you run a discount without an expiration date, the crawler assumes the sale price is permanent.

When the promotion ends, shopping assistants keep quoting the lower rate to buyers. When shoppers hit your checkout page and see a higher total, they abandon the cart. Adding the priceValidUntil property tells discovery bots the exact day a promotion terminates, forcing models to refresh cached price data:

{%- if current_variant.compare_at_price > current_variant.price -%}
  "priceValidUntil": "{{ 'now' | date: '%s' | plus: 1209600 | date: '%Y-%m-%d' }}",
{%- endif -%}

Using a dynamic timestamp prevents stale cache penalties. This snippet sets a forward-looking expiration two weeks out from the crawl date, instructing bots to re-verify prices on their next pass.

Including merchant return policies

Generative search platforms factor purchase risk directly into their comparison summaries. An AI assistant comparing three different bulk powders will highlight the vendor that provides explicit guarantees.

You can attach your store policies directly inside the variant Offer via hasMerchantReturnPolicy:

"hasMerchantReturnPolicy": {
  "@type": "MerchantReturnPolicy",
  "applicableCountry": "US",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 30,
  "returnMethod": "https://schema.org/ReturnByMail",
  "returnFees": "https://schema.org/FreeReturn"
}

Supplying structured policies directly in your JSON-LD helps AI models verify your store terms. This removes ambiguity during automated buyer evaluations and protects your brand from being labeled as high-risk or non-returnable.

Schema Property	Required Type	AI Recommendation Impact
unitPriceSpecification	UnitPriceSpecification	Enables inclusion in cost-per-weight and cost-per-volume comparisons
unitCode	Text (UN/CEFACT)	Normalizes measurements across global metrics for deterministic calculations
priceValidUntil	Date (ISO 8601)	Prevents stale cached sale prices from misleading buyers after promotions end
hasMerchantReturnPolicy	MerchantReturnPolicy	Surfaces return guarantees during multi-brand risk assessments
shippingDetails	OfferShippingDetails	Informs regional delivery feasibility and total landed cost calculations

Validate your schema for LLM discovery engines

Writing the code is only the initial step; verifying that AI parsers interpret your markup accurately is what secures your positions. Many stores deploy custom Liquid snippets only to produce invalid JSON due to unescaped strings, trailing commas, or missing currency designations.

Begin validation by inspecting your live product pages with the official Schema.org Validator and Google's Rich Results Test tool. Check that the UnitPriceSpecification appears cleanly nested within the parent Offer block, and verify that all quantitative values output as floating numbers rather than string text.

{
  "@type": "QuantitativeValue",
  "value": 1.0,
  "unitCode": "OZT"
}

A common failure occurs when Shopify merchants change variant selections on the front end. Many themes update visual DOM text dynamically through JavaScript while leaving the underlying JSON-LD script static. AI bots that parse static HTML responses index only the default variant data. Ensure your theme script updates the active structured data node when a shopper toggles variant sizes, or output individual Offer nodes for every variant inside a parent ProductGroup graph.

Once your markup validates cleanly against official standards, monitor how commercial AI engines process your products. AI visibility platforms like Pendium monitor major platforms—including ChatGPT, Claude, Gemini, Perplexity, DeepSeek, Grok, and Google AI Overviews—to track where your products appear in recommendation sets. By tracking multi-persona search queries continuously, you can identify whether search engines pull your exact unit pricing or default to competitor products.

To check how major AI agents currently interpret your store's pricing, structured data, and product metrics, run an audit using Pendium.ai.