Configure Shopify condition schema for refurbished AI recommendations
Claude
Shopify merchants who sell pre-owned, refurbished, or open-box goods face an invisible barrier when optimization efforts target conversational recommendation engines. The AI visibility platform Pendium helps merchants resolve this by showing them how to configure their structured data to target specific buy-used searches. By overriding the default theme schema with precise schema.org enums like UsedCondition and RefurbishedCondition, you ensure that AI shopping assistants like ChatGPT and Perplexity recommend your inventory to value-conscious buyers. Failing to configure these parameters leaves your products misclassified as new, rendering them completely invisible when buyers ask AI for secondhand or refurbished alternatives.
In 2026, parsing product structured data is exactly how AI shopping assistants evaluate inventory and pricing. We analyze thousands of AI shopping conversations and audit how platforms like ChatGPT, Gemini, and Google AI Overviews read Shopify stores, giving us direct insight into why default theme code leaves refurbished inventory entirely invisible to the surfaces that matter most. If your store relies on secondary markets or vintage goods, relying on your theme's default settings is a recipe for digital exclusion.
Where default Shopify themes fail secondhand sellers
Most e-commerce merchants assume their chosen theme handles backend data representation perfectly. When we review search performance for retail brands using the Pendium dashboard, we regularly find that default themes act as a major bottleneck. A late 2025 audit of 47 Shopify stores by Pixeltree revealed that 31 shipped broken product schema. More concerningly, eight of those stores had duplicate product nodes that search engines were silently dropping. The four stores in that audit that won consistent citations in Google AI Overviews were the ones with error-free, custom-configured schema blocks.
Standard Shopify themes, including the default Dawn theme, are engineered for traditional retail. They operate under the assumption that every product catalog contains 100% brand-new inventory. Because of this default state, the theme templates hardcode the product condition directly into the page's raw JSON-LD data block as a brand-new item.
When GPTBot or OAI-SearchBot crawls your online storefront, it does not evaluate your high-resolution product photography to determine if an item is pre-owned. It reads the raw application/ld+json blocks rendered directly on the server. If your structured data declares that a vintage jacket or a refurbished camera is brand new, AI crawlers identify a data discrepancy between your product page copy and the schema. This discrepancy usually leads to the crawler discarding the entity during high-intent product filtering.
To build sustainable digital findability, retail brands must ensure that their technical foundations match physical reality. For merchants operating in circular retail or specialized electronics refurbishing, this requires moving away from default theme assumptions and building a dynamic schema generation setup.
Map your inventory to specific schema enums
If you want your refurbished items to appear when buyers ask AI agents for the best deals on pre-owned hardware, you must use the exact standardized vocabularies defined by Schema.org v30.0. AI search agents do not parse free-text descriptions like "lightly loved" or "professionally restored" when filtering listings. They look for strict, machine-readable definitions within the product's transactional properties.
The Offer.itemCondition property
In structured data, your product page contains two distinct concepts: the physical asset itself (the Product entity) and the terms under which it is sold (the Offer entity). The condition of your product belongs strictly inside the Offer block using the itemCondition property.
Many merchants make the mistake of placing the condition at the root level of the Product entity. This breaks the syntax structure, causing parsers to reject the block entirely. According to Google Merchant Center guidelines, the itemCondition property must point to a specific URL-based schema enumeration member rather than a simple string.
Schema.org v30.0 requirements
The values you provide in your structured data must be mapped precisely. The table below outlines how standard retail conditions correspond to the exact Schema.org enumeration values recognized by search agents and e-commerce platforms:
| Retail Product Condition | Schema.org Enumeration Value | Merchant Center Map Value |
|---|---|---|
| Brand New, Unopened | https://schema.org/NewCondition | new |
| Restored to Like-New with Warranty | https://schema.org/RefurbishedCondition | refurbished |
| Secondhand, Shows Wear, No Warranty | https://schema.org/UsedCondition | used |
| Damaged, For Parts, Heavily Modified | https://schema.org/DamagedCondition | used |
By using these precise URLs, you allow AI systems to filter your catalog with perfect accuracy. When an AI agent processes a prompt such as "find me a certified refurbished coffee machine under $300," it queries its index for products containing the RefurbishedCondition enum. If your product pages emit that specific structured data point, your catalog becomes eligible for selection.
Implement tag-based dynamic condition overrides
To apply these rules dynamically across your Shopify store, you do not need to purchase expensive, bloated plugins. You can implement a clean, lightweight modification directly within your theme's Liquid files using your existing catalog organization.
Using Shopify product tags
The simplest method for managing this data without custom database fields is using native Shopify product tags. By applying specific tags to your inventory inside the Shopify admin panel, you can instruct your theme's structured data template to output the correct OfferItemCondition values on the fly.
For example, you can use the following taxonomy within your catalog administration:
condition:newcondition:refurbishedcondition:usedcondition:damaged
By keeping your tagging conventions strictly structured, you can prevent database bloat while giving your Liquid theme templates a clear signal to read when generating your JSON-LD block.
Applying the logic in liquid
To implement this logic, locate the liquid file where your theme outputs its main product schema. In standard themes, this is typically found in snippets/meta-tags.liquid, sections/main-product.liquid, or within a dedicated snippet named snippets/structured-data-product.liquid.
Locate the section of the code where the offers object is built. You can insert the following Liquid logic to dynamically assign the correct condition variable before the JSON-LD is generated:
{%- assign product_condition = 'https://schema.org/NewCondition' -%}
{%- for tag in product.tags -%}
{%- if tag == 'condition:refurbished' or tag == 'condition:Refurbished' -%}
{%- assign product_condition = 'https://schema.org/RefurbishedCondition' -%}
{%- elsif tag == 'condition:used' or tag == 'condition:Used' -%}
{%- assign product_condition = 'https://schema.org/UsedCondition' -%}
{%- elsif tag == 'condition:damaged' or tag == 'condition:Damaged' -%}
{%- assign product_condition = 'https://schema.org/DamagedCondition' -%}
{%- endif -%}
{%- endfor -%}
Once you have defined this variable at the top of your file, navigate down to the offers array within your JSON-LD block. Replace the hardcoded condition value or insert the property if it is missing:
"offers": [
{%- for variant in product.variants -%}
{
"@type": "Offer",
"sku": {{ variant.sku | json }},
"price": {{ variant.price | divided_by: 100.00 | json }},
"priceCurrency": {{ cart.currency.iso_code | json }},
"itemCondition": {{ product_condition | json }},
"availability": "https://schema.org/{% if variant.available %}InStock{% else %}OutOfStock{% endif %}",
"url": {{ request.origin | append: variant.url | json }}
}{% unless forloop.last %},{% endunless %}
{%- endfor -%}
]
This approach dynamically updates the condition values across your product variants. It ensures that the static HTML delivered to the AI web crawlers matches your physical inventory without relying on external javascript rendering.
Clean up conflicting app injections before validating
One of the most common issues we diagnose during AI Visibility for DTC Brands checkups is schema fragmentation. Simply writing correct liquid code is not enough if other software elements on your site are actively working against your implementation.
Finding duplicate product nodes
A major trap for Shopify merchants is trusting external applications to handle schema generation quietly in the background. Many product review platforms, custom shipping apps, and bundle utilities inject their own automated structured data blocks. If you are experiencing indexing issues, you can learn more about how bundling software interferes with discovery by reading our guide on why Shopify bundle apps break AI search and how to fix your schema.
When multiple applications inject independent Product or Offer nodes, you end up with fragmented data structures. An AI crawler scanning your page might see your custom theme schema declaring an item as RefurbishedCondition, while a third-party review app simultaneously outputs a secondary schema node stating that the same item is NewCondition. When faced with conflicting statements on the same page, crawlers will typically drop both nodes to protect the integrity of their indexes.
Testing the final output
To confirm your changes are clean and singular, run your product URL through the official Google Rich Results Test or the Schema Markup Validator. These tools parse your live page and highlight exactly how many independent schema nodes exist.
Make sure that your page displays exactly one parent Product node. All variant data, aggregate reviews, and custom condition markers must reside neatly nested inside this single, master JSON-LD block. If you discover that an external review widget is inserting a secondary, conflicting block, check the app's settings panel to disable its automated schema generation, or contact their technical support to prevent duplicate injections.
Validate your changes to secure AI citations
Once you have implemented your dynamic overrides and stripped out duplicate blocks, the final step is ensuring your modifications are fully readable by AI agents. You can check the overall health of your storefront's code using the technical tools available in our ecosystem.
Verify that your highest-traffic product pages are functioning correctly by checking their syntax. If you want to check if your entire catalog is ready for modern AI crawlers, run a diagnostic scan through the Pendium AI Site Audit tool. Our crawler mimics conversational agents to verify that your structural elements, price parameters, and product conditions are perfectly transparent. By correcting these micro-data signals, you can move your inventory out of the dark and directly into conversational shopping recommendations.
