Shopify trust signals for AI shopping agents: return policy, warranty, certifications, and seller rating schema

Why AI agents are trust-first recommendation engines

When someone asks ChatGPT Shopping "where can I buy a good cast-iron skillet under $80?" the agent doesn't run a price comparison. It runs a trust check. It asks: which stores in my knowledge base have verified product data, documented post-purchase policies, and a credible seller reputation? Then it picks the cheapest option from that verified set.

This is fundamentally different from how Google Shopping worked. Google Shopping ranked products on price, relevance, and bid. AI agents rank stores on verifiability. A store with a clear return policy, a real warranty commitment, and certified product claims is more likely to be recommended than a cheaper competitor who has none of those signals documented in structured data — even if the product data itself is otherwise identical.

The reason comes down to liability. When an AI agent recommends a specific store and that purchase goes wrong (item doesn't ship, return is refused, product breaks), the agent's trust in that store degrades. Modern AI shopping recommendation models penalize stores that create post-purchase friction. The way agents pre-screen for post-purchase risk is by reading trust schema before making a citation.

The four trust signals that AI agents read most consistently are: MerchantReturnPolicy (return policy terms in schema.org), WarrantyPromise (guarantee signals on products), hasCertification (safety and sustainability certifications), and Organization AggregateRating (seller-level reputation, distinct from product reviews). Each maps to a different layer of post-purchase risk.

Signal 1: MerchantReturnPolicy — the most commonly missing trust signal

MerchantReturnPolicy is a schema.org type that documents your store's return terms in a machine-readable format. It attaches to an Offer via the hasMerchantReturnPolicy property. Despite being the highest-leverage trust signal (ChatGPT Shopping and Perplexity both parse it explicitly), 73% of Shopify stores have no return policy schema at all.

The minimum viable MerchantReturnPolicy block has four fields: returnPolicyCategory (the key trust gate), merchantReturnDays (the window), returnMethod, and returnFees. Here's what a standard 30-day free-returns policy looks like:

{
  "@type": "MerchantReturnPolicy",
  "@id": "https://yourstore.com/#return-policy",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 30,
  "returnMethod": "https://schema.org/ReturnByMail",
  "returnFees": "https://schema.org/FreeReturn",
  "applicableCountry": "US"
}

The returnPolicyCategory field is the one AI agents read for a binary trust decision. The four valid values form a trust hierarchy:

For Shopify stores, the cleanest way to inject MerchantReturnPolicy is to add it as a nested object inside your Offer JSON-LD block in sections/main-product.liquid. This scopes the policy to the product level, which is where AI agents look for it during product-page crawls.

Signal 2: WarrantyPromise and warranty additionalProperty

For electronics, appliances, tools, and premium goods, warranty commitment is as important as price. A buyer asking Perplexity "best standing desk under $600 with a 5-year warranty" is giving you an explicit filter — if you don't have warranty data in structured form, you're invisible for that query even if your desk is $550 with a 7-year warranty listed on your product page in plain text.

Schema.org's WarrantyPromise type is the official vehicle. It has two key properties: durationOfWarranty (a QuantitativeValue) and warrantyScope (an enum describing what's covered).

{
  "@type": "Product",
  "name": "{{ product.title | json }}",
  ...
  "warranty": {
    "@type": "WarrantyPromise",
    "durationOfWarranty": {
      "@type": "QuantitativeValue",
      "value": 2,
      "unitCode": "ANN"
    },
    "warrantyScope": "https://schema.org/WarrantyScope/LabourAndParts"
  }
}

The warrantyScope enum has four values worth knowing:

For stores where warranty terms are stored as metafields, the durationOfWarranty.value can be injected dynamically. If product.metafields.warranty.duration_months exists, divide by 12 for years or use unitCode: "MON". If warranty varies by variant (common for electronics with extended-protection bundles), loop through variants and inject per-variant warranty in the hasVariant array.

Alongside WarrantyPromise, add a parallel additionalProperty entry. Some AI agents parse additionalProperty arrays more broadly than they parse the formal warranty property:

"additionalProperty": [
  {
    "@type": "PropertyValue",
    "name": "warrantyDuration",
    "value": "2 years"
  },
  {
    "@type": "PropertyValue",
    "name": "warrantyScope",
    "value": "parts and labour"
  }
]

Signal 3: hasCertification — safety and sustainability trust

For children's products, food, cosmetics, textiles, and anything with a sustainability claim, certifications are the most credible trust signal available. A buyer asking "is this sunscreen reef-safe?" or "is this toy CPSC-compliant?" is doing a compliance check, not a price check. If your products carry real certifications (GOTS, USDA Organic, B Corp, CE Marking, CPSC, 1% for the Planet), schema.org's hasCertification property is how you make those certifications machine-readable.

The Certification type has four useful properties: name (required), issuedBy (the certifying Organization), about (what it certifies), and optionally url or sameAs linking to the cert's public database entry.

{
  "@type": "Product",
  "name": "{{ product.title | json }}",
  ...
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "GOTS Certified Organic",
      "issuedBy": {
        "@type": "Organization",
        "name": "Global Organic Textile Standard (GOTS)",
        "sameAs": "https://www.global-standard.org/"
      },
      "about": {
        "@type": "Thing",
        "name": "Organic textile processing and social criteria"
      }
    },
    {
      "@type": "Certification",
      "name": "OEKO-TEX STANDARD 100",
      "issuedBy": {
        "@type": "Organization",
        "name": "OEKO-TEX Association",
        "sameAs": "https://www.oeko-tex.com/"
      }
    }
  ]
}

