BlogFindings
Product schema: 42 of 50 product pages declared it, and 22 of those carried no GTIN
Lantad asked the 164 commerce hostnames in this repository's two committed corpus seed files for robots.txt on 22 September 2026, then walked each site to a page carrying an add to cart control and read that page with no JavaScript executed. 50 product pages answered. 42 declared a Product node in JSON-LD, 41 of those 42 carried a price, a currency and an availability value, and 22 carried no GTIN, MPN or other manufacturer identifier.
That makes it worth counting rather than asserting. This run asked the 164 commerce hostnames in this repository's two committed corpus seed files for robots.txt as LantadBot, requested each home page, and then walked to a page that offered an add to cart control, reading raw bytes with no JavaScript executed. The add to cart control matters: earlier attempts at this measurement picked the first product shaped URL a home page offered and collected category listings, gift cards and, on one site, a glossary. A page only counts here if the HTML it served carried a control for buying something. 50 pages cleared that bar, and the result is not the one the corpus usually produces. The markup, where it exists, is mostly correct. What is missing is narrower and more specific than "sites do not use schema".
In short
- Product schema was present on 42 of the 50 corpus product pages Lantad read on 22 September 2026, and 41 of those 42 declared a price, a priceCurrency and an availability value, so the commercial fields are the ones these sites get right.
- 22 of the 42 Product nodes carried no GTIN, MPN, productID or ISBN, and 5 of them carried no sku either, so the field most often missing is the one that would match the item against the same product sold somewhere else.
- 8 of the 50 product pages published no Product node at all in the HTML served to LantadBot, among them amazon.com, target.com and newegg.com, and 7 of those 8 showed a price in visible text that no parser could attribute to anything.
- SCHEMA_REQUIREMENTS in core/src/schema.ts asks a Product for a name and nothing else, and on this sample that bar and Google's much longer merchant listing requirement rejected the same single page, dollargeneral.com.
- Only 50 product pages could be read at all from 164 commerce hostnames asked on 22 September 2026: 42 home pages answered 403 to LantadBot, 2 disallowed it in robots.txt, and 35 offered no product link a crawler could follow.
| Stage | Sites | What happened |
|---|---|---|
| Commerce hostnames asked | 164 | The committed corpus, an editorial sampling frame rather than a random draw |
| robots.txt disallows LantadBot at the root | 2 | gmarket.co.kr and instacart.com, left alone |
| Home page did not answer 200 with HTML | 59 | 42 answered 403, 8 answered 503, 5 returned no status at all |
| No product shaped link a crawler could follow | 35 | Home page, collection pages and sitemap all checked |
| Product shaped URL carried no add to cart control | 18 | Not counted as a product page |
| Product pages read | 50 | The denominator for every figure below |
| Declared a Product node in JSON-LD | 42 | 30 of the 34 Shopify stores, 12 of the 16 larger retailers |
What is product schema, and what does it have to contain?
Three documents have an opinion and none of them agrees with the others.
schema.org's Product type marks nothing as required. It lists properties with their expected types and leaves every one of them optional, which is true of the vocabulary generally: schema.org describes what a property means, not what a publisher owes. Read on 22 September 2026, the current version is release 30.1 dated 2026-09-16, and the release notes for it say the release exists in part to "Add vocabulary to express common eCommerce product data". The vocabulary is still growing, six days before this measurement.
Google supplies the requirements the vocabulary does not, and supplies two different sets of them for two different search features. The product snippet guidance, carrying Last updated 2026-09-08 UTC, requires name plus at least one of review, aggregateRating or offers, and requires price on an Offer. The merchant listing guidance, carrying the same date, requires name, image and offers, with both price and priceCurrency on the Offer. So the same Product node can satisfy one Google feature and fail the other, and a page author reading only one of the two pages would not know.
Lantad has a third bar, and it is the lowest of the three. SCHEMA_REQUIREMENTS in core/src/schema.ts asks a Product for name and stops there. That is a decision rather than a finding: somebody chose it, and the same file asks an Organization for name and url and a BreadcrumbList for a non-empty itemListElement. It is worth stating plainly because it sets what the scanner can and cannot tell you about a product page, and the measurement below puts a number on the difference. The vocabulary underneath all three is the same one this blog has counted before, when 141 of 382 home pages carried no structured data at all and when only 16 schema.org types reached 10 million domains.
| Requirement set | What it requires of a Product | Pages of 42 that met it |
|---|---|---|
| schema.org Product | Nothing. Every property is optional. | 42 |
| Google product snippet | name, plus one of review, aggregateRating or offers | 41 |
| Google merchant listing | name, image, offers, with price and priceCurrency | 41 |
| Lantad SCHEMA_REQUIREMENTS.Product | name | 41 |
How many product pages declared product schema?
42 of the 50 pages carried a Product node in JSON-LD. Of the 8 that did not, 5 served no JSON-LD whatsoever and 3 served some without a Product in it: newegg.com published a BreadcrumbList, an ImageObject and an FAQPage on a processor listing and no Product, canadiantire.ca published a WPHeader and a WPFooter and nothing about the item, and breda.com published a breadcrumb trail and left the watch it was selling undescribed.
The names in that group of 8 are the point. amazon.com, target.com, newegg.com and canadiantire.ca are four of the largest retailers in the sample, alongside four Shopify stores, breda.com, hiutdenim.co.uk, skullbliss.com and sleepyjones.com. Requested independently on 22 September 2026, the Apple Watch listing at amazon.com and the Apple Watch listing at target.com each returned zero script elements of type application/ld+json to LantadBot.
State the limit of that finding precisely, because it is the one a reader will otherwise overstate. This measurement reads the bytes the server sends and runs no JavaScript, so it says those pages published no Product node in their served HTML. It does not say the markup is absent from the rendered page. A site that injects JSON-LD client side is invisible here and visible to a renderer that executes scripts, which is a distinction this blog has measured directly: JavaScript supplied 7.6 percent of the prose across 271 pages. What it does mean is that any consumer reading raw HTML, which is how most AI crawler fetchers work, sees nothing.
7 of those 8 pages showed a price in visible text. Only target.com did not, and its page carried 189 words. So on 7 pages a human reader could see what the thing cost and a parser had no field to read it from, which is the same gap 17 of 93 SaaS pricing pages showed from the other direction. The split by platform runs the way the funnel suggests: 30 of the 34 Shopify stores read carried a Product node, against 12 of the 16 larger retailers, and Shopify generates the markup from the theme rather than leaving it to the merchant, which is the same mechanism behind 1,112 products served as open JSON from 38 stores.
Price, currency and availability were almost always present
This is where the measurement stopped matching the expectation. Among the 42 pages carrying a Product node, 41 declared a price, 41 declared a priceCurrency and 41 declared an availability value. Every one of the 42 carried an image. 41 carried a name. The commercial core of the markup, the part that costs a merchant something to get wrong, is the part these pages get right.
The values themselves survive checking. Every price parsed as a number, none was zero, and every priceCurrency was a three letter code: 37 USD, and one each of EUR, GBP, INR and TRY. Availability was InStock on 39 pages and OutOfStock on one. That last figure is worth reading carefully rather than celebrating, because a sample of pages reached by following a shop's own promoted links is a sample of things the shop wants to sell, so the near absence of OutOfStock is a property of how these pages were found and not a fact about retail inventory.
One availability value out of the 41 was malformed, and malformed in a way no human would spot and no parser can rescue. goodgirlsnacks.com declared "http://schema.org/ InStock", with a literal space between the slash and the word. schema.org's ItemAvailability enumeration has twelve members and that string is not one of them, so a consumer resolving the value against the vocabulary gets nothing back, while a consumer doing a substring match on "InStock" gets the right answer by accident. Which of those a given engine does is not documented by any of them.
The wider point is about where a scan's attention is worth spending. If 41 of 42 pages carry price, currency and availability, then checking those three fields separates almost nothing, and a report that spends its space confirming them is reporting the weather. The discrimination happened earlier, at whether a Product node existed at all, and it happens again in the fields covered below. That is the kind of thing a methodology has to keep re-testing, because a check that used to be informative stops being informative as adoption moves under it.
The field most often missing was the identifier, not the price
22 of the 42 Product nodes carried no GTIN, MPN, productID or ISBN. 5 of the 42 carried no sku either, so on those five pages the markup describes a purchasable thing and offers no key of any kind: aboutyou.de, glossier.com, burdenofproofna.com, eatmila.com and masienda.com. Across the 42, the median node filled 9 of the 10 properties counted here and the weakest filled 4.
An identifier is a different kind of field from a price and the difference is why this gap matters more than its size suggests. A price describes this listing. A GTIN describes the object, and it is the same string wherever that object is sold, which makes it the only field in the node that can join one merchant's page to another merchant's page or to a manufacturer's own record. Without one, a consumer comparing offers has to match on a name, and names are marketing copy. Google's merchant listing guidance lists gtin and mpn as recommended rather than required, so 22 pages omitting them are not doing anything the documentation forbids. They are declining the one field that makes the node comparable.
Reviews are thinner still. 13 of the 42 carried an aggregateRating and 3 carried a review, and 29 carried neither. That is the population Google's product snippet guidance is aimed at, since its requirement is satisfied by offers alone, and on this sample offers is what satisfied it every time. The rating that would let a snippet show stars is simply not in the markup on seven pages out of ten.
None of this is a claim about what any engine does with the fields, and the difference matters enough to state rather than imply. Lantad measured what these pages publish. It did not measure whether an answer engine reads a GTIN, weights it, or ignores it, because that is not observable from the page. What can be said is that an identifier the page does not publish cannot be read by anything, which is the floor under every question about AI visibility and entity confidence that follows from it.
| Field | How Google classifies it | Present | Absent |
|---|---|---|---|
| sku | Recommended for merchant listings | 33 | 9 |
| brand | Recommended for merchant listings | 31 | 11 |
| gtin, mpn, productID or isbn | Recommended for merchant listings | 20 | 22 |
| aggregateRating | Recommended for product snippets | 13 | 29 |
| review | Recommended for product snippets | 3 | 39 |
| No identifier of any kind | Not a Google category | 5 | 37 |
What the two malformed pages show about the checks that run on them
Two of the 42 pages carried something a check can fail them on without any judgement being involved, and they are worth setting out individually because they fail differently.
dollargeneral.com published a Product node, on a listing for a Riley Green CD, whose complete set of keys is @context, @type, brand, description, image and sku. There is no name and no offers. So the page tells a parser the brand and the SKU of a thing it will not name and does not price, while the visible page prices it perfectly well. This is the single page in the sample that fails Lantad's requirement, and it is also the single page that fails Google's merchant listing requirement, and the two bars reject it for overlapping reasons: Lantad because name is absent, Google because name, offers, price and priceCurrency are all absent.
goodgirlsnacks.com is the opposite failure. Its node is otherwise complete, and one character inside one string makes one field unresolvable. Nothing in a rendering pipeline surfaces that, because the string never reaches a reader.
Now the uncomfortable part, which is about the scanner rather than the sample. Lantad's Product requirement is name and nothing more, and Google's merchant listing requirement is four fields deeper. On these 42 pages the two bars produced the same answer: 41 pass, 1 fails, and it is the same page. The extra strictness bought nothing here. That is not an argument for the lower bar, and the honest reading runs the other way: both bars are close to useless on this population, because a site that publishes a Product node at all almost always publishes the fields either bar asks for. Any real signal in this measurement lives in the presence or absence of the node, in the identifier gap above, and in the 114 hostnames of 164 that never produced a readable product page at all. A check that passes 41 of 42 inputs is not measuring those inputs, and saying so is cheaper than discovering it later. This blog has published the same shape of result before, when 117 of 612 home pages with JSON-LD carried a defect and when 201 of 936 interior pages declared a breadcrumb trail.
-
dollargeneral.comNo name, no offers Keys present: @context, @type, brand, description, image, sku. Fails Lantad's requirement and Google's alike. -
goodgirlsnacks.comUnresolvable availability Declares http://schema.org/ InStock, with a space, which is not one of the twelve ItemAvailability members. -
The other 40Pass both bars Name, image, offers, price, priceCurrency and availability all present and well formed. -
Lantad against GoogleSame verdict on all 42 A four field difference in requirements separated no page in this sample.
Does an AI answer engine read product schema?
The documentation answers this less clearly than the volume of advice about it suggests, and the honest summary is that the strongest published commitment belongs to search rather than to any answer engine.
Google's two guides are explicit, and they are about search appearance: what a result can show, which features a page becomes eligible for. Neither describes what a generative answer does with the same node. OpenAI's route to product data is not the page at all. Its commerce feed specification has merchants deliver product records through a file upload, in JSONL, CSV or TSV, with fields the specification names itself, and it describes no crawl and no reading of schema.org markup as a source. This blog has already read that specification in detail and counted the twelve fields it marks required. A merchant who marks up a page perfectly has not submitted a feed, and a merchant who submits a feed has not thereby marked up a page.
So a page's Product node sits in an odd position. It is the only machine-readable statement of price and availability that a general purpose fetcher can obtain without a commercial relationship, and no AI crawler vendor documents what its fetcher does with it. Lantad has not measured that either, and will not infer it: what an engine ingests is not visible from the page, and the same gap has shown up whenever this blog has looked, which is why the way a crawler reaches a page keeps mattering more than the polish of what it finds there.
The practical order follows from the funnel rather than from the markup. Of 164 commerce hostnames, 42 answered 403 to LantadBot at the home page and 2 disallowed it outright, which is the same pattern as 79 of 115 sites blocking an AI crawler. Markup on a page a fetcher cannot open is not read by anybody. The ordering is: let the fetcher in, which the bot page documents for this scanner and a robots.txt check will show you for others; serve the node in HTML rather than after hydration; then fill the identifier. Sites running a hosted platform get the second of those free, which is what the Shopify guide covers, and none of the three is worth doing before the one above it.
Flow: Product page HTML (42 of 50) to Product node in JSON-LD; Product node in JSON-LD to Fetcher reads raw bytes; Fetcher reads raw bytes (documented) to Google search features; Fetcher reads raw bytes (not documented) to Answer engines, undocumented; Merchant feed file to File upload, no crawl; File upload, no crawl (documented) to OpenAI commerce.
Lantad
Published .
Product schema is the markup that tells a parser this page is selling one thing, that the thing costs a number in a currency, and that it is or is not in stock. It is the most commercially loaded structured data a site publishes, because unlike a heading or a description it carries facts a machine can act on rather than paraphrase. A price is either there or it is not, and if it is there it is either a number or it is not.
Common questions
What is product schema?
Product schema is schema.org's Product type, usually written as JSON-LD in a script element, stating that a page describes one purchasable item and carrying its name, image, price, currency and availability. schema.org itself marks none of those properties as required; Google's merchant listing guidance, read on 22 September 2026, requires name, image and offers, with price and priceCurrency on the offer.
How many product pages actually use product schema?
On the 50 corpus product pages Lantad read on 22 September 2026, 42 carried a Product node in the HTML the server sent, and 8 did not. That figure counts markup present without executing JavaScript, so a site injecting its node client side would count as absent here. The sample is 164 commerce hostnames from this repository's committed corpus, not a random draw from the web.
Does a product page need a GTIN?
Google's merchant listing guidance lists gtin and mpn as recommended rather than required, so a page without one is not breaking a rule. 22 of the 42 Product nodes Lantad read on 22 September 2026 carried no GTIN, MPN, productID or ISBN. The practical cost is that an identifier is the only field in the node that matches the same object across different sellers, which a product name cannot do.
Do AI answer engines read product schema?
No AI crawler vendor documents what its fetcher does with a Product node, and Lantad has not measured it, because what an engine ingests is not observable from the page. Google documents the markup for search appearance. OpenAI's commerce feed specification takes product records as an uploaded file rather than from a crawl, so marking up a page is not how product data reaches it.
See what AI can read on your site
Run a free scan and get a graded report of exactly what AI crawlers can and cannot read, with ranked fixes.
Structured data for AI (schema markup)
Structured data is schema.org markup, usually written as JSON-LD, that labels a page's facts in a machine-readable format so AI systems can extract and attribute them without having to interpret the surrounding prose.
AI crawler
An AI crawler is an automated bot, such as GPTBot, ClaudeBot, or PerplexityBot, that fetches web pages so an AI system can read, train on, or cite what those pages contain.
Entity confidence
Entity confidence is a free diagnostic on every graded Lantad report that scores, out of 100, how completely the JSON-LD in your crawler-visible HTML declares one identity and how far that identity is anchored by identifiers which resolve outside the page.
Generative Engine Optimization (GEO)
Generative Engine Optimization (GEO) is the practice of structuring and publishing content so that generative AI engines can fetch it, read it in full, and cite it when they answer a question.
Fix your Shopify (Liquid) site
Shopify themes are server-rendered Liquid, so most of your store is already readable to AI crawlers, and the real gap is the content third-party apps and widgets inject with JavaScript after the page loads.
How to get cited by ChatGPT
ChatGPT can only cite a page its crawlers are allowed to fetch and can read without JavaScript, so being permitted and readable comes first, and any citation follows from there.
