"Invalid value for category [price]": why a Shopify product reaches Google with a price of zero

Short answer. Google rejects the item because the price it received is zero, and a merchant listing requires a price above zero. On Shopify the zero has three sources: a variant with no price set, a theme reading a field that can be empty, or Liquid integer division turning a real sub-unit price into 0. The Rich Results Test shows the price Google actually received, not the one you typed.

Want to know if your store has this right now? Check my store, free 2 min · read-only

Google's guidance on this issue is short and leaves no room for interpretation. The Merchant Center help page states that the issue "occurs when you've entered 0 for the price [price] attribute", and documents exactly one exception: "if the product is a mobile device, sold as a part of a contract or promotion. During this promotion for mobile devices, the price [price] attribute value can be 0."

Unless you sell phones on contract, a zero price is simply not an offer, and Google treats it accordingly.

The part that makes this hard to catch

A zero price is a loud failure with a quiet distribution. It rarely affects a whole catalog. It affects a handful of products inside a catalog that otherwise looks perfectly healthy, which is precisely why nobody notices until an item stops selling or a disapproval appears.

A zero price is usually deliberate, and that is exactly what hides the one that is not. Reading the public catalogue listings of 28 Shopify-served storefronts on 7 November 2026, we counted 144 variant prices of exactly zero out of 35,414, on 9 of the 28 stores. Then we fetched and parsed 73 product pages from those same stores, and exactly one declared a price of zero in its structured data. On that one, the store’s own catalogue confirms the single variant really is priced at zero, and the page’s og:price:amount agrees with it, so page and markup are in perfect agreement about a number Merchant Center will not accept.

Those are counts from one dated sample, not rates, and the shape they describe is the useful part: zeros sit in catalogues in quantity and reach the markup rarely. That is the whole reason a harmful one survives. Spot-checking a few products in the admin will almost never land on it, and the store whose free sample is correctly priced at zero looks identical, from the admin, to the store whose $40 product is silently declaring nothing.

StoreCanary checks this on your store

Want to know whether any of your product pages declare a price of zero? We read the structured data on your live catalog and flag them: read-only, no app to install, about 2 minutes.

Scan my store for free

Three causes, and they need different fixes

The price is genuinely missing

Someone created the product as a draft with a placeholder price and never filled it in, or added a variant later and left its price blank. The admin is telling the truth, and the markup is faithfully reporting it. This is the ordinary case, it takes a minute to fix, and it needs no developer.

The detail that catches people out is that it is usually one variant, not the product. A product whose first variant is priced correctly looks entirely normal at a glance, while a later variant sits at zero and drags the item into a disapproval.

The theme is reading the wrong variable

Here the admin price is correct and the markup still says zero. The theme's JSON-LD snippet is reading a field that can be empty instead of the one that always resolves to the displayed variant. The value to check is product.selected_or_first_available_variant.price.

This version is worse than the first, because it is not a data-entry mistake on one product: it is a snippet that applies to every product page on the store. It also survives every correction made in the admin, which is what makes it so frustrating to diagnose: the merchant fixes the price, the price is right, and Google keeps rejecting the item.

The arithmetic turns a real price into a zero

The third cause is the least obvious of the three, because the admin is right and the theme is reading the correct variable. Shopify’s Liquid reference defines a variant’s price as “The price of the variant in the currency’s subunit”, so a $24.00 variant is the integer 2400 and a theme has to divide by 100 before writing it into JSON-LD. How it divides decides whether the output is a price or a zero. Shopify documents that “The divided_by filter produces a result of the same type as the divisor”, and the same page’s own example shows {{ 20 | divided_by: 7 }} returning 2.

So {{ variant.price | divided_by: 100 }} returns an integer, and any price below one whole unit of currency becomes 0. A $0.99 add-on emits a zero and gets rejected outright. A $24.50 product emits 24, which is not this failure at all but the price mismatch failure. The single character between the two outcomes is the decimal point in divided_by: 100.0, which returns a float and keeps the pennies.

The honest limit on this one: of the 35,414 catalogue prices we read on 7 November 2026, only 3 sat between zero and one unit of currency, on three stores. Shopify documents the arithmetic, so the mechanism is certain; its prevalence is not something this sample can measure, because a catalogue with nothing priced under a dollar cannot show it. If your catalogue has no sub-unit prices, this cause cannot reach you, and the first two still can.

