Skip to main content
Layers is designed for headless integrations that need to layer experimentation, dynamic pricing, or third-party A/B tooling on top of the storefront. Every API response — Search, Browse, and Blocks — returns each product’s full pricing information inline with the result set, so an experimentation layer can re-sort, filter, or modify prices without making a second round-trip per product. This page describes how prices are returned, how to combine Layers with an A/B testing platform, and how to handle promotional and B2B price overrides.

​
Prices are returned with every result

When you request products from the Search, Browse, Blocks, or Similar Products APIs, each item in the response carries its full price data by default. You do not need to hydrate prices separately from Shopify or another service before re-sorting. The relevant fields on each product:
  • price_range — minimum and maximum variant prices for the product.
  • variants — per-variant price, compare_at_price, and availability.
  • first_or_matched_variant — the variant most relevant to the request (matched against filters or facets), with its own price fields.
See Available Attributes for API Requests for the full attribute list and how to scope responses with the attributes parameter.
If you only need pricing for a subset of products, request the page size you actually plan to display. Layers paginates results — request page 1 with limit: 24, run your A/B re-sort on those 24 results, and request page 2 only when the shopper scrolls. You do not need to pull the entire collection client-side.

​
Sorting by price after an A/B price override

A common A/B testing pattern is to apply a dynamic discount (e.g., +5% on a treatment cohort) and then re-sort the visible page by the new price. Because Layers returns the original price on every result, the override can run entirely in your A/B platform or storefront code:
  1. Request the collection page from the Browse API with your normal sort order applied (e.g., relevance, best sellers).
  2. In your storefront, apply the cohort’s pricing transformation to each product’s price_range.min and per-variant price.
  3. Re-sort the visible page by the transformed price before rendering.
  4. Render with the SDK’s reactive ProductCard, which exposes the selected variant’s price as a signal so the UI updates without re-fetching.
Because every response page carries prices for every product on that page, the sort stays consistent as the shopper loads more — there is no “products at the bottom missing prices” failure mode.

​
Running A/B tests on Layers itself

If the test is on Layers configuration (sort order, ranking weights, search rule, merchandising rule), you can run the experiment without storefront code changes:
  • Sort order A/B — assign cohort A and B to different sort order codes and pass sortOrder on the API request based on cohort. The default sort order is configured per collection but always overridable via the API.
  • Search rule A/B — encode the cohort in context (for example context.experiment = "treatment") and write search rules that activate only for the treatment cohort. The rule can inject filters, swap sort orders, or apply expression-based boosts.
  • Block strategy A/B — when calling the Blocks API, choose between block strategies per cohort to test recommendation algorithms head-to-head.
Pair these tests with LayersQL metrics segmented by cohort to measure revenue, conversion, and engagement directly inside the Layers analytics dashboards. See Metric recipes for examples.

​
Promotional and B2B price overrides

When prices vary by market, B2B catalog, or active promotion, Layers resolves the correct price server-side before returning the result — so sort-by-price and price-range facets stay accurate.
  • Shopify Markets — Layers applies market-specific pricing when a market is in the request context.
  • B2B catalogs — when identity.companyLocationId is supplied, Layers applies catalog price list precedence before market and base variant pricing.
  • Abra Promotions — Layers natively integrates with Abra so flash-sale and discount entitlements feed into price sorting and price filtering automatically.
  • Custom discount entitlements — for arbitrary discount logic, pass discount entitlements on the request and Layers applies them to the response prices.
Use these built-in mechanisms whenever possible — they keep facet counts and sort-by-price ranks consistent across pagination. A storefront-side override is the right pattern only when the experiment specifically requires it to live in the A/B platform.

​
See also