Get Started for Free
All posts
Guide

Ecwid Product Schema for AI Answers

Stop losing Ecwid product visibility to ChatGPT and Perplexity. Learn step-by-step how to add Product, Review, and Offer structured data so AI engines cite

HHerman11 minutes read

You’re checking your Ecwid site’s traffic and see a slow leak you can’t explain. Referral sources from search are flat, but organic is down, especially long-tail product queries. Then you open ChatGPT or Perplexity, ask “best [your product] for [use case],” and watch an AI list your competitor’s specs, price, and star rating. Your store isn’t mentioned without Ecwid product schema. That’s the new reality: AI answer engines like ChatGPT, Perplexity, Gemini, Grok, and Claude don’t crawl your site the way Google does. They consume structured data. If they can’t parse your products, they can’t cite them.

This guide fixes that for your Ecwid store. We’ll wire up Product, Review, and Offer schema types so AI engines pull your prices, ratings, and attributes into real-time comparison answers. You’ll get the exact JSON-LD blocks, placement instructions, and validation steps. No vague theory, only what gets you cited in AI side-by-side product tables and voice answers.

Prerequisites

Before you add any code, you need:

  • An active Ecwid store on any plan, Instant Site or embedded storefront.
  • Admin access to your Ecwid control panel.
  • The ability to edit your theme’s HTML (usually via Ecwid’s custom code areas or a code injection app).
  • A basic understanding of JSON structure (copy-paste skill is enough).
  • Google Search Console property set up for your store (optional but recommended for monitoring).
  • A [SearchFit] account to track AI citations after implementation. We’ll use its cross-engine visibility dashboard to verify that Ecwid Product Schema for AI answers actually gets you quoted.

Step 1: Know Your Schema Types

You’re going to deploy three linked schema entities on every product page. AI models parse these together to understand what you sell, how much it costs, and whether buyers trust it.

  • Product: This is the core. It describes the item’s name, description, brand, SKU, image, and any unique attributes like color or size. For an Ecwid store, you’ll map each field to your product listing data. The official schema.org/Product reference defines every possible property, but we’ll stick to the ones that AI engines actually weigh: name, description, sku, image, brand, and gtin/mpn if you have them. Perplexity and ChatGPT prioritize these when building comparison snippets.
  • Offer: Nested inside Product, this tells AI your price, currency, and availability. Without a live Offer block, models default to “call for pricing” or ignore you. You’ll use schema.org/Offer with price, priceCurrency, availability, and url.
  • Review: Both AggregateRating and individual Review objects. AggregateRating gives the average star score and count of reviews. Individual reviews carry textual detail that AI can quote. This is often the deciding factor when an engine picks one product over another in a “best X” answer. For Ecwid, you’ll pull review data from the built-in review system or sync from a third-party app like Judge.me (which also outputs its own schema, more on avoiding duplication later).

Pro Tip:

Search engines like Google still require product structured data for rich results. AI engines don’t care about “rich results” but they do consume the same JSON-LD. So your work here kills two birds: it feeds Google Shopping and AI comparisons simultaneously.

Step 2: Add Ecwid Product Schema

Your Ecwid store generates product pages with dynamic data. You’ll inject a JSON-LD script that pulls live product variables. The exact method depends on whether you’re using Ecwid’s Instant Site (server-side rendering) or an embed on your own domain. In either case, you’ll place the script in the <head> of the product page template.

For Ecwid Instant Site:

  • Go to your Ecwid admin → Settings → Instant Site → Code Injection.
  • In the HEAD section, paste the script we’re building. Ecwid supports Liquid-like templating for product variables, but code injection limits you to JavaScript. So we’ll use a self-contained JSON-LD block that you manually update, or, better, a small JavaScript snippet that pulls data from the DOM.

