20 Common Schema Markup Errors That Kill Your Rich Results and AI Visibility

Schema markup is unforgiving. A single wrong URL format, a missing required property, or a mismatch between your structured data and your visible page content can silently destroy your rich results, trigger a Google manual action, or cause AI systems to skip your pages entirely. After auditing thousands of ecommerce sites, these are the 20 most common schema errors -- ranked roughly by how frequently they appear and how much damage they cause.

Error 1: Wrong Availability URL Format

The mistake: Using plain text like "In Stock" or "Available" instead of the full Schema.org URL.

Wrong:

{ "availability": "In Stock" }
{ "availability": "InStock" }

Correct:

{ "availability": "https://schema.org/InStock" }

Google requires the full Schema.org URL for availability values. The accepted values are:

  • https://schema.org/InStock
  • https://schema.org/OutOfStock
  • https://schema.org/PreOrder
  • https://schema.org/BackOrder
  • https://schema.org/Discontinued
  • https://schema.org/OnlineOnly
  • https://schema.org/InStoreOnly
  • https://schema.org/LimitedAvailability
  • https://schema.org/SoldOut

This is the single most common Product schema error. Many auto-generated schema implementations use the short form, which Google rejects.

Error 2: Stale Prices in Schema

The mistake: Your schema shows one price but the page shows a different price -- usually because the schema is not dynamically generated from the same data source as the visible price.

This happens most often during sales. Your visible price drops to $24.99 but your schema still shows the original $34.99 because the schema template pulls from a different data field than the sale price display.

Google's policy is explicit: structured data must match the values shown to the user. A mismatch can result in a manual action that strips all your rich results.

The fix: Generate your schema price from the exact same data source as your displayed price. On Shopify, use {{ product.selected_or_first_available_variant.price | money_without_currency }} for both.

Error 3: Missing Required Offer Properties

The mistake: Including a Product schema without the minimum Offer properties that Google requires.

For Google Merchant Center automated feeds and Shopping eligibility, you need at minimum:

  • name (on the Product)
  • image (on the Product)
  • offers.price
  • offers.priceCurrency
  • offers.availability

Missing any of these means Google cannot use your structured data for Shopping results. Many merchants include name and price but forget priceCurrency or availability.

Complete minimum Offer:

