Schema markup for Shopify is structured data — written in JSON-LD and based on the Schema.org vocabulary — that tells search engines what your products, pages, and business are, not just what text they contain. Shopify has built-in structured data, and that is both a convenience and a trap. Most themes output a Product schema block automatically, but the quality of that output varies enormously by theme, and the gaps it leaves — missing aggregateRating, incomplete offers, no breadcrumb markup — are exactly the ones that determine whether you get rich results in search. Understanding what Shopify does by default and where you need to intervene is the foundation of any honest schema markup strategy on this platform.

What Shopify themes output by default

Most paid Shopify themes include a Product JSON-LD block in the product template. It typically covers name, image, description, sku, and a basic Offer with price and availability. Dawn, Shopify’s reference theme, does this reasonably well. The problems appear when you look at what is missing.

Review data is rarely wired to the schema output even when you have a reviews app installed — the app stores rating data in its own database but has no automatic connection to the JSON-LD the theme outputs. The result is that Google never sees your aggregateRating, and you lose star rating rich results even though the reviews exist on the page. The brand property is often omitted. Variant-level pricing is handled inconsistently across themes, and some output the base price regardless of which variant is selected. If your store has collections, there is almost never any BreadcrumbList markup present unless you added it yourself.

Beyond product pages, most Shopify themes output nothing structured for the homepage, collection pages, or blog posts. There is no Organization or Store block, no FAQPage markup, and no Article data on blog posts. The schema gap on Shopify is primarily a product-page issue, but it extends across the whole store if you look at the full picture.

How to add schema markup to Shopify

You have three practical options, each with different trade-offs around control, maintenance burden, and technical complexity.

Option 1: Edit theme files directly

The most precise approach is editing the theme’s Liquid templates directly — specifically the product.json or product.liquid template and the corresponding product-schema.liquid snippet if one exists in your theme. This gives you full control over the output with no added page weight or third-party dependency. The downside is that it requires comfort with Liquid templating syntax and breaks — or requires re-implementation — if you switch themes. For stores with a stable, long-term theme, this is the cleanest option.

Option 2: Use a schema markup app

Apps like Schema Plus for SEO and JSON-LD for SEO install via the Shopify App Store and handle schema across your store without requiring theme editing skills. They are easier to maintain across theme changes and typically cover FAQPage and BreadcrumbList in addition to product data. The risk is that they may output schema that conflicts with what the theme already outputs — producing duplicate Product blocks on the same page. Always audit your pages with the Rich Results Test after installing any schema app to check for conflicts.

Option 3: Shopify Script Editor or custom pixel

Shopify’s Script Editor (or a custom pixel via the Customer Events section in newer Shopify versions) can inject JSON-LD on specific pages. This is more suited to advanced use cases like schema on checkout pages or specific landing pages, and it is harder to maintain at scale. It is not the right first choice for product or collection schema.

Product schema example for Shopify (Liquid)

Here is a minimal corrected Product block written as a Liquid snippet. All JSON-LD keys and string values use single quotes. Liquid filter syntax also uses single quotes for escape and variable references.

<script type='application/ld+json'>
{
  '@context': 'https://schema.org',
  '@type': 'Product',
  'name': '{{ product.title | escape }}',
  'description': '{{ product.description | strip_html | truncate: 200 | escape }}',
  'sku': '{{ product.selected_or_first_available_variant.sku | escape }}',
  'image': '{{ product.featured_image | img_url: '1200x' }}',
  'brand': {
    '@type': 'Brand',
    'name': '{{ product.vendor | escape }}'
  },
  'offers': {
    '@type': 'Offer',
    'url': '{{ shop.url }}{{ product.url }}',
    'price': '{{ product.selected_or_first_available_variant.price | money_without_currency }}',
    'priceCurrency': '{{ cart.currency.iso_code }}',
    'availability': {% if product.selected_or_first_available_variant.available %}'https://schema.org/InStock'{% else %}'https://schema.org/OutOfStock'{% endif %},
    'seller': {
      '@type': 'Organization',
      'name': '{{ shop.name | escape }}'
    }
  }
}
</script>