For stores that carry certified products alongside non-certified ones, use product tags or a product.metafields.certifications.list JSON metafield to gate the hasCertification block conditionally in Liquid. Injecting empty or fabricated certification schema is a trust signal violation — AI agents cross-check against certifying body databases for premium certification types.

Store-level sustainability certifications (B Corp, 1% for the Planet, carbon-neutral operations) belong on the Organization type in theme.liquid, not on individual products. This is the correct semantic scope: your B Corp status certifies your business, not each product individually.

{
  "@type": "Organization",
  "name": "Your Store Name",
  "url": "https://yourstore.com/",
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "Certified B Corporation",
      "issuedBy": {
        "@type": "Organization",
        "name": "B Lab",
        "sameAs": "https://www.bcorporation.net/"
      }
    }
  ]
}

Signal 4: Organization AggregateRating — seller-level trust

Product reviews tell agents "this product is good." Seller ratings tell agents "this store is reliable." They're distinct signals with distinct schema placements. Product AggregateRating lives inside the Product type on product pages. Seller AggregateRating lives inside the Organization type in theme.liquid — it appears on every page of your site.

The minimum viable seller AggregateRating block:

{
  "@type": "Organization",
  "name": "Your Store Name",
  "url": "https://yourstore.com/",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "2341",
    "bestRating": "5",
    "worstRating": "1"
  }
}

The source data for seller AggregateRating depends on where your customers leave store-level reviews. Trustpilot provides an API endpoint for your score. Google Customer Reviews (enabled through the Google channel in Shopify admin) feeds into Google's shopping trust graph. Yotpo's store reviews widget, if enabled separately from product reviews, provides aggregate seller rating data. The Shopify admin dashboard shows your store's overall review rating if you use Shopify Reviews.

The most important thing: keep the reviewCount accurate and synced. An Organization AggregateRating with a stale count (e.g., showing 156 reviews when you now have 2,340) is a low-trust signal to AI agents that cross-check against the platform source. Use a metaobject or a server-side variable to inject the real count dynamically, or update it manually each month. Never hardcode a round number like "100 reviews" — it reads as fabricated.

Perplexity Commerce is the most aggressive reader of seller-level AggregateRating among the major AI shopping agents. Its recommendation model weights post-purchase confidence signals heavily, and a store with a high seller rating but no product ratings will still outperform a store with strong product ratings and no seller rating in Perplexity's recommendation logic for certain query types (e.g., "best place to buy X" vs. "best X").

Putting it together: a complete trust-layer Liquid snippet

These four trust signals operate at two levels. Return policy and warranty live inside the product Offer. Certifications split between product level (product-specific certs) and organization level (store-wide certs). Seller rating lives at organization level in theme.liquid.

Here's a combined snippet for sections/main-product.liquid that layers all product-level trust signals into the existing Offer block:

{% comment %} Trust layer — add inside the Offer object in your main Product JSON-LD {% endcomment %}
"hasMerchantReturnPolicy": {
  "@type": "MerchantReturnPolicy",
  "@id": "https://{{ shop.domain }}/#return-policy",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 30,
  "returnMethod": "https://schema.org/ReturnByMail",
  "returnFees": "https://schema.org/FreeReturn",
  "applicableCountry": "US"
}
{% if product.metafields.warranty.duration_years %}
,"warranty": {
  "@type": "WarrantyPromise",
  "durationOfWarranty": {
    "@type": "QuantitativeValue",
    "value": {{ product.metafields.warranty.duration_years }},
    "unitCode": "ANN"
  },
  "warrantyScope": "https://schema.org/WarrantyScope/LabourAndParts"
}
{% endif %}
{% assign cert_tags = product.tags | join: ',' %}
{% if cert_tags contains 'certified-organic' or cert_tags contains 'gots' %}
,"hasCertification": [
  {
    "@type": "Certification",
    "name": "GOTS Certified Organic",
    "issuedBy": {
      "@type": "Organization",
      "name": "Global Organic Textile Standard (GOTS)",
      "sameAs": "https://www.global-standard.org/"
    }
  }
]
{% endif %}

And in theme.liquid, the organization-level trust block that persists across every page:

{% comment %} Organization trust block in theme.liquid global JSON-LD {% endcomment %}
{
  "@type": "Organization",
  "name": {{ shop.name | json }},
  "url": "https://{{ shop.domain }}/",
  {% if shop.metafields.store_trust.seller_rating %}
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": {{ shop.metafields.store_trust.seller_rating | json }},
    "reviewCount": {{ shop.metafields.store_trust.review_count | json }},
    "bestRating": "5",
    "worstRating": "1"
  },
  {% endif %}
  {% if shop.metafields.store_trust.is_b_corp == "true" %}
  "hasCertification": [{
    "@type": "Certification",
    "name": "Certified B Corporation",
    "issuedBy": {
      "@type": "Organization",
      "name": "B Lab",
      "sameAs": "https://www.bcorporation.net/"
    }
  }],
  {% endif %}
  "contactPoint": {
    "@type": "ContactPoint",
    "contactType": "customer service",
    "availableLanguage": "English"
  }
}

This pattern keeps trust data DRY: the metafields (store_trust.seller_rating, store_trust.review_count, store_trust.is_b_corp, warranty.duration_years) are maintained in the Shopify admin, and the Liquid templates inject them at render time. No redeployment needed when your review count increases or you earn a new certification.

5 common trust schema mistakes

FAQ