Salesforce Commerce Cloud Product Schema for AI Answers

Your product pages show up in Google, but when a shopper asks ChatGPT or Perplexity “best running shoes for plantar fasciitis” or “compare Dyson V15 vs. Samsung Jet 90,” your store is invisible. Zero citations. Zero traffic. AI answer engines are bypassing search results and building product comparisons straight from structured data. If a competitor’s product schema surfaces better than yours, they claim the recommendation, and the sale, before the shopper ever visits a site.

Salesforce Commerce Cloud (SFCC) stores hold vast product catalogs, yet most leave the structured data that feeds these AI engines half-implemented or missing altogether. Google requires Product, Review, and Offer markup for rich results; AI models scrape the same crawlable JSON-LD to fuel answers. When your SFCC store gets the schema right, it earns a seat in the AI-generated comparison table. This step-by-step guide shows exactly how to implement Product, Review, and Offer structured data in Salesforce Commerce Cloud so AI engines cite and recommend your products.

Prerequisites

Before touching code, make sure you have:

• SFCC environment access: an administrator account with permission to edit page templates (ISML, JavaScript controllers) and the Business Manager.
• Schema design mapped to your catalog: Product types, variants, pricing logic, and review data sources must be clearly identified. You’ll need to pull real-time availability, price currency, and review aggregate values from your SFCC backend.
• JSON-LD preference: Google and AI models favor JSON-LD over microdata or RDFa. All snippets in this guide use JSON-LD. If your store currently uses other formats, plan a migration.
• Testing tools: You’ll use the Schema Markup Validator, Google’s Rich Results Test, and an AI visibility tracker like SearchFit to audit and monitor performance.

Warning: If your SFCC instance is heavily customized, review how the framework exposes product data. Some Page Designer-built pages may render content outside standard controllers, making schema injection more complex. Confirm you can access product attributes in the rendering context before proceeding.

Step 1: Audit Your Current Schema Markup

Start by scraping a handful of representative product pages, main PDP, a size variant, a bundle, and a page with reviews. Use any HTTP client to fetch the rendered HTML, then extract all <script type="application/ld+json"> blocks. Check what’s there. Most SFCC stores using standard Reference Architecture (SFRA) will include some Product markup, often auto-generated by the platform’s SEO helpers. It’s rarely complete, and almost never tuned for AI engines.

Run each page through Google’s Rich Results Test at https://search.google.com/test/rich-results. Note the warnings and errors. Pay special attention to:

• Missing offers array.
• Offer lacking priceCurrency, availability, or a valid price.
• No aggregate aggregateRating on the Product.
• Images miss the required image property at the Product level.
• Duplicated markup (common when a theme adds schema and a custom script adds another).

Document the gaps. Then test the same pages in an AI citation tool. SearchFit lets you see whether ChatGPT, Perplexity, Gemini, or Claude already cite your product data, and exactly which fields they pull. Many teams discover their description field is missing, so the AI substitutes a generic blurb from another source.

Pro tip: Audit mobile templates separately. AI crawlers often fetch the mobile version of a page, so schema must be present and complete there as well.

Step 2: Implement Product Structured Data

The Product schema is the anchor. Everything else, offers, reviews, attaches to it. In SFCC, you’ll inject a dynamically generated JSON-LD block into the <head> of your product detail page. The ideal approach is to extend the existing SEO helper class or create a new server-side JavaScript (SFRA) controller that constructs the JSON-LD object and outputs it to the ISML template.

Here’s a minimal but AI-ready Product schema template:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "@id": "https://www.example.com/product/12345#product",
  "name": "Hoka Bondi 8",
  "description": "Maximum-cushion road running shoe with a plush, breathable upper and early-stage Meta-Rocker geometry.",
  "sku": "1123193-BWHT",
  "brand": {
    "@type": "Brand",
    "name": "Hoka"
  },
  "image": [
    "https://www.example.com/on/demandware.static/-/Sites-masterCatalog/default/dw123456/images/hi-res/bondi8-black.jpg"
  ],
  "category": "Shoes > Running",
  "gtin13": "195719123456",
  "mpn": "1123193-BWHT"
}

Build it dynamically from your SFCC product model:

• @id should be the canonical URL with a fragment identifier. This helps AI models deduplicate products across pages.
• name uses your product display name (full title, not a truncated one).
• description: pull the long description, not the short. Aim for 150-300 characters of unique, benefit-focused text. AI answer engines extract product descriptions verbatim; they heavily influence comparison summaries.
• sku, gtin13, mpn: Include every identifier you have. AI models cross-reference these to group the same product across retailers. If you only have a SKU, use it in sku and repeat in identifier properties as well.
• brand: if your SFCC store sells multiple brands, map the manufacturer brand string. For store-brand products, use your company name.
• image: Provide the primary image URL in an array. Include at least one high-res, two-megapixel image; AI engines sometimes pull images into visual answers.
• category: Use a clear breadcrumb-style string or a Schema.org CategoryCode reference. This helps AI models understand the product context beyond keyword analysis.

Pro tip: For color/size variants, mark up each as a separate Product node and link them via the isVariantOf property pointing to a ProductGroup. This signals to AI engines that different variants are related, and they may surface the best variant match for a query.

Step 3: Add Review Schema That AI Engines Trust

Review markup converts star ratings into crawlable numbers. Without it, your product may be filtered out of AI comparisons that require “average rating” as a sort criterion. On SFCC, if you use a native reviews module like Bazaarvoice, PowerReviews, or Salesforce’s own Commerce Cloud Reviews, you likely have an API that returns aggregate rating data.

Embed the following snippet inside your main Product schema, right before the closing brace:

"aggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": "4.5",
  "reviewCount": "148",
  "bestRating": "5",
  "worstRating": "1"
}

