If you’ve ever pasted a Shopify product page into Google’s Rich Results Test and been surprised by what shows up (or doesn’t), you’ve bumped into one of the more misunderstood parts of Shopify SEO: schema markup. Most merchants assume that because Shopify is a modern, well-built platform, structured data is just “handled” for them. It partly is, and that partial coverage is exactly where things go wrong.
Shopify’s Online Store 2.0 themes do ship with a reasonable amount of JSON-LD structured data out of the box, particularly for products. But schema markup is not one single thing, it’s a family of different vocabularies, each describing a different type of content, and Shopify’s default coverage is uneven across them. Some themes nail Product schema and completely ignore FAQ and review markup. Others output breadcrumb schema that doesn’t match the visual breadcrumb trail. None of this is visible unless you go looking for it.
This guide walks through the four schema types that actually matter for a Shopify store, Product, FAQPage, BreadcrumbList and Review/AggregateRating, what Shopify gives you natively, where the gaps usually are, and how to close them without breaking your theme.
What schema markup actually does on a Shopify store
Schema markup (also called structured data) is code, almost always JSON-LD on modern Shopify themes, that sits in the page’s <head> or body and describes the content on the page in a format search engines can parse directly, rather than inferring it from headings and text.
It doesn’t directly boost rankings. What it does is make your page eligible for enhanced search results: star ratings next to a product listing, an expandable FAQ accordion in the SERP, a breadcrumb trail instead of a raw URL, and richer previews that tend to earn a higher click-through rate than a plain blue link. On a competitive Shopify category, those visual differences in the search results are often the difference between a shopper clicking your listing or a competitor’s.
Google reads JSON-LD markup, cross-checks it against what’s visibly on the page (this matters, mismatches between markup and visible content can lead to schema being ignored or, in cases of deliberate manipulation, a manual action), and decides whether to use it to generate rich results. There’s no guarantee a rich result will show even with perfect markup, but without valid markup it’s off the table entirely.
Product schema: what Online Store 2.0 themes handle by default
This is the one Shopify does reasonably well natively. Most current Online Store 2.0 themes (Dawn and its derivatives, plus most paid themes built to the OS 2.0 standard) output a Product JSON-LD block on product pages via theme.liquid or a dedicated snippet, typically including:
name,descriptionandimageskuandbrand(where set on the product)offerswithprice,priceCurrencyandavailability, pulled from the variant data- Sometimes
aggregateRating, but only if a reviews app is injecting it
Where this commonly breaks down:
- Variant handling. A product with multiple variants (size, colour) should ideally expose an
AggregateOfferor per-variant offer data reflecting the actual price range and stock status. Some themes only output schema for the default variant, which means Google sees a single price even when your range spans two different values. - Missing GTIN/MPN. For stores selling branded products, Google increasingly favours listings that include a GTIN (barcode) or MPN. Shopify has native fields for barcode data, but many themes never surface them in the JSON-LD.
- Duplicate or conflicting schema. This is the one we see most often in technical audits, a theme outputs Product schema in theme.liquid, and then a reviews app, an SEO app, or a page builder app also injects its own Product or Review schema block on the same page. Google will usually just pick one, but it can pick the wrong one, or flag inconsistent data in Search Console’s Enhancements report.
Checking this is simple: view page source on a handful of product pages (not just the homepage), search for application/ld+json, and paste each block into Google’s Rich Results Test. If you see the same @type declared twice, that’s an app conflict worth resolving.
FAQPage schema: the one Shopify never adds for you
This is the schema type merchants most often assume exists and doesn’t. Shopify has no native FAQ content type and no default FAQPage JSON-LD output, on any theme, out of the box. If your product page or a support page has an FAQ accordion built with a theme section or an app, that content is visible to shoppers, but it is not automatically marked up as structured data unless something specifically generates the JSON-LD.
There’s also a genuine trade-off to know before implementing FAQPage schema: in 2023, Google significantly narrowed how often FAQ rich results are shown in search, limiting them mostly to authoritative government and health sites. For most Shopify merchants, that means FAQ schema is far less likely to produce the rich snippet it once did. It’s still worth marking up accurately (it costs little and can still help in some contexts, and it supports voice/AI answer engines that parse structured Q&A content), but it shouldn’t be sold to a merchant as a guaranteed SERP win the way it might have been a few years ago.
To implement it properly on Shopify, you generally need one of:
- A custom Liquid section built specifically for FAQ content, with a metafield or JSON structure feeding both the visible accordion and a matching JSON-LD block, this is the cleanest approach because the visible text and the markup come from the same source, so they can’t drift out of sync.
- An SEO or FAQ app that reads existing page content and outputs FAQPage schema automatically.
The failure mode to avoid: hardcoding FAQ schema in theme.liquid with generic, store-wide questions that don’t match the actual visible FAQ content on each page. That’s a mismatch Google’s guidelines explicitly warn against.
BreadcrumbList schema: shallow by default, easy to get wrong
Shopify’s default collection and product templates typically include a visible breadcrumb trail (Home > Collection > Product), and most Online Store 2.0 themes do output a matching BreadcrumbList JSON-LD block. So far, so good, this is usually one of the better-covered schema types out of the box.
The gaps show up in stores with deeper or messier category structures:
- Single-collection assumption. Shopify products can belong to multiple collections, but there’s only one “canonical” position in the URL structure at a time. If a product sits logically under two or three category paths, the breadcrumb (and its schema) will usually only reflect one of them, which is fine for schema validity but worth being aware of when planning collection architecture.
- Flat structure on themes with sub-collections. Some merchants build a visual sense of hierarchy (a “Runners” sub-page under “Shoes”) using collection descriptions, filters, or manual navigation, without an actual nested collection structure in Shopify. In that case the breadcrumb schema won’t reflect the hierarchy the customer sees in your main navigation, because Shopify’s collection object doesn’t have a native parent-child relationship, that navigation hierarchy lives in your menu structure, not your data structure.
- Custom page types. Landing pages, blog posts and app-generated pages (like some subscription or B2B portal pages) often fall outside the standard product/collection templates and may not get breadcrumb schema at all unless the theme’s custom page templates specifically include it.
Testing this one is straightforward: check that the BreadcrumbList items in your JSON-LD match, in order, what’s visually rendered on the page. A mismatch here is a common cause of Search Console flagging breadcrumb errors.
Review and AggregateRating schema: entirely dependent on your reviews app
This is the schema type most tied to a third-party app decision rather than theme code. Shopify’s core platform has no native product review feature, so there is no default Review or AggregateRating markup unless a reviews app (or a manually built solution) is generating it.
When merchants install a reviews app like the ones listed in Shopify’s integration ecosystem (see Shopify’s reviews and loyalty integration options for how this typically fits into a wider retention stack), most reputable apps will automatically inject AggregateRating and individual Review schema into the product page’s JSON-LD. This is usually the fastest way most stores get star ratings showing in search results.
Things worth checking once a reviews app is installed:
- The
aggregateRatingfigure in the schema should match what’s visibly displayed on the page, Google has been explicit that ratings must be genuine, user-submitted, and visible to the reader, not aggregated from third-party sources or applied site-wide from a single average. - Watch for double markup again here, if your theme already outputs a basic
Reviewblock and the app adds its own, you can end up with duplicate or conflicting review schema, which Search Console will often surface as a warning rather than an error, but is still worth cleaning up. - If you remove a reviews app, its schema injection usually disappears from new page loads, but cached versions of your pages might briefly show stale schema in Google’s index until it’s recrawled.
A practical checklist for auditing your Shopify schema
Run through this on a handful of representative pages, one product with variants, one product with reviews, one collection, and one page with an FAQ section:
- View source on each page and search for
application/ld+json. - Paste each JSON-LD block into Google’s Rich Results Test and confirm it validates without errors.
- Check for duplicate
@typedeclarations on the same page (a sign of theme + app conflict). - Confirm
Productschema price and availability match what’s actually shown for the selected/default variant. - Confirm
BreadcrumbListitems match the visible breadcrumb trail, in the same order. - If you have FAQ content, confirm it has matching
FAQPageschema, and confirm the questions in the markup are the same questions visible on the page. - If you use a reviews app, confirm
AggregateRatingnumbers match what’s displayed and that there’s no duplicate review schema from the theme. - Check Search Console’s Enhancements reports (Products, Breadcrumbs) periodically for validation errors Google has already flagged.
When to bring in a specialist
Fixing a single duplicate schema block is a reasonable DIY task if you’re comfortable in the Shopify theme code editor. Where it gets harder is when the problems compound, a theme, an SEO app and a reviews app are all touching the same JSON-LD, your collection structure doesn’t map cleanly to your visible navigation, and you’re not sure which markup Google is actually reading versus ignoring.
That’s the point where a structured technical review pays for itself, because it’s genuinely difficult to catch these conflicts just by eyeballing a page. It’s exactly the kind of gap our Shopify technical SEO service is built to catch, auditing your JSON-LD across templates, resolving app-versus-theme conflicts, and making sure every schema type you’re eligible for is actually implemented correctly rather than partially.
FAQ
Does Shopify add schema markup automatically?
Partially. Most current Online Store 2.0 themes output basic Product and BreadcrumbList JSON-LD automatically. FAQPage and Review/AggregateRating schema are not native, they only appear if a theme customisation or an app (like a reviews app) specifically generates them.
Will adding FAQ schema guarantee a rich snippet in Google?
No. Google tightened its FAQ rich result eligibility in 2023 and now shows the expandable FAQ snippet far less often, mostly on authoritative sites. It’s still worth implementing accurately for AI/answer-engine visibility, but it shouldn’t be treated as a guaranteed ranking or CTR boost.
Can I have two review apps or an app plus theme both adding review schema?
You can, but you shouldn’t, duplicate Review or AggregateRating blocks on the same page can confuse how Google interprets the data and often show up as warnings in Search Console. Pick one source of truth for review schema and disable markup output in the other.
How do I check what schema my Shopify store currently has?
View the page source of a product, collection and FAQ page, search for application/ld+json, and paste each block into Google’s Rich Results Test. This shows you exactly what’s being output and whether it validates.
Does schema markup directly improve my Shopify SEO rankings?
Not directly, it’s not a ranking factor in the way page speed or backlinks are. What it does is make your listings eligible for enhanced search results (star ratings, breadcrumbs, FAQ snippets where still shown), which can improve click-through rate even at the same ranking position.
Ready to check your store’s schema?
If you’re not sure what’s actually being output on your product and collection pages, don’t guess, a Shopify SEO audit will show you exactly where your schema is working, where it’s missing, and where apps and theme code are quietly conflicting with each other.