What a zero does to each Google surface

The Merchant Center rejection is the half you are told about. The quieter half is in organic search, and the rule there is explicit: “Unlike product snippets, merchant listing experiences require a price greater than zero.” That is why the damage looks partial rather than total. The same markup can keep producing a product snippet while losing the merchant listing experiences, the ones that put a price and availability in front of a shopper. The full requirement lists behind that split, and which Search Console report each belongs to, are the subject of their own article: what matters here is that zero is the one price that fails the merchant listing bar outright.

There is a fourth route to a zero that none of the three causes above covers, and it needs no variant to be mispriced at all. Where a theme emits an AggregateOffer instead of a single Offer, the price field is no longer price: the property Google requires is lowPrice, which it defines as “The lowest price of all offers available”. One deliberately free variant inside an otherwise ordinary product, a sample or a bundled gift, is therefore enough to set lowPrice to zero, at which point the whole product is represented to Google by the cheapest thing in it. The product is correctly priced, every variant is intentional, and the number Google reads is still zero.

Where the price actually sits, measured. Across the 73 Shopify product pages we parsed on 7 November 2026, the offer node was not in the same place twice. Counting each distinct shape once per page: 53 pages carried it as Product.offers, 25 as ProductGroup.hasVariant[].offers and 6 as ProductGroup.offers. Those add up past 73 because 16 of the pages carry more than one shape at once, which is itself worth knowing. On 5 pages, across 2 of the 28 stores, the type was AggregateOffer rather than Offer. The practical consequence is that check the price in your structured data is not a single check, and the field you need to read is not always called price.

How this differs from the other price failures

This is a close relative of the mismatch failure covered in the price mismatch article, where the page and the markup disagree about a real price. Here they may well agree: on a number that cannot be right. It is distinct again from the stale price problem, where the price is valid but out of date, and from a price carrying the wrong currency, where the number is right and the code beside it is not. Four different failures, one shared consequence: what Google shows is not what you sell for. If the block is malformed rather than merely wrong, none of the four applies and Google discards the markup entirely.

How to check your own store

  1. Run a product URL through the Rich Results Test and read the price field of the detected Product. This is the number Google receives, which is the only one that matters here.
  2. Check which node carries that price. On a multi-variant product the offer can sit on the ProductGroup, on each hasVariant entry, or on both, and if its type is AggregateOffer the field to read is lowPrice rather than price.
  3. Open the same product in Shopify Admin → Product → Pricing and check every variant, not just the first.
  4. If a variant has no price, set it. That is the whole fix. Google’s own remedy is to “update the” price “value to 1 or more, unless the product is a mobile device”.
  5. If the admin prices are all correct and the markup still shows 0, the theme snippet is at fault: confirm it reads product.selected_or_first_available_variant.price, and that it divides by 100.0 and not by 100. This one usually needs a developer, and it is worth fixing properly because it affects the entire catalog.
  6. Revalidate with the Rich Results Test, then let the feed refresh or reupload the corrected data in Merchant Center. In Merchant Center, the affected items are listed under the Needs attention tab.

One caveat worth stating plainly: Merchant Center only shows you the products that reached a feed. A product that never made it into one can carry a zero price in its markup indefinitely without ever appearing in a diagnostics report. If you want the real count, the structured data served on your live product pages is the source of truth, not the feed.

Is this happening on your store right now?

Merchant Center will not tell you until it disapproves a listing. The product is live in your store, and Google Shopping is showing a different price, the wrong availability, or nothing at all. The only way to know is to check the feed the way Google reads it.

  • 90+ checks, the way Google reads your product feed. Price and availability mismatches, missing identifiers, redirect chains.
  • Read-only. No app to install, no admin access, nothing changes on your store.
  • The exact fix for each page, in plain English, so you or your developer can act the same day.

Across full-catalog scans of more than 90,000 Shopify product pages, about 1 in 4 stores had at least one critical Google visibility issue.

Scan my store for free

Free scan: issue types, counts and first fixes. Full report on every product page, not a sample: $49 once, no subscription.

Next in this cluster