Here’s the manual JSON-LD template. Replace the bracketed values with your actual data. You can automate this later.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "sku": "[PRODUCT_SKU]",
  "name": "[PRODUCT_NAME]",
  "description": "[PRODUCT_DESCRIPTION]",
  "image": "[PRODUCT_IMAGE_URL]",
  "brand": {
    "@type": "Brand",
    "name": "[BRAND_NAME]"
  },
  "offers": {
    "@type": "Offer",
    "url": "[PRODUCT_URL]",
    "priceCurrency": "USD",
    "price": "[PRICE]",
    "availability": "https://schema.org/InStock"
  }
}
</script>

Where to get dynamic values in Ecwid: If you’re embedding Ecwid on your own site (e.g., WordPress, Webflow), use the Ecwid JavaScript API. The Ecwid.OnPageLoaded.add(function(page){...}) callback gives you product data on product pages. For example:

Ecwid.OnPageLoaded.add(function(page){
  if (page.type === "product") {
    var product = page.product;
    var schema = {
      "@context": "https://schema.org",
      "@type": "Product",
      "sku": product.sku,
      "name": product.name,
      "description": product.description,
      "image": product.imageUrl,
      "brand": {
        "@type": "Brand",
        "name": "Your Brand"
      },
      "offers": {
        "@type": "Offer",
        "url": product.url,
        "priceCurrency": product.currency,
        "price": product.price,
        "availability": product.inStock ? "https://schema.org/InStock" : "https://schema.org/OutOfStock"
      }
    };
    var script = document.createElement('script');
    script.type = 'application/ld+json';
    script.textContent = JSON.stringify(schema);
    document.head.appendChild(script);
  }
});

Copy this script into your theme’s custom JavaScript area. It’s safe, fast, and ensures every product page emits the schema. Test it by viewing the page source and searching for "@type":"Product".

Warning:

Don’t hardcode prices or availability status. If your catalog changes and the schema is static, AI engines will show stale data, eroding trust. Always tie schema values to your live product database.

Step 3: Perfect the Offer Schema

The Offer block inside Product is where AI extracts your price and stock status. But a plain Offer node misses optional fields that can win visibility in price-specific queries like “Ecwid Product Schema for AI Answers under $50.” Include these additional properties if they apply:

  • priceValidUntil: A date after which the price is no longer guaranteed. Use ISO 8601 format ("2025-12-31"). This tells AI models that a promotion is time-bound, which can increase urgency in answers.
  • itemCondition: "https://schema.org/NewCondition", "RefurbishedCondition", etc. Helps Perplexity correctly categorize used versus new products.
  • shippingDetails: Especially important for e-commerce. AI comparisons often mention “free shipping” or “$5.99 delivery.” Use the OfferShippingDetails type with shippingRate, deliveryTime, and shippingDestination. Google’s structured data documentation covers the exact fields, even though this goes beyond Google’s Rich Results to feed AI directly.
  • hasMerchantReturnPolicy: AI answer engines increasingly surface return policies when users ask “which store has the best return policy?” Add a MerchantReturnPolicy node inside Offer specifying returnPolicyCategory (e.g., "https://schema.org/MerchantReturnFiniteReturnWindow") and merchantReturnDays.

Example extended Offer block:

"offers": {
  "@type": "Offer",
  "url": "[PRODUCT_URL]",
  "priceCurrency": "USD",
  "price": "29.99",
  "priceValidUntil": "2025-06-30",
  "availability": "https://schema.org/InStock",
  "itemCondition": "https://schema.org/NewCondition",
  "shippingDetails": {
    "@type": "OfferShippingDetails",
    "shippingRate": {
      "@type": "MonetaryAmount",
      "value": 0,
      "currency": "USD"
    },
    "deliveryTime": {
      "@type": "ShippingDeliveryTime",
      "handlingTime": {
        "@type": "QuantitativeValue",
        "minValue": 1,
        "maxValue": 2,
        "unitCode": "d"
      },
      "transitTime": {
        "@type": "QuantitativeValue",
        "minValue": 2,
        "maxValue": 5,
        "unitCode": "d"
      }
    }
  },
  "hasMerchantReturnPolicy": {
    "@type": "MerchantReturnPolicy",
    "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
    "merchantReturnDays": 30,
    "returnMethod": "https://schema.org/ReturnByMail",
    "returnFees": "https://schema.org/FreeReturn"
  }
}