{
  "offers": {
    "@type": "Offer",
    "price": "34.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

Error 4: Schema on Hidden Content

The mistake: Marking up content that is not visible to users. Google's policy states that structured data must describe content that is visible on the page. Schema describing hidden content may be considered deceptive.

Common violations:

  • Adding FAQ schema for questions that are hidden behind a collapsed accordion that requires JavaScript interaction
  • Including review text in schema that does not appear anywhere on the page
  • Adding product descriptions in schema that differ from the visible page description

The rule: If a user cannot see it on the page, do not include it in your schema. The one exception: properties like sku, gtin, and priceCurrency that are inherently machine-oriented and do not need visible counterparts.

Error 5: Category-Level Ratings Applied to Individual Products

The mistake: Taking the aggregate rating of your best-reviewed product and applying it to your entire collection page, or applying a single product's rating to all products in a category.

Google explicitly warns: "If you add reviews or ratings to a page, make sure the reviews and ratings are about the specific item described on the page and not about a general category." Applying one product's 4.9-star rating to all 200 products in a collection is manipulative and can trigger a manual action.

The rule: AggregateRating must represent the actual reviews for the specific entity described on that page.

Error 6: JSON Syntax Errors

The mistake: Invalid JSON that breaks the entire schema block. JSON-LD is standard JSON, and it is unforgiving about syntax.

Common syntax errors:

  • Trailing commas after the last item in an array or object (valid in JavaScript, invalid in JSON)
  • Missing closing braces or brackets
  • Unescaped quotes in string values
  • Single quotes instead of double quotes (JSON requires double quotes)
  • Comments in JSON (JSON does not support comments)

Wrong (trailing comma):

{
  "name": "Product Name",
  "price": "29.99",
}

Correct:

{
  "name": "Product Name",
  "price": "29.99"
}

The fix: Run your JSON through a linter (jsonlint.com) before deploying. Most IDEs also highlight JSON syntax errors.

Error 7: Nesting Errors -- Offer Outside Product

The mistake: Placing the Offer as a sibling of Product instead of nesting it inside Product. Or placing AggregateRating outside the entity it describes.

Wrong (Offer as sibling):

[
  {
    "@type": "Product",
    "name": "Organic Cotton T-Shirt"
  },
  {
    "@type": "Offer",
    "price": "29.99"
  }
]

Correct (Offer nested inside Product):

{
  "@type": "Product",
  "name": "Organic Cotton T-Shirt",
  "offers": {
    "@type": "Offer",
    "price": "29.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

Error 8: Using the Wrong itemCondition URL

The mistake: Similar to the availability URL error, using short-form strings instead of full Schema.org URLs for item condition.

Wrong:

{ "itemCondition": "New" }
{ "itemCondition": "NewCondition" }

Correct:

{ "itemCondition": "https://schema.org/NewCondition" }

Valid values include:

  • https://schema.org/NewCondition
  • https://schema.org/UsedCondition
  • https://schema.org/RefurbishedCondition
  • https://schema.org/DamagedCondition

Error 9: Duplicate Schema Blocks for the Same Entity

The mistake: Having two or more separate Product schema blocks on the same page describing the same product. This confuses search engines about which data is authoritative.

This commonly happens when:

  • A schema app generates Product schema, and the theme also outputs Product schema
  • A developer adds schema manually without knowing the theme already includes it
  • Multiple plugins each add their own schema output

The fix: Check your page source for all application/ld+json script blocks. Search for duplicate @type declarations. Remove duplicates and keep only one authoritative source.

Error 10: Missing Image Property

The mistake: Product schema without any image. Google requires at least one image for Product rich results and Shopping eligibility.

Requirements:

  • Image must be crawlable and indexable
  • Image URL must be a complete, absolute URL (not a relative path)
  • Image should be at least 800x800 pixels for Shopping eligibility
  • Include multiple images for better rich result performance

Wrong:

{ "image": "/images/product.jpg" }

Correct:

{ "image": "https://example.com/images/product.jpg" }

Error 11: Price Format Errors

The mistake: Including currency symbols, thousands separators, or other formatting in the price value.

Wrong:

{ "price": "$29.99" }
{ "price": "1,299.99" }
{ "price": "29.99 USD" }

Correct:

{ "price": "29.99", "priceCurrency": "USD" }
{ "price": "1299.99", "priceCurrency": "USD" }

The price must be a plain decimal number. Currency goes in the separate priceCurrency property.

Error 12: Not Updating Schema for Variant Products

The mistake: A product page shows a t-shirt available in 5 sizes and 3 colors, but the schema only describes one variant -- usually the default selection.

For products with variants, you have two options:

Option A: Single Offer with the lowest price (simplest):

{
  "offers": {
    "@type": "AggregateOffer",
    "lowPrice": "24.99",
    "highPrice": "34.99",
    "priceCurrency": "USD",
    "offerCount": "15",
    "availability": "https://schema.org/InStock"
  }
}

Option B: Multiple Offers for each variant (more detailed):

{
  "offers": [
    {
      "@type": "Offer",
      "name": "Small / White",
      "price": "24.99",
      "priceCurrency": "USD",
      "availability": "https://schema.org/InStock"
    },
    {
      "@type": "Offer",
      "name": "Large / White",
      "price": "29.99",
      "priceCurrency": "USD",
      "availability": "https://schema.org/OutOfStock"
    }
  ]
}

Error 13: Self-Written Reviews in Schema

The mistake: Adding reviews written by the business itself (or commissioned without disclosure) to the Review schema. Google's guidelines state that reviews must be genuine, independent, and from actual customers.

If Google detects that a business is generating its own reviews to display star ratings in search results, it may issue a manual action that removes all review rich results from the site.

Error 14: Wrong @type for the Page Content

The mistake: Using Product schema on a category/collection page. Using Article schema on a product page. Using LocalBusiness when you are an online-only store.

The rule: The @type must match the primary content of the page.

  • Product pages get Product schema
  • Collection pages get ItemList or CollectionPage schema
  • Blog posts get Article schema
  • Your homepage gets Organization and WebSite schema

Error 15: Forgetting dateModified on Article Schema

The mistake: Implementing Article schema with datePublished but never including or updating dateModified. Pages with dateModified schema receive 1.8x more AI citations. Omitting it means your content always appears as old as its original publication date to AI systems.

The fix: Include dateModified on every Article. Update it whenever you make substantive content changes. Automate this through your CMS.

The mistake: Including sameAs URLs in Organization schema that lead to 404 pages, deleted social profiles, or pages about a different entity with the same name.

Every sameAs URL should:

  • Return a 200 status code
  • Point to a page that is actually about your organization
  • Be a profile you control or a Wikipedia/Wikidata page about you

The fix: Audit your sameAs links quarterly. Remove any that are broken or incorrect.

Error 17: Using Deprecated Properties

The mistake: Using schema.org properties that have been deprecated or replaced.

Common examples:

  • offers.seller should now use offers.offeredBy in some contexts
  • productID has been superseded by more specific identifiers like sku, gtin, mpn
  • Older review properties may have updated formats

The fix: Check the Schema.org changelog and Google's structured data documentation when implementing or updating schema. Use the Schema Markup Validator to catch deprecated properties.

Error 18: Multiple @context Declarations in Nested Objects

The mistake: Including "@context": "https://schema.org" inside nested objects. The @context only needs to be declared once at the top level.

Wrong:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "T-Shirt",
  "offers": {
    "@context": "https://schema.org",
    "@type": "Offer",
    "price": "29.99"
  }
}

Correct:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "T-Shirt",
  "offers": {
    "@type": "Offer",
    "price": "29.99"
  }
}

While duplicate @context declarations may not break the schema, they add unnecessary bytes and can cause issues with some parsers.

Error 19: Not Matching Schema Data to Visible Content

The mistake: Your schema contains different information than what users see on the page. This goes beyond just price mismatches:

  • Schema name says "Premium Organic Cotton Tee" but the H1 says "Soft Cotton T-Shirt"
  • Schema description is a different paragraph than the visible product description
  • Schema shows a product image that does not appear on the page
  • Schema includes a review count of 312 but the page displays 298 (because some reviews were filtered)

Google's policy is clear: structured data must reflect the content on the page. Any discrepancy is a potential policy violation.

Error 20: Plugin Conflicts Creating Invalid Schema

The mistake: Installing multiple Shopify apps, WordPress plugins, or CMS modules that each generate their own schema, resulting in conflicting or duplicate structured data.

Common scenario on Shopify:

  1. Theme includes basic Product schema
  2. You install a review app that adds its own Product schema with AggregateRating
  3. You install a schema app that generates complete Product schema
  4. Result: three Product schema blocks on one page, with different prices, names, or ratings

The fix:

  1. View your page source and search for application/ld+json
  2. Count how many Product schema blocks exist
  3. Disable schema output from all sources except one
  4. Configure your chosen schema source to include all needed properties (reviews, ratings, shipping, etc.)

How to Audit for These Errors

Run this checklist across a sample of your pages (at least 3 of each page type):

  1. Test each page in the Google Rich Results Test
  2. View page source and count JSON-LD blocks -- check for duplicates
  3. Compare schema values to visible page content (price, name, rating, availability)
  4. Validate JSON syntax with a linter
  5. Check all URLs in schema (availability, itemCondition, sameAs, image) return valid responses
  6. Verify all required properties are present for each schema type
  7. Run Screaming Frog across your site to identify sitewide patterns

Fixing these 20 errors will not just restore your rich results. It will strengthen your structured data's reliability as a signal for AI systems, which increasingly use schema accuracy as a trust indicator when deciding which sources to cite.

Up next

Schema for Shopify

Implementing structured data on Shopify stores.