## Start here: what schema does, and what it does not
Schema markup is structured data — a vocabulary of properties and values in JSON-LD format that you add to your page so search engines can understand the content without having to infer it from text alone.
What it does: makes your pages eligible for rich results. A product page with valid AggregateRating schema can display star ratings directly in the SERP. A page with valid FAQPage schema can expand a dropdown of questions and answers inside the search result. A page with BreadcrumbList schema displays a cleaner URL path. These visual enhancements increase click-through rates — rich results consistently earn higher CTR than plain blue links at equivalent positions.
What it does not do: improve your rankings directly. Google has confirmed in public documentation that structured data is not a ranking factor. The indirect path to better rankings is: schema → rich results → higher CTR → stronger behavioral signal → improved position over time. That loop is real, but it is not a direct, mechanical lift.
The other reason to care about schema in 2026 specifically: AI search engines. ChatGPT Search, Google AI Overviews, and Perplexity all consume structured data as one of their primary inputs when generating product answers. A complete Product schema block tells an AI model exactly what your product is, what it costs, whether it is in stock, who makes it, and what buyers think of it — without requiring the model to parse unstructured prose. See our guide to AI content marketing for Shopify stores for how this fits into a broader AI discoverability strategy.
The four schema types every Shopify store should have:
1. Product schema (with embedded Offers and AggregateRating)
2. FAQPage schema (on product pages and collection pages)
3. Organization schema (once, in theme.liquid)
4. BreadcrumbList schema (on product and collection pages)
Shopify's Dawn theme ships with a version of Product schema. It is incomplete. The following sections tell you exactly what it is missing and how to fix it.
---
## What Shopify's default themes include vs. what they miss
Dawn and other modern Shopify themes (Sense, Refresh, Craft) emit Product schema automatically for product pages. The auto-generated schema covers: name, description, image, and offers (with price, priceCurrency, and availability).
What they consistently miss:
- AggregateRating — not included by default. Star ratings do not appear without it.
- brand — the Brand type property. Usually omitted even when a vendor is set in Shopify admin.
- sku and gtin (GTIN-13/GTIN-12) — required for Google to match products to Merchant Center records and for enhanced Shopping eligibility.
- FAQPage — never emitted by default themes. Requires custom implementation.
- BreadcrumbList — some themes emit this in breadcrumb navigation but not as a separate JSON-LD block.
- Organization — no default theme emits this.
Before touching any code, verify what your specific theme produces. Open a product page URL in Google's Rich Results Test. Look at the detected items. If you see Product with all five key fields (name, image, description, offers, aggregateRating) and no errors, you have a head start — but you still likely need FAQPage and Organization.
Use our Shopify schema generator if you want to skip the manual implementation and generate valid JSON-LD from your product data directly.
---
## Product schema: complete implementation
Product schema is the foundation. Every other schema type on a product page builds on it or nests inside it.
### Required properties (Google will not show rich results without these)
Per Google's Product structured data documentation, the required properties for rich result eligibility are:
- name — the product name
- image — at least one image URL (Google prefers multiple, different aspect ratios)
- description — product description text
- Offer properties (inside an offers object): price, priceCurrency, availability
Without all four, the page is not eligible for Product rich results. Period.
### High-impact optional properties
These are technically optional per schema.org vocabulary but are practically required if you want maximum rich result coverage and AI citation fidelity:
- brand — { "@type": "Brand", "name": "..." }. Required for Merchant Center matching.
- sku — your Shopify variant SKU
- gtin13 or gtin12 — barcode/UPC. Required for Google Shopping eligibility on physical products. Without GTIN, Google cannot match your product to its Shopping graph.
- aggregateRating — see the dedicated section below
- material — especially valuable for fashion, furniture, and any product where material composition is a search filter
### Liquid code block: Product schema for product.liquid
Add this inside a
`
Critical detail on price: use product.selected_or_first_available_variant.price — not product.price. The variant price reflects active sale pricing. Using the product-level price produces stale price errors when a sale is running, and Google will withhold rich results when schema price does not match on-page price.
### Handling variants
If your product has multiple variants (size, color, material), you have two choices:
Option A — Single Offer (recommended for most stores): The schema above uses the selected or first available variant. This is the approach Shopify recommends and avoids creating duplicate/noisy schema from all variants.
Option B — Multiple Offers: Nest an array of Offer objects, one per variant. This is technically more complete but creates complex schema that is harder to keep accurate. Only worth doing if your variants have significantly different prices or availability states that you want Google to understand individually.
---
## AggregateRating schema: review stars in search results
AggregateRating is the schema property that unlocks star ratings in SERPs. It is one of the most visible improvements you can make to a product page's SERP appearance, and one that Dawn does not ship by default.
### What AggregateRating requires
Per the schema.org AggregateRating definition, the required properties for Google to display stars are:
- ratingValue — the average rating (e.g., 4.7)
- reviewCount — the total number of reviews. Google's documented minimum before showing stars is 3 reviews.
- bestRating — the maximum possible rating (5 for a 5-star system). Without this, Google assumes the max is 5, but it is safer to specify it explicitly.
The data must match the visible on-page review count and average exactly. Google cross-checks both. Mismatches result in a manual action for misleading schema.
### Connecting Judge.me, Okendo, or Yotpo review data to schema in Liquid
Most review apps expose product metafields you can reference in Liquid. The exact metafield namespace varies by app:
- Judge.me: product.metafields.judgeme.widget contains pre-rendered HTML, but the rating data is in product.metafields.judgeme.reviews_average and product.metafields.judgeme.reviews_count
- Okendo: product.metafields.okendo.ReviewsWidgetSnippet — check their Liquid documentation for the specific rating keys
- Yotpo: exposes product.metafields.yotpo.score in newer integrations
For Judge.me (the most common Shopify review app), the AggregateRating block inside the Product schema looks like:
`liquid
{% assign review_count = product.metafields.judgeme.reviews_count %}
{% assign review_avg = product.metafields.judgeme.reviews_average %}
{% if review_count > 0 %}
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": {{ review_avg | json }},
"reviewCount": {{ review_count | json }},
"bestRating": "5",
"worstRating": "1"
},
{% endif %}
`
Add this block inside your Product schema JSON-LD, before the closing }. The conditional {% if review_count > 0 %} prevents invalid schema from being emitted on products with no reviews yet.
---
## FAQPage schema: more SERP real estate on product and collection pages
FAQPage schema lets Google display an expandable FAQ section directly inside the search result. For a product page, this can mean showing 2-4 product-specific questions (return policy, sizing, compatibility) inside the SERP before the user even clicks through.
Google's guidelines specify that FAQPage schema is appropriate on pages where a single entity (the page author) provides the questions and answers. Product pages, collection pages, and blog posts all qualify.
### Which pages benefit most
Product pages: FAQ items about returns, shipping, sizing, compatibility, care instructions. These match the pre-purchase questions buyers type into Google. A buyer who sees your return policy answered in the SERP is more likely to click your result than a competitor's.
Collection pages: FAQ items about category-level questions ("what is the difference between linen and cotton shirts?", "what thread count should I look for?"). These match high-volume informational queries that land on collection pages.
Blog posts: FAQ items at the end of the post targeting related informational queries. This post itself uses FAQPage schema for the same reason.
### Liquid code block: FAQPage schema as a section in product.liquid
Create this as a separate JSON-LD block below your Product schema block. The FAQ content can come from metafields (allowing merchants to edit questions per product) or from hardcoded per-template content:
`liquid
{% if product.metafields.custom.faq_questions != blank %}
{% endif %}
`
This pattern uses a metafield of type list.metaobject_reference where each metaobject has question and answer text fields. Set this up in the Shopify admin under Settings → Custom data → Metaobjects.
### Keyword-targeting your FAQ questions
The questions you write for FAQPage schema are indexed by Google and can rank independently for question-intent queries. Write them as the actual queries your buyers type — not internal-facing summaries. "What is your return policy?" is less valuable than "Can I return this after 30 days if it does not fit?" The second version matches a long-tail query. Use our Shopify SEO checker to identify the question-intent queries driving traffic to your competitor product pages.
---
## Organization schema: establishing your brand entity
Organization schema belongs in theme.liquid once, on all pages. It communicates to Google's Knowledge Graph that your store is a coherent business entity — with a name, URL, logo, and verifiable social profiles. This is one of the signals Google uses to build entity understanding, which affects how confidently it cites your brand.
### Fields that matter most
- name — your store's brand name, not the Shopify shop domain
- url — your store's primary URL
- logo — the URL of your brand logo (ImageObject type)
- sameAs — an array of URLs to your official social profiles (Instagram, LinkedIn, Facebook, Pinterest). This is how Google connects your schema entity to your verified social presence.
- contactPoint — customer service contact information. Relevant for Google's seller trust signals.
### Liquid code block: Organization schema for theme.liquid
Place this in theme.liquid inside the
tag. It should appear on every page:
`liquid
`
Adjust the
settings.* keys to match the actual setting names in your theme's config/settings_schema.json. Dawn uses social_instagram_link and social_facebook_link by default.
Note: Organization schema belongs on your homepage and global template — not on every product page. More schema is not always better. Nesting Organization inside Product schema creates unnecessary hierarchy noise.
---
## BreadcrumbList schema: site structure signals
BreadcrumbList schema tells Google the intended hierarchy of a page within your site. On Shopify, where all product URLs are
/products/[handle] regardless of which collection they live in, breadcrumb schema is especially important — it is how Google understands that a product belongs to a specific category.
### Why it matters for Shopify specifically
Shopify's flat URL structure means Google cannot infer hierarchy from URLs alone. A product at
/products/blue-linen-shirt could belong to "Men's Shirts," "Linen Clothing," "Summer Collection," or all three. BreadcrumbList schema tells Google which collection context you want Google to associate with the product, which affects how the URL displays in SERPs and which collection gets link equity credit.
### Liquid code block: BreadcrumbList for product pages
This renders a BreadcrumbList based on the collection the product was accessed through (using the
collection Liquid object, which is available on product pages accessed via a collection context):
`liquid
`
For collection pages, simplify the structure: Home → Collection Name, with the collection URL as the final item.
---
## Validating and monitoring your schema
Implementation without validation is incomplete. Google may accept your schema or reject it — you only know by checking.
### Google Rich Results Test
The starting point for every schema implementation. Enter a URL at search.google.com/test/rich-results and the tool tells you:
- Which schema types it detected on the page
- Whether each type qualifies for rich results
- Specific errors and warnings (missing required properties, incorrect value types)
Run this on at minimum: your most popular product page, one collection page, and your homepage. Fix every error before moving to monitoring.
### Schema Markup Validator
The Rich Results Test only checks schema types that Google has defined rich result formats for. The Schema Markup Validator at validator.schema.org checks all schema vocabulary against the full schema.org specification. Use it to catch property name typos, incorrect value types (a string where an integer is expected), and structural errors the Rich Results Test will not surface.
### Google Search Console Enhancements report
Once your schema is deployed, go to Google Search Console → Search Appearance → and look for Enhancement reports (Product snippets, FAQ, Sitelinks searchbox). These show:
- How many pages Google has detected each schema type on
- How many of those pages are valid (eligible for rich results)
- How many have errors and which errors
- Whether any pages have been demoted due to misleading structured data
Check this report weekly for the first month after a schema deployment. Error counts above a small fraction of your total pages indicate a template-level problem that is affecting many pages simultaneously. Use our Shopify SEO checker to spot-check individual pages between Search Console reviews, or run a full Shopify SEO audit to find schema gaps across your catalog automatically.
---
## Common schema mistakes in Shopify themes
These are the errors that appear most often in the Enhancements report for Shopify stores.
### Schema that says "In Stock" when the page shows "Backorder"
The availability property maps
InStock, OutOfStock, PreOrder, and BackOrder to specific schema.org values. Shopify's native product.available boolean only gives you in-stock vs. not-in-stock. It does not distinguish "Backorder" or "PreOrder" from "OutOfStock."
If you sell products on backorder or pre-order, add logic to check the variant's
inventory_policy:
`liquid
{% if product.selected_or_first_available_variant.available %}
"availability": "https://schema.org/InStock"
{% elsif product.selected_or_first_available_variant.inventory_policy == "continue" %}
"availability": "https://schema.org/BackOrder"
{% else %}
"availability": "https://schema.org/OutOfStock"
{% endif %}
`
Google cross-checks schema availability against the buy button state on the page. If the button says "Backorder — ships in 4 weeks" and your schema says InStock, expect an enhancement error.
### Variant-level offers creating duplicate/noisy schema
If you output one Offer object per variant, you can end up with 30+ Offer objects for a t-shirt that comes in 10 sizes and 3 colors. This is not technically invalid, but it creates schema noise that can confuse Google's product graph matching. Unless your variants have meaningfully different prices or availability states, a single Offer representing the selected or first available variant is cleaner and performs better.
### Missing reciprocal links between Product and AggregateRating
AggregateRating must be nested inside the Product schema block — not as a separate top-level entity on the page. A common mistake is outputting
@type: AggregateRating` as its own JSON-LD script rather than as a property of the Product object. This makes both declarations incomplete and neither receives full rich result consideration.
### Duplicate schema from theme + app
As noted in the best apps post on this blog, many Shopify stores have Product schema emitted by both the theme and a schema app. The duplicates often have different values (the theme uses current variant price; the app uses a cached price). Google handles this inconsistently. Always run the Rich Results Test after installing any schema app to verify you are not duplicating. If you are using the Obsess AI schema generator, it checks for existing schema on the page and flags conflicts before generating.
---
## The practical install workflow
Here is the sequence that works for most Shopify stores starting from scratch:
Step 1 — Audit what you have. Run your product page through the Rich Results Test. Note which types are detected and which errors appear. Run a collection page and your homepage too.
Step 2 — Fix Product schema first. Complete the required and high-impact optional fields. Resolve every error the Rich Results Test flags. Add AggregateRating if you have a review app.
Step 3 — Add FAQPage to product pages. Set up the metaobject definition in Settings → Custom data. Write 3-5 questions for your top 20 products. Deploy the Liquid block. Validate with the Rich Results Test.
Step 4 — Add Organization to theme.liquid. One-time implementation. Validate it appears on your homepage with no errors.
Step 5 — Add BreadcrumbList to product and collection templates. Test several product pages accessed through different collection URLs to confirm the collection context renders correctly.
Step 6 — Submit to Search Console. Go to URL Inspection in Search Console, enter a product page URL, and request indexing. Google will re-crawl and pick up the new schema faster than waiting for the normal crawl schedule.
Step 7 — Monitor Enhancements. After 2-3 weeks, check the Search Appearance reports in Search Console. Your product pages should appear under Product snippets. Watch for error counts.
The full Shopify SEO checklist covers schema as one step in a broader technical SEO review — use it alongside this guide to make sure schema implementation fits into your store's overall optimization priority order.
---
If you want to generate complete Product, FAQ, and Organization schema blocks without writing Liquid manually, the Obsess AI schema generator takes your product URL and outputs paste-ready JSON-LD with all required and recommended fields populated. It also validates the output against Google's rich result requirements before you download.