Link everything to reality. If you offer free returns, mark it. If you don’t, omissions are fine; but never fabricate return policies, that leads to poor customer experience and will eventually be flagged by AI trust signals.

Step 4: Add Review Schema (AggregateRating + Individual Reviews)

AI citations often include phrases like “4.2 stars from 230 reviews.” That’s your AggregateRating. When Perplexity pulls a quote like “sturdy build but arrived late,” that’s an individual Review.

Ecwid stores can collect reviews natively via the built-in Product Reviews feature. If you use that, ratings appear on your product pages but not as structured data. You need to extract them into JSON-LD.

Here’s the AggregateRating block to nest inside your Product schema:

"aggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": "4.5",
  "reviewCount": "230",
  "bestRating": "5"
}

This goes directly under the Product object, sibling to “offers”. Use live data: dynamically pull the average rating and total reviews from your Ecwid store. If you’re using the JavaScript API approach, Ecwid’s product object might not expose reviews directly, check the API docs. Often, you’ll need to fetch reviews via Ecwid REST API and cache them.

If you use Judge.me for reviews, it likely injects its own JSON-LD. But duplicate schemas confuse parsers. Choose one source: either pull Judge.me’s aggregate data into your custom schema and disable their JSON-LD, or rely on theirs. I recommend consolidating everything into a single, unified schema block that you control. That’s the only way to guarantee AI engines get clean, unambiguous data.

Individual Reviews: For products with fewer than 50 reviews, include a few sample Review objects to give AI quotes. Each Review requires an author (Person), reviewBody, and reviewRating. Like this:

"review": [
  {
    "@type": "Review",
    "author": {
      "@type": "Person",
      "name": "Jane D."
    },
    "reviewBody": "Best price I found. Quick shipping and perfect condition.",
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": "5",
      "bestRating": "5"
    }
  }
]

Include 3-5 reviews per product page. Pick varied, substantive quotes, the kind an AI might paraphrase. Do not include all reviews, because the JSON-LD block becomes too large and can slow page load.

Pro Tip:

In competitive spaces, an AI often compares the number of reviews. If your Ecwid store has a loyal but small customer base, consider slowing the rollout of schema until you’ve accumulated at least 20 reviews. An AggregateRating of 5.0 with 5 reviews can be ignored by cautious models; 4.8 with 150 reviews is far more convincing.

Step 5: Testing and Validation

Before you declare victory, test your Ecwid Product Schema for AI Answers thoroughly.

  1. Validate with Google’s Rich Results Test: Go to https://search.google.com/test/rich-results and paste your product page URL. Correct any errors. While this tool is Google-centric, it’s the best debugger for schema syntax. AI engines don’t have analogous testers, so a clean Google report is your baseline.
  2. Use Schema.org’s validator: https://validator.schema.org/ is less strict but catches logical errors like missing required fields.
  3. Check the raw JSON-LD: View the page source and copy the script block. Run it through a JSON linter. A single missing comma breaks the entire block, invisible to users but fatal for AI parsing.
  4. Query AI engines manually: Ask ChatGPT (with browsing enabled), “what’s a good [your product] from [your brand]?” See if it cites your store. Do the same on Perplexity, focusing on product comparison queries. Use a tool like [SearchFit] to check your visibility across ChatGPT, Perplexity, Gemini, Claude, and Grok simultaneously. The dashboard shows whether your Ecwid Product Schema for AI answers is registering, i.e., if any AI engine quotes your product name, price, or review snippet.
  5. Check for duplication: Review your page’s rendered HTML for multiple JSON-LD blocks with the same @type. If your theme or apps inject their own, choose one and remove the rest. SearchFit’s schema monitoring can also alert you to duplicate or conflicting markup.

Warning:

Do not rely solely on Google’s Rich Results test passing. AI engines parse schema more thoroughly, they’ll consume shippingDetails, returnPolicy, and individual reviews even if Google ignores them. So your schema must be complete, not just Google-passing.

Step 6: Watch the AI Engines and Iterate

