Blog › Technical SEO

How to audit Shopify structured data: the exact 3-tool workflow to verify your JSON-LD is working for AI shopping agents

CatalogScan — June 5, 2026 — Technical SEO Structured Data AI Shopping

Most Shopify merchants who've added JSON-LD to their theme believe their structured data is working. Most of the time, it isn't — not in the form AI shopping agents can actually parse and trust. Here's the exact audit workflow that surfaces what's broken.

The gap between "I added JSON-LD" and "AI agents are reading it"

When Shopify's default theme outputs structured data, it includes a <script type="application/ld+json"> block on product pages with a basic Product schema: name, description, image, offers. Many merchants stop there and assume the work is done.

But AI shopping agents — ChatGPT Shopping, Perplexity Commerce, Google AI Mode, Shopify's own Global Catalog feed — don't give partial credit. If a required property is missing, incorrectly typed, or rendered in a form the parser doesn't recognize, the entire product may be excluded from the agent's consideration set for that query signal. The failure is invisible: your page still renders, your products still sell through human-initiated search, but you're absent from AI-mediated recommendations.

The audit gap has three common sources:

• Rendering failures: Liquid template variables that produce empty strings, null values, or raw Liquid syntax in the JSON-LD output when the product is missing a metafield or variant attribute
• Type mismatches: Price as a formatted string ("$29.99") rather than a bare number (29.99), or availability as a custom string ("available") rather than a schema.org URI ("https://schema.org/InStock")
• Scope problems: Structured data present on the homepage or collection pages but absent or malformed on the individual product page URLs that AI agents actually crawl

None of these trigger a 500 error. None produce a broken page. They only show up when you test the JSON-LD output directly — which is what the three-tool audit is for.

Tool 1: Rich Results Test — per-product verification

Reading a Rich Results Test output for a Shopify product

When you paste a product URL and click "Test URL," the tool shows you a parsed tree of every JSON-LD block it found. For Shopify's default theme output, you'll typically see a Product item with nested Offer items. The critical things to check in each Offer:

Tool 2: Schema.org Validator — JSON-LD syntax and property validation

The paste-in workflow for Shopify

The Schema.org Validator's URL mode doesn't execute JavaScript, so it sees the raw server-rendered HTML. For Shopify stores using JavaScript-injected structured data (rare but possible with some headless setups), use the paste-in mode instead:

1. Open a product page in your browser, right-click → "View Page Source" (not Inspect — you want the raw HTML, not the post-JavaScript DOM)
2. Search for application/ld+json — copy the entire content of the script tag (the JSON object inside)
3. Paste into the Schema.org Validator's "Validate by Direct Input" tab
4. Note every red error (blocking) and yellow warning (advisory)

For Shopify Online Store 2.0 themes, the JSON-LD is server-rendered by Liquid, so the URL mode works correctly. The paste-in approach is only necessary if your theme uses a custom storefront or injects structured data via a JavaScript app.

Comparing the two tools' error sets

It's worth running both tools on the same URL and comparing the error lists. They use different validation rule sets and will often catch non-overlapping issues. A clean Rich Results Test result does not mean clean Schema.org validation — and for AI shopping agents that implement the full schema.org spec rather than just Google's rich-result subset, the Schema.org Validator errors are the ones that matter.

Tool 3: Google Search Console — catalog-wide coverage errors

Reading the Search Console structured data report for Shopify

The report groups errors into three categories:

• Errors: Properties present but with invalid values, or required properties missing. Each error shows an "Affected URLs" count — click through to see which specific product pages are affected.
• Warnings: Recommended properties missing. These don't block rich result eligibility but do reduce the quality score that AI shopping agents use when ranking product matches.
• Valid with warnings: Pages where the structured data is technically parseable but has advisory issues.

The most common Search Console errors seen in Shopify catalogs:

Bonus: manual curl verification for crawlability

Before any structured data can be read, the crawler has to be able to reach your pages. A quick curl check tells you whether AI shopping agent crawlers are being blocked, redirected, or served different content than what your browser sees.

Check that JSON-LD is present in the server-rendered HTML

curl -s https://your-store.com/products/your-product-handle | grep -c "application/ld+json"

Should return a non-zero number. Zero means no JSON-LD is server-rendered at all — the structured data is either absent or injected client-side (invisible to crawlers).

Check that AI crawlers aren't blocked by Cloudflare or a WAF

# Simulate OAI-SearchBot (ChatGPT Shopping crawler)
curl -s -o /dev/null -w "%{http_code}" \
  -H "User-Agent: OAI-SearchBot/1.0 (+https://openai.com/searchbot)" \
  https://your-store.com/products/your-product-handle

# Simulate PerplexityBot
curl -s -o /dev/null -w "%{http_code}" \
  -H "User-Agent: PerplexityBot/1.0 (+https://docs.perplexity.ai/bots)" \
  https://your-store.com/products/your-product-handle

Both should return 200. A 403 or 429 means your CDN or WAF is blocking AI crawlers by user agent — a common misconfiguration documented in detail in our Cloudflare AI crawler guide. A 301 or 302 redirect chain on product URLs can also cause crawlers to abandon indexing if the redirect target is slow or returns a different content type.