• ratingValue must be a decimal number, fetched from your reviews system. AI aggregators compare this value directly; an off-by-0.1 error can drop you below a threshold.
• reviewCount influences perceived trust. Even a low count is better than missing it.
• Always pair aggregateRating with at least one Review item if reviews are displayed on the page. For SFCC stores that display individual reviews, add an array of Review nodes:

"review": [
  {
    "@type": "Review",
    "author": {
      "@type": "Person",
      "name": "Sarah K."
    },
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": "5"
    },
    "reviewBody": "Best running shoes I’ve ever owned. Cushioning lasts."
  }
]

Warning: Never hardcode rating values. AI engines can detect static numbers across multiple products and devalue the schema. Always wire into the live review feed. If reviews aren’t available for a product, omit aggregateRating altogether rather than faking it.

Some AI engines also read positiveNotes and negativeNotes subproperties within Review (proposed extension). If your reviews platform surfaces pros/cons, include them inside the review object as additionalProperty or in the reviewBody. AI comparisons often extract pros and cons to build summary tables, so explicit positive/negative data can make your product stand out.

Step 4: Layer On Offer Structured Data

Offer markup turns pricing into a structured signal. An AI query like “best budget wireless headphones under $100” only returns products whose price data the model can parse. In SFCC, price tiers, promotions, and availability change constantly. Your schema must reflect the real state at crawl time.

Attach an offers array to the Product node. For a simple e-commerce store with a single price, this works:

"offers": {
  "@type": "Offer",
  "priceCurrency": "USD",
  "price": "129.95",
  "availability": "https://schema.org/InStock",
  "url": "https://www.example.com/product/12345",
  "itemCondition": "https://schema.org/NewCondition",
  "seller": {
    "@type": "Organization",
    "name": "Your Store Name"
  }
}

SFCC-specific considerations:

• Price: Pull from the effective price (after promotions, but before tax/shipping). If the product is on sale, many stores publish both price and priceSpecification with a minPrice and maxPrice, or a wasPrice via priceDetail. For AI comparisons, the current price is the most critical. Use the SFCC pricing object to get the tier applicable to the anonymous shopper.
• Availability: Map SFCC availability status from ProductInventoryList or ATSMODEL.getAvailabilityStatus() to one of the Schema.org enumerated values: InStock, OutOfStock, PreOrder, BackOrder. AI shopping assistants often filter products by availability. If your store supports in-store pickup, also include availableAtOrFrom with store locations.
• Eligible quantity: For B2B or bulk commerce, include eligibleQuantity with price breaks. AI comparison engines like Perplexity will surface “price per unit when buying a 6-pack” if you provide that detail.

Pro tip: For multi-price scenarios (e.g., different sizes have different prices), use an offers array with multiple Offer nodes, each tied to variant SKU via sku. This allows AI to answer “What does the medium-sized shirt cost?” directly.

Step 5: Validate and Test Your Markup

Implementation is half the battle. You must validate that your JSON-LD renders correctly and is parseable by AI engines.

1. Schema Markup Validator (https://validator.schema.org/): Paste the URL of a live product page. Check every property for unrecognized types. Fix any errors or warnings. This tool validates against the official Schema.org specification, which is what AI models reference.
2. Google Rich Results Test: Even though you’re targeting AI engines, Google’s tool catches common parsing errors and shows exactly how your schema will appear in search features. It also flags incompatible combinations. Use it for all three content types.
3. AI citation test: Use searchfit.ai’s AI visibility tracker to check whether ChatGPT, Perplexity, Gemini, Claude, and Grok now cite your product data. Run a query like “compare [your product] to [competitor]” and see which fields appear in the model’s response. The tool shows you the exact snippet the model attributed to your product, often a truncated description or missing rating, highlighting gaps you still need to close.

Warning: Check both desktop and mobile rendered pages. Some SFCC implementations inject schema only in the desktop template or use JavaScript to dynamically load reviews, which may not fire for crawlers. Ensure your schema is emitted in the server-rendered HTML of the mobile template.

Step 6: Monitor AI Visibility and Iterate

Schema isn’t set-it-and-forget-it. AI answer engines evolve, and competitors change their markup. You need continuous monitoring.

Set up a weekly audit routine:

• Use searchfit.ai to track your brand’s AI visibility percentage across engines. It shows which product pages get cited and which don’t.
• Re-run the Schema Markup Validator after any catalog changes (new categories, price structures).
• Monitor your reviews feed: a sudden drop in average rating can push your product below a threshold in AI comparisons. React by addressing root causes, not by faking data.

When you spot a drop in citations, drill into the AI snippet. Often, the model stopped including your product because a required field changed from required to optional in the Schema.org spec, or a new AI engine introduced a custom property that your competitors adopted. For example, Claude recently began parsing hasMerchantReturnPolicy schema on Offers to inform “return policy” questions. Adding this to your Offer markup can earn you a citation edge.

Pro tip: Leverage SFCC’s extensibility to automatically update schema whenever a product attribute changes. Use a hook on the product save event to regenerate JSON-LD and purge any cached template fragments. This keeps schema fresh without manual intervention.

Key Takeaways

• Product, Review, and Offer structured data are the three pillars that get your SFCC store cited in AI-generated product comparisons.
• Dynamic JSON-LD, generated from live catalog and pricing data, outperforms static markup every time.
• AI engines scrape the same structured data that Google uses, so validating against Schema.org and the Rich Results Test directly improves AI answer presence.
• Monitoring tools like searchfit.ai close the loop between implementation and visible results, showing you exactly when and where your products show up in AI answers.

Start with a single product template. Implement the full schema chain, Product, Offer, Review, and verify AI citations within a week. Then scale to your entire catalog. The stores that act now will own the AI comparison tables before the rest of the market catches on.