Once the schema is live, monitor how AI platforms use it. This is where many Ecwid stores stall: they deploy schema and forget it. But AI answer engine optimization is dynamic. You need to know which products get cited, which schema properties are used, and whether competitors are displacing you.

Set up a dedicated tracking process:

  • Use SearchFit’s AI visibility dashboard: The platform checks your brand’s presence across ChatGPT, Perplexity, Gemini, Claude, Grok, and Google. When you search “Ecwid Product Schema for AI Answers” and see your store surface in the answer, you’ll know the schema is working. More importantly, it tracks keywords where you’re absent, those are opportunities to refine attributes or add more detailed descriptions.
  • Refine product descriptions: AI models often quote the description field. Ensure yours are unique, feature-driven, and between 80-300 words. Avoid manufacturer boilerplate; write a human-centric summary.
  • Update prices and offers in real time: If your schema pulls live data, you’re set. If you hardcoded anything, switch to dynamic loading immediately. A price change tomorrow that isn’t reflected in schema causes AI to either show wrong data or ignore your listing.
  • Add more structured properties: As your store grows, introduce additionalProperty for specs (e.g., dimensions, weight, color). Models like Gemini and Claude are becoming adept at comparing technical specs, give them the data.
  • Monitor reviews and respond: Fresh reviews update your AggregateRating. The more recent, the better. Some AI models weigh recency of reviews. Prompt buyers to leave reviews post-purchase.

Pro Tip:

Monthly schema audits pay off. Use a schema markup generator to catch new properties that may influence AI answers. Often, the category property (aligning with Google product taxonomy) improves matching in niche product comparisons.

Step 7: Beyond Product Schema, Leveraging AI-First Content

Structured data alone gets you cited, but the content around your schema can push your product to the top of AI answer lists. AI engines digest your on-page text to understand context. Here’s how to fortify your Ecwid product pages:

  • Write for comparison queries: Anticipate queries like “best X for Y” and answer those questions within your product description. Use H2 subheadings like “Why this [product] beats alternatives.” AI summaries will pull from that.
  • Include Q&A sections: Use a FAQ schema on product pages (separate from Product schema) that addresses common objections. Perplexity often sources from FAQ markup.
  • Build authority with external links: Cite credible external sources in your product explanations. For example, link to an industry report if your product aligns with a trend. This signals trustworthiness to some AI models.
  • Add videos and images with appropriate alt text and structured data: Video objects inside Product schema can boost your presence in multimodal AI answers (e.g., Gemini’s image-based responses).

Real-world example: An Ecwid store selling ergonomic office chairs added detailed back-support specs and a comparison chart against top brands. After implementing this schema guide, they started appearing in ChatGPT answers to “best ergonomic chair under $500.” Their AI citation rate climbed 3X within two months, tracked via [SearchFit].

Summary: Key Takeaways

  1. AI answer engines (ChatGPT, Perplexity, Gemini, Claude, Grok) rely on structured data, not just page content. Ecwid Product Schema for AI Answers fuses Product, Offer, and Review types so your store is machine-readable for comparisons.
  2. Start with a clean JSON-LD block dynamically populating name, description, sku, image, brand, and nested offers with live price, currency, and availability.
  3. Extend Offer with shippingDetails, priceValidUntil, and hasMerchantReturnPolicy to win price-sensitive and trust-based queries.
  4. Incorporate aggregateRating and a few individual review objects to supply social proof that AI engines quote directly.
  5. Validate with Google Rich Results and Schema.org validators, then manually test on AI platforms. Use SearchFit to track visibility at scale.
  6. Iterate: keep data fresh, expand schema as you grow, and align your on-page content with comparison-style questions.

With this implementation, your Ecwid store stops being invisible to the next generation of search. You’re not just optimizing for a blue link anymore, you’re engineering your products into the voice and text answers that are siphoning traffic from traditional search. Deploy the schema, verify with data, and keep refining. Your competitors are already doing it.

Get SearchFIT Weekly

What we are learning about getting brands cited in AI search, in your inbox every week. Unsubscribe any time.