Extract the raw JSON-LD for inspection

curl -s https://your-store.com/products/your-product-handle \
  | grep -o '<script type="application/ld+json">[^<]*</script>' \
  | sed 's/<[^>]*>//g'

This prints the raw JSON to your terminal. Pipe it to a JSON formatter (| node -e "process.stdin.resume();let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.stringify(JSON.parse(d),null,2)))") to check for Liquid syntax leaking through, empty strings in critical fields, or malformed JSON that would cause a parse error.

5 silent failure patterns and how to fix them

These patterns are "silent" because they produce no visible page error — your store works fine for human visitors. But they reliably cause AI shopping agents to either skip your product or index it with degraded signals.

How CatalogScan's automated audit fits into the workflow

The three-tool manual workflow above is thorough but time-consuming — especially for catalogs with hundreds or thousands of products where the Rich Results Test and Schema.org Validator require individual URL checks. CatalogScan's automated scan addresses the catalog-scale problem: it crawls your entire product feed the way AI shopping agents do, extracts the JSON-LD from every product page, and scores each of the 18 AI-agent-critical signals across your full catalog.

The output maps directly to what the three-tool workflow would find if you ran it on every product:

The manual workflow is still valuable for two reasons: it lets you verify CatalogScan's findings independently before making theme changes, and it gives you the context to explain specific errors to a developer in terms of the exact field, tool, and error message they'll see when they test the fix.

10-step structured data audit checklist

• Rich Results Test: test highest-traffic product URL — "Product" detected, no errors in Offer block
• Rich Results Test: test a product with no metafields set — no empty-string values in required properties
• Rich Results Test: test an out-of-stock product — availability shows full schema.org URI, not bare string
• Schema.org Validator: paste raw JSON-LD from a product page — no red errors, especially around gtin, availability, or price type
• Schema.org Validator: confirm priceCurrency is ISO 4217 code (USD, EUR, GBP) — not a currency symbol
• curl check: curl -s URL | grep -c "application/ld+json" returns non-zero on product pages
• curl check: OAI-SearchBot and PerplexityBot user agents both receive HTTP 200 on product pages
• curl check: JSON-LD output contains no HTML entities (&, ") inside string values
• Search Console: Shopping enhancements report shows no "Invalid value for field 'availability'" or "Missing field 'price'" errors
• Search Console: URL Inspection on top 10 products shows "Page is eligible for rich results" status

Frequently asked questions

Does Shopify's default Dawn theme have correct structured data for AI shopping agents?

Dawn outputs the basic Product + Offer JSON-LD block with name, description, image, price, priceCurrency, and availability. However, it uses bare availability strings (InStock / OutOfStock) rather than schema.org URIs, it doesn't include GTIN or MPN fields even when metafields are populated, and it doesn't handle the case where a product has no active variants (which causes an empty Offer block). For basic Google rich results eligibility, Dawn is sufficient. For AI shopping agent optimization — where GTIN, MPN, brand, and condition signals all affect recommendation ranking — Dawn's output needs to be extended.

How often should I run a structured data audit?

Run the full 3-tool audit whenever you: upgrade your Shopify theme, install or update a JSON-LD app, modify your product.liquid template, or change your pricing structure (especially if adding multi-currency or Shopify Markets). For ongoing monitoring, Google Search Console's structured data report will flag new errors automatically as Googlebot crawls your catalog. For AI shopping agent-specific monitoring, a monthly CatalogScan run catches signal degradation that Search Console doesn't track (like GTIN coverage declining as new products are added without GTINs).

If the Rich Results Test passes, does that mean AI shopping agents can read my structured data?

Not necessarily. The Rich Results Test validates against Google's rich-result eligibility rules, which are a subset of the full schema.org specification. AI shopping agents like ChatGPT Shopping and Perplexity Commerce implement broader portions of the schema.org spec — they use GTIN, MPN, brand, material, condition, and other properties that aren't required for Google's Product rich results. A product that passes the Rich Results Test but is missing GTIN and brand will be eligible for Google shopping rich results but may rank lower (or be excluded) in AI agent recommendation sets for brand-specific or GTIN-matched queries.

What's the difference between an error and a warning in the Rich Results Test?

Errors in the Rich Results Test indicate that a required property is missing or has an invalid value that prevents the page from qualifying for any rich result type. Warnings indicate that a recommended property is missing — the page can still qualify for rich results, but the quality and ranking may be lower. For AI shopping agents, the error/warning distinction is less meaningful: both represent incomplete signals that reduce the agent's ability to match your product to relevant queries. Treat all Rich Results Test warnings as issues to fix for AI shopping optimization, not just errors.

Can I test structured data without a live public URL?

Yes — both the Schema.org Validator and Rich Results Test support "Direct Input" mode where you can paste in raw HTML or JSON-LD text. This is useful for testing structured data in a development or staging environment before deploying to production. For the Rich Results Test, use the "Code" tab (the small icon next to the URL field) to switch to paste mode. Note that Direct Input mode doesn't execute JavaScript, so if your theme injects structured data via JavaScript, paste in the JSON-LD from the post-JavaScript DOM (copy from the browser's Inspect panel, not View Source).