# Schema.org Shopify: What AI Actually Reads
> How to implement Product, Offer, AggregateRating and FAQ schema on Shopify. What themes do by default and mistakes to avoid.
- Canonical HTML: https://verityscore.io/en/blog/shopify-schema-org-guide/
- Markdown alternate: https://verityscore.io/en/blog/shopify-schema-org-guide.md
- Language: en
- Content type: blog
- Published: 2026-02-10
- Updated: 2026-04-12
- Tags: schema-org, shopify, seo, structured-data, tutorial
## Schema.org: the language AI understands

When an LLM or shopping agent visits your Shopify product page, it doesn't see your design. It reads code. And in that code, it looks for a standard format: **Schema.org**.

[Schema.org](https://schema.org/Product) is a structured data vocabulary backed by Google, Microsoft, Yahoo, and Yandex. It describes products, prices, reviews, businesses, in a format that machines understand perfectly.

**Without schema.org, your store is plain text to AI. With schema.org, it's a structured database.**

## What Shopify does by default

Good news: modern Shopify themes (Dawn, Sense, Craft, etc.) already include basic schema.org. Here's what you typically get:

### Product + Offer (present by default)

Most themes inject a `<script type="application/ld+json">` block on product pages with:

```json
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Product Name",
  "description": "Product description...",
  "image": "https://cdn.shopify.com/...",
  "offers": {
    "@type": "Offer",
    "price": "39.90",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://your-store.com/products/product-name"
  }
}
```

It's a good start, but it's often **incomplete**.

### What's frequently missing

| Field | Status | AI Impact |
|-------|--------|-----------|
| `brand` | Often missing | AI can't identify the brand |
| `aggregateRating` | Depends on review app | No proof of customer satisfaction |
| `sku` / `gtin` | Rarely present | AI can't uniquely identify the product |
| `review` | Depends on review app | No individual reviews readable by machines |
| `shippingDetails` | Never present by default | AI can't confirm shipping timelines |
| `returnPolicy` | Never present by default | AI can't confirm return policy |

## How to check your current schema

### Method 1: Source code

1. Go to a product page on your store
2. Right-click → "View page source"
3. Search for `application/ld+json`
4. Copy the JSON content and analyze it

### Method 2: Google Rich Results Test

1. Go to [search.google.com/test/rich-results](https://search.google.com/test/rich-results)
2. Enter your product page URL
3. Check detected types and warnings

### Method 3: Verity Score

Run a Verity Score audit. The Schema.org analysis checks your structured data completeness in detail and tells you exactly what's missing.

## Adding the missing fields on Shopify

### Adding `brand`

In your theme file `product.liquid` or the `main-product.liquid` section, find the JSON-LD block and add:

```json
"brand": {
  "@type": "Brand",
  "name": "{{ product.vendor }}"
}
```

Shopify stores the brand in `product.vendor`. Just inject it into the schema.

### Adding `AggregateRating`

This is the highest-impact field for AI recommendation. Two approaches:

**Option A : Your review app handles it (recommended)**

Judge.me, Stamped.io, and Loox automatically inject an `AggregateRating` block in HTML, provided the option is enabled. Check your app settings:
- Judge.me: Settings → SEO → "Add structured data" (enabled by default)
- Stamped.io: Settings → SEO Snippets → Enable
- Loox: Settings → SEO → Enable JSON-LD

**Option B : Manual injection**

If your review app doesn't support it, add to the theme's JSON-LD block:

```json
"aggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": "4.7",
  "reviewCount": "342",
  "bestRating": "5",
  "worstRating": "1"
}
```

Warning: values **must match reality**. Google (and LLMs) detect inconsistencies.

### Adding `sku` and `gtin`

```json
"sku": "{{ product.selected_or_first_available_variant.sku }}",
"gtin13": "{{ product.selected_or_first_available_variant.barcode }}"
```

The `sku` is almost always filled in Shopify. The `gtin` (EAN/UPC barcode) is less common, but it's a strong authenticity signal for AI.

## Advanced schemas: FAQ and HowTo

### FAQPage schema

If your product page contains a FAQ section, add the corresponding schema:

```json
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What are the shipping times?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Free shipping in 2-3 business days across the US."
      }
    }
  ]
}
```

This schema is doubly useful:
1. It enriches your Google results (FAQ rich snippet)
2. It provides structured answers to LLMs

### BreadcrumbList

Breadcrumbs help AI understand your store's hierarchy:

```json
{
  "@type": "BreadcrumbList",
  "itemListElement": [
    { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://store.com/" },
    { "@type": "ListItem", "position": 2, "name": "Face Care", "item": "https://store.com/collections/face-care" },
    { "@type": "ListItem", "position": 3, "name": "Retinol Serum" }
  ]
}
```

## Common mistakes to avoid

### Mistake 1: Schema present but with empty values

```json
"brand": { "@type": "Brand", "name": "" }
```

An empty field is worse than a missing field. It signals to AI that the data should exist but is broken.

### Mistake 2: Price at 0 or negative

```json
"price": "0.00"
```

A zero price in schema indicates a free product. If your product costs $39.90, make sure the schema reflects the real price.

### Mistake 3: Inconsistent duplication

Two `Product` JSON-LD blocks with different prices on the same page = inconsistency signal for AI. Keep a single complete `Product` block.

### Mistake 4: `availability` with wrong value

Shopify sometimes uses `"InStock"` instead of `"https://schema.org/InStock"`. The correct value is the full schema URL.

## Schema.org checklist for Shopify

For each product page, verify:

- [ ] `Product` with `name` (> 3 words) and `description` (> 50 characters)
- [ ] `brand` with Shopify vendor
- [ ] `Offer` with `price` > 0, ISO `priceCurrency`, full URL `availability`
- [ ] `AggregateRating` if you have reviews (via app or manual)
- [ ] `sku` filled in
- [ ] `image` pointing to Shopify CDN
- [ ] No duplicate JSON-LD Product blocks
- [ ] No empty values in required fields

## The concrete impact on AI recommendation

A store with complete and correct schema consistently gets better GEO Score and AI Buyer Score. Why? Because structured data is the **native language** of AI agents.

When an LLM needs to recommend an anti-aging serum, it compares structured signals from 10 stores. The one with the most complete schema (clear price, verified reviews, identified brand, confirmed availability) gets recommended first.

**Schema.org is no longer a "nice to have" for SEO. It's a prerequisite for visibility in the AI commerce era.**

For a deeper dive, see the full guide: [Schema.org Product: Why and How on Shopify](/en/kb/schema-org).

---

*Check your schema.org in 60 seconds: [run a free Verity Score audit](/en#audit).*
## FAQ

### Does Shopify add schema.org automatically?

Yes, modern themes (Dawn, Sense, Craft) inject basic Product + Offer schema.org. But they often miss AggregateRating, FAQ, GTIN, brand, and variants with hasVariant. These missing fields reduce visibility in ChatGPT and Perplexity.

### What's the difference between native schema and an app?

Native theme schema is static HTML, readable by all crawlers. Review apps (Judge.me, Loox) often inject schema via JavaScript, which can make it invisible to some AI crawlers. Always check the HTML source, not the browser render.

### Which schema.org fields are essential for GEO?

At minimum: Product (name, description, image, brand), Offer (price, priceCurrency, availability, url), AggregateRating (ratingValue, reviewCount). To maximize AI visibility: add gtin, sku, hasVariant, shippingDetails, hasMerchantReturnPolicy.

### How do I test if my schema.org is correct?

Use the Google Rich Results Test (search.google.com/test/rich-results) for Google validation. For full AI visibility, run a free GEO audit on Verity Score which checks the 40+ fields used by ChatGPT, Perplexity, and Google AI Mode.

## Sources

- [Schema.org Official Documentation](https://schema.org/Product) (official)
- [Google Search Central: Structured Data Documentation](https://developers.google.com/search/docs/appearance/structured-data/product) (official)
- [Google Rich Results Test](https://search.google.com/test/rich-results) (official)