Product schema for Shopify, explained — JSON-LD without a developer

If you've ever Googled a product and seen the star rating, price, and "In stock" tag appear directly in the search result — before you even clicked — that's a rich result. Rich results are generated from structured data on the page, and for product pages that structured data follows a specific format called schema.org/Product in a packaging called JSON-LD.

Most Shopify stores either skip this entirely or rely on whatever their theme bakes in (which is often incomplete). This is a quick, end-to-end explanation of what Product schema is, why it matters specifically for Shopify, and how to add it without touching theme code.

What is Product schema?

Schema.org is a vocabulary that Google, Bing, and other search engines agreed on for describing things on the web — products, recipes, events, articles, businesses. Product schema is the subset for describing a product page: what it is, who makes it, how much it costs, whether it's in stock, and what reviewers think.

JSON-LD is the format Google prefers for delivering this data. It's a JavaScript object — looks like a code block in your page's HTML — that describes the product in structured fields. A minimal Product JSON-LD block looks like this:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Linen Weighted Throw",
  "image": "https://example.com/throw.jpg",
  "description": "A weighted linen throw built for everyday use.",
  "brand": { "@type": "Brand", "name": "ExampleCo" },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/products/linen-throw",
    "priceCurrency": "USD",
    "price": "129.00",
    "availability": "https://schema.org/InStock"
  }
}
</script>

Google reads this when it crawls the product page. If it's valid, Google may render the product as a rich result — price, availability, and (if you supply review data) star ratings — directly in search.

Why it matters for Shopify stores specifically

Three reasons schema markup has outsized value on Shopify product pages:

1. You're competing in Google Shopping. Rich product results show price and availability inline. A shopper comparing your $89 candle against three others can see "In stock — $89" directly in the SERP. Stores without schema show only a blue title link. The difference in click-through rate is real.
2. You're often selling commodity products. Many Shopify stores resell catalog items. Schema is one of the few SEO signals you fully control even when the SKU is identical to a competitor's.
3. Image schema helps Google Lens. A growing share of product discovery happens through Google Lens (camera-based image search). Schema feeds the structured side of those results.

The fields that matter most

You don't need to fill every possible schema.org/Product field. Focus on these:

• name — the product title
• image — image URL (or array of URLs)
• description — the product description
• brand — usually your store's brand
• offers.price — the price as a string
• offers.priceCurrency — usually "USD" but match your store's currency
• offers.availability — schema.org/InStock or schema.org/OutOfStock
• offers.url — canonical product URL

Optional but useful: sku, gtin, mpn, aggregateRating (if you have real reviews), review (individual review markup).

How to add it to Shopify without touching theme code

Shopify themes vary in how much schema they generate. Most include some, but coverage is inconsistent across themes and often incomplete (missing brand, missing availability, missing image arrays). The robust approach: store schema as a JSON object in a product metafield, and add a tiny theme snippet that renders it inside a <script type="application/ld+json"> tag on every product page.

Step 1 — Define a metafield

In Shopify admin: Settings → Custom data → Products → Add definition. Create a metafield with namespace custom, key product_jsonld, type "JSON". This gives every product a slot to store its schema.

Step 2 — Generate the JSON for each product

The JSON-LD block above, populated per product. You can write a one-off script, paste manually, or use an app like ShelfCopy that generates valid Product JSON-LD on every product automatically and writes it to the metafield via the Admin API.

Step 3 — Render it on the product page

Add this Liquid snippet to your theme's product.liquid (or the product template that fits your theme structure), inside the <head>:

{% if product.metafields.custom.product_jsonld %}
<script type="application/ld+json">
  {{ product.metafields.custom.product_jsonld | json }}
</script>
{% endif %}

One snippet, every product page, no per-product theme work. The JSON renders as a script tag in the head and Google indexes it on the next crawl.

Common mistakes

• Multiple schemas conflicting. Some themes already inject Product schema. Adding a second can cause Google to ignore both. Check Google's Rich Results Test on a live product page before launching.
• priceCurrency hardcoded as USD when the store sells in EUR. Use the actual currency code per shop. ShelfCopy 1.1.0 ships a fix for this — pull the shop's currency into the prompt.
• Availability set to InStock when inventory is zero. Tie availability to live inventory if you can; stale schema gets demoted by Google over time.
• Missing required fields. Google requires name, image, and an offers block with price and priceCurrency to surface rich results. Skip any of those and you get nothing.

How to verify it's working

Three checks, in order:

1. View source on a product page. Search for application/ld+json and confirm a Product block is present.
2. Run Google's Rich Results Test. Paste the product URL into search.google.com/test/rich-results. It tells you if your schema is valid and what rich result types are eligible.
3. Wait for the next crawl, then check GSC. Google Search Console's "Enhancements" report lists which schema types it has detected. Product enhancements show up there within a few weeks of deployment.

How ShelfCopy handles this

ShelfCopy generates valid schema.org/Product JSON-LD on every product as one of its four core outputs. It writes the JSON to a Shopify metafield via the Admin API automatically — no developer work — and you only need the four-line Liquid snippet above (or its theme-specific equivalent) to render it. The diff preview shows the generated schema alongside the description and meta tags, so you see every field before anything publishes.