The critical difference from many theme defaults is the conditional availability — pulling it from actual variant inventory data rather than hardcoding InStock. This matters because Google can and does cross-reference schema availability against what it crawls on the page.

Schema types worth adding on Shopify

Beyond the core Product block, these are the Schema.org types that Shopify stores most commonly miss and that deliver measurable results:

  • BreadcrumbList — one of the simplest wins available on Shopify. Add breadcrumb markup to collection and product page templates, and you get breadcrumb paths in SERPs that replace the raw URL. It also reinforces your site hierarchy as an entity signal for Google’s understanding of your catalog structure.
  • FAQPage — if your product pages include an FAQ section (common in higher-ticket categories), adding FAQPage markup can trigger expanded FAQ rich results that take up significantly more SERP real estate than a standard listing.
  • Organization — a site-wide Organization block in the theme layout connects your store to a named entity with a url, logo, and sameAs links to social profiles. This feeds into Google’s knowledge graph and is increasingly relevant for AI Overviews.
  • Article / BlogPosting — if you maintain a Shopify blog, your posts almost certainly have no structured data. Adding BlogPosting markup with author, dates, and image improves Discover and Google News eligibility and ties the content to your store entity.

How to test Shopify schema markup

Testing is not a one-time step — Shopify theme updates, app installs, and platform changes can silently alter what your store outputs. Build testing into your maintenance routine:

  • Google Rich Results Test — paste a product page URL and see which types Google detects, which are eligible for rich results, and which fields are missing or invalid. This is your primary validation tool.
  • Schema Markup Validator (validator.schema.org) — runs against the full Schema.org specification rather than just Google’s rich result requirements. Catches type mismatches and missing recommended properties that the Rich Results Test does not flag.
  • Google Search Console — the Enhancements section in Search Console reports on structured data errors across your crawled pages over time. It will surface issues you did not catch in point-in-time testing.

After installing any new theme, schema app, or major Shopify update, run the Rich Results Test on at least three representative product pages before assuming everything carried over correctly.

Schema markup and AI search for Shopify stores

AI Overviews in Google Search are increasingly using structured data as a primary signal for entity recognition — understanding not just what a page says but what a product, brand, or business is. For Shopify stores, this means that a complete Product block with accurate brand, offers, and aggregateRating data is no longer just about product rich results in the traditional sense. It is about whether your products are understood as distinct entities that AI systems can confidently surface in shopping-adjacent queries.

Stores that have wired their reviews data into aggregateRating, connected their brand to a sameAs entity network, and structured their catalog with consistent sku and gtin data are building a structured data moat that is harder to replicate than content alone. Microdata and RDFa remain technically valid Schema.org formats, but JSON-LD is what Google recommends and what all modern Shopify schema implementations should use.

Common mistakes on Shopify

  • Duplicate Product blocks from theme plus app. Installing a schema app without disabling the theme’s built-in output is the single most common error I see in Shopify audits. Two competing Product blocks on the same page can cause Google to ignore both or report a conflict in Search Console.
  • Hardcoded availability as InStock. Many theme snippets output availability: InStock as a static string. When a product goes out of stock, the schema contradicts the page content — a pattern Google notices and that can result in manual actions for misleading structured data.
  • Reviews app not wired to schema output. Review apps store rating data in their own system. Without a deliberate connection between that data and your Product JSON-LD, Google never sees the aggregateRating and you do not get star rating rich results.
  • Assuming Dawn is sufficient for all product types. Dawn handles standard single-variant physical products reasonably well. It is not built for product bundles, digital downloads, or subscription SKUs, and attempting to use its default output for those cases produces inaccurate or invalid structured data.
  • Not adding BreadcrumbList. Collection and product pages without breadcrumb markup show raw URLs in SERPs rather than structured paths. This is one of the simpler wins available on Shopify and is consistently overlooked.

If you want a clear picture of what your Shopify store is actually outputting and where the gaps are, the right move is to start with a schema audit. From there I can help you prioritize fixes or work through the implementation as part of schema markup consulting. For a broader look at the testing side, see the guide on how to test schema markup.