Your products are now reachable by 880 million monthly AI users - but being in the index isn't the same as being recommended. AI shopping agents match buyer queries to product attributes. If those attributes don't exist in your feed, the agent skips your store entirely. This guide covers the six steps that close that gap, starting with the fields that matter most.

Step 1: Which Product Data Fields Do AI Shopping Agents Actually Read?

The fields AI shopping agents read first are the ones both major platforms require: a descriptive title, a complete description, a clean product image, price with an ISO 4217 currency code, stock availability, brand name, and a product URL that returns an HTTP 200. Get those right across every SKU before adding anything else.

That shared core set covers OpenAI's Agentic Commerce Protocol (ACP) and Google Merchant Center simultaneously - which means you can optimize for both from a single data source rather than running two separate projects. The key difference is GTIN. For Google, a missing or incorrect GTIN excludes a product from AI-mode competitive aggregation. For ACP, GTIN is listed as recommended rather than required, but it's still worth adding for every physical product because it's the strongest cross-platform matching signal you have.

Here's the gap most stores have: Shopify reports that most stores provide 5-8 structured product attributes while AI agents making purchase recommendations need 30 or more data points to confidently select a product. The six fields Shopify syndicates by default (title, description, options, images, price, availability) are a starting point, not a complete feed. And those defaults only help if the content inside them is structured for an agent, not a human browser.

Shopify's own data makes the opportunity visible: AI-referred orders grew nearly 13x year-over-year in Q1 2026, and AI-referred visitors convert at nearly 50% higher rates than organic search. Those numbers reflect stores that have done the field-level work, not the average store.

Our analysis of Shopify skincare brands found that 41% have product titles too branded for an AI agent to match to a buyer query. A title like "The Glow Serum" returns no signal to an agent trying to answer a buyer asking "which brightening serum is good for post-acne dark spots?" The agent needs the ingredient, the category, and the use case in the title itself - not in a brand's internal naming convention.

The practical starting point: audit your full SKU list against the shared core fields (title, description, image, price, availability, brand, product URL), then add GTIN for every physical product. That alone moves you ahead of most stores in your category.

Sources: Products (Feed Spec) - Agentic Commerce | OpenAI Developers - How To Add Merchant Listing Structured Data | Google Search Central - Shopify Catalog and product discovery for agentic storefronts - Agentic-Ready Product Data: How to Get It & the Cost of Inaction (2026) - Shopify - The State of AI Visibility for Shopify Skincare Brands (UpClick 2026 Report)

Step 2: How Do AI Agent Feed Requirements Differ Across Platforms?

ACP and Google Merchant Center share a core field set but diverge on three things: how the feed is delivered, how checkout eligibility is gated, and whether on-page schema is required.

Feed delivery works differently at each end. ACP expects a gzip-compressed file (.jsonl.gz, .csv.gz, or .xml.gz) pushed daily to an OpenAI-provided endpoint, plus intraday API updates for price and availability changes. Google ingests via XML, CSV, or the Content API and refreshes its Shopping Graph at roughly 2 billion listings per hour - which means stale price or availability data gets penalized fast on either side.

The biggest ACP-specific detail most stores miss: two Boolean flags called `is_eligible_search` and `is_eligible_checkout`. These gate which products appear in AI search results versus which can be purchased directly inside a conversation. If you omit them, the default is exclusion - your products don't show up. When `is_eligible_checkout` is set to true, two more fields become required: `seller_privacy_policy` and `seller_tos`. These aren't optional additions - they're the compliance layer the protocol needs before completing a transaction.

One field ACP has that Google's Merchant feed doesn't: `q_and_a`, which accepts structured FAQ pairs at the product level. This is where you can pre-answer the questions buyers ask AI about your product - ingredients, use-case fit, size guidance, compatibility. It's listed as recommended, not required, but it's one of the cleaner ways to improve recommendation rate at the content layer without a separate FAQ page.

On the Google side, Product schema.org markup on the product detail page is required independently of the Merchant Center feed. The critical rule: when the schema.org markup on the page contradicts your feed data (different price, different availability, different description), Google deprioritizes both. Keep them synchronized from the same data source.

Google's April 2026 spec update added three new fields worth knowing: `handling_cutoff_time` and `minimum_order_value` (both at product level, effective April 14 2026), and `video_link` (serving begins June 30 2026). The minimum image resolution was raised to 500x500 pixels, with enforcement starting January 31 2027 and warning flags appearing now. These aren't urgent today, but they will matter in your next audit cycle.

The practical implication: run your product data from a single source of truth, then output it to both platforms. Don't maintain two separate product databases if you can avoid it - divergence between them is where most feed errors start.

Sources: Products (Feed Spec) - Agentic Commerce | OpenAI Developers - Merchant Center product data specification update 2026 - Google Merchant Center Help - How To Add Merchant Listing Structured Data | Google Search Central - Agentic Commerce Protocol | OpenAI Developers

> Further reading: How to Get Your Products Recommended in ChatGPT Shopping

Step 3: What Does a Real Product Data Fix Actually Look Like?

The fastest measurable change comes from two things: rewriting product titles to a descriptive formula, and completing GTIN fields across your catalog. Everything else builds on top of those two.

Here's what that looks like in practice. When we rebuilt the Google Merchant feed for Circadian - a Shopify brand in the sleep and wellness space - we replaced branded product names with category-first, AI-readable titles and added custom metafields structured for shopping-agent parsing. The result: AI-referred shoppers converted at roughly 7x the rate of paid search clicks. The engagement returned 3.85x profit compared to 0.8x for paid ads on the same SKUs. The products hadn't changed. The titles and feed structure had.

The title issue is more common than most founders realize. Our analysis found that 41% of Shopify stores have product titles too branded for an AI agent to match to buyer queries. The agent is trying to answer a specific buyer question - it isn't browsing a catalog. A title like "The Glow Serum" tells it nothing. The same product titled "Niacinamide 10% Brightening Serum for Post-Acne Dark Spots" tells it the active ingredient, the concentration, the category, and the use case. That's a matchable product.

The formula we use: [Key ingredient or key attribute] + [product category] + [use case or skin/body concern]. Applied to a few common examples:

  • "Daily Moisturizer" becomes "Ceramide + Hyaluronic Acid Moisturizer for Dry, Sensitive Skin"
  • "Sun Shield" becomes "Mineral SPF 50 Sunscreen for Oily, Acne-Prone Skin, No White Cast"

Notice what changed: no brand name, no internal product code, no marketing copy. Literal, descriptive language that maps to how buyers phrase their questions when asking AI for a recommendation.

When we hand brands the tools to work through this independently, the four starting points we walk them through are:

1. Install the Shopify Knowledge Base app (Apps - search "Shopify Knowledge Base") - roughly 2-4 hours setup. This lets AI platforms use your store's FAQ answers when buyers ask about your products. 2. Enrich your Catalog metafields with Ingredients, Skin type, and Concern (Settings - Custom data) - roughly 1 day across a catalog. 3. Allow AI crawlers in robots.txt (Themes - Edit code - robots.txt.liquid) - roughly 30 minutes. 4. Rewrite product titles to the [ingredient %] + [category] + [use case] formula - 1-2 days depending on catalog size.

These are exactly the steps we run in the first week of any engagement. If you want to work through them independently first, start there.

Sources: Circadian Case Study - The State of AI Visibility for Shopify Skincare Brands (UpClick 2026 Report) - Agentic-Ready Product Data: How to Get It & the Cost of Inaction (2026) - Shopify

Step 4: Which Tools Help You Prepare Your Catalog for AI Agent Discovery?

No single tool covers both ACP and Google Merchant Center comprehensively right now. The practical setup for most stores is a two-tool stack, with a third app for FAQ enrichment. Here's what each does and where each stops.

For Google Merchant Center feed management, Simprosys is the most reviewed option on the Shopify App Store - over 4,000 reviews, a 4.9 rating, starting from $4.99 per month as of early 2026. It handles feed submission to Google Merchant Center and structured data enrichment on product pages. It's Google-centric, not ACP-native, so it won't handle your OpenAI feed submission or the ACP Boolean flags.

For Shopify-native agentic readiness, two options are worth knowing:

  • [AgentReady](https://apps.shopify.com/agentready-ucp-catalog-audit) is purpose-built for AI agent discoverability. It scans your catalog for what it calls "Agent Invisibility" risks - products with missing UPIDs, unstructured metafields, or incomplete variant data - and syncs the corrected feed to Shopify's Global Catalog. It's the closest thing to an ACP-native tool available on the App Store as of this writing.
  • The Shopify Knowledge Base app lets you review and customize the FAQ answers that AI platforms pull when buyers ask questions about your store - questions like "does this brand ship internationally" or "what's the return policy". These answers feed into the `q_and_a` layer that ACP supports at the product level.

For developers building catalog automation: the Shopify AI Toolkit is an official developer plugin that gives AI coding environments direct access to Shopify's documentation, API schemas, and code validators. It's built for technical teams building custom feed pipelines, not for non-technical operators.

Recommended stack for a store with 2,000 SKUs: Simprosys for Google Merchant Center, AgentReady or Shopify's native Catalog Mapping for ACP and AI channel readiness, and the Knowledge Base app for FAQ enrichment. That covers the three layers - feed submission, field enrichment, and conversational content - that together determine whether an agent recommends your product or your competitor's.

One honest note: tools show you gaps and manage submission. They don't rewrite your product titles, fill in missing GTIN data across 2,000 SKUs, or build out the metafield structure that variant grouping requires. That's the work that takes time. For brands running larger catalogs or wanting faster results, the Sprint ($1,500, 2 weeks) covers the title rewrites, GTIN completion, schema setup, and measurement in a fixed-scope engagement - the tools can then maintain what we build.

Sources: AgentReady - Shopify App Store - Shopify Catalog optimizing products - Shopify Catalog and product discovery for agentic storefronts

> Further reading: ChatGPT's 4% Storefront Fee vs Free Organic AEO

Step 5: How Do You Allow AI Agents to Actually Find Your Store?

If AI crawlers are blocked in your robots.txt, none of the product data work in the previous four steps matters - the crawlers can't reach the store. Check this before anything else.

Our audit of Shopify stores found that 6% silently block at least one major AI crawler. These aren't stores that intentionally opted out - they're stores where a theme update, a security plugin, or a default Disallow rule added a block that no one noticed. The crawlers affected most often are GPTBot, OAI-SearchBot, and PerplexityBot.

Checking is straightforward: go to yourdomain.com/robots.txt and look for `Disallow: /` rules under any of these user-agent blocks: GPTBot, OAI-SearchBot, ChatGPT-User, PerplexityBot, Google-Extended, or ClaudeBot. If any of them show a blanket disallow, they can't crawl your store. In Shopify, the fix is Themes - Edit code - robots.txt.liquid. Add `Allow: /` under each agent's user-agent block.

Here's the full allow-kit to paste in:

```text User-agent: GPTBot Allow: /

User-agent: OAI-SearchBot Allow: /

User-agent: ChatGPT-User Allow: /

User-agent: PerplexityBot Allow: /

User-agent: Google-Extended Allow: /

User-agent: ClaudeBot Allow: / ```

OpenAI operates three distinct crawlers with different jobs: GPTBot is used for AI training and general indexing, OAI-SearchBot handles citations in AI search results, and ChatGPT-User crawls pages live during a conversation when a user shares a link. Each needs explicit access - allowlisting only GPTBot doesn't cover OAI-SearchBot for citation eligibility. The full list is documented at developers.openai.com/api/docs/bots.

On the measurement side: once crawlers can reach your store and your products start appearing in AI-referred traffic, be aware that GA4 significantly undercounts it. In our Circadian engagement, GA4 reported one AI-referred order while post-purchase survey data showed ten - a 9x undercount. Set up UTM parameters on your AI channel links and add a post-purchase survey question to get a real read on how much AI traffic you're actually receiving.

For Shopify merchants specifically: Agentic Storefronts shipped on March 24 2026 and auto-enrolled 5.6 million merchants, making 880 million monthly AI users potentially reachable. But auto-enrollment means your products are in the index, not that they're being recommended. The crawler access fix and the field enrichment from the earlier steps are both required before that enrollment translates to actual sales.

Sources: OpenAI Bots documentation (GPTBot, OAI-SearchBot, ChatGPT-User) - Shopify Catalog and product discovery for agentic storefronts - The State of AI Visibility for Shopify Skincare Brands (UpClick 2026 Report) - Circadian Case Study

Step 6: How Do You Add Variant Grouping and Social Proof Fields That AI Agents Use to Filter?

AI agents filter products by specific attributes. If a field doesn't exist in your feed, the agent removes your product from its recommendation set before the buyer ever sees it. Variant grouping and social proof fields are the two layers most stores skip - and they're often what separates a recommended product from one that never surfaces.

Variant grouping is the issue of how many products an agent thinks you have. ACP uses two fields for this: `group_id` (which connects variants to a parent record) and `listing_has_variations` (a Boolean that tells the agent the product comes in sizes, shades, or other options). Without these, a store with 500 parent products and four variants each looks like 2,000 unrelated, competing entries in the index. An agent trying to find "vegan fragrance-free moisturizer in size XL" gets nothing returned if size, vegan status, and fragrance-free status don't appear anywhere in the title, description, tags, or metafields - and if the 2,000 variants aren't grouped, the agent has no way to know they're the same product.

Shopify's native variant grouping handles this automatically for Shopify-to-Shopify channels. For ACP and other AI channels, Catalog Mapping (Settings - Custom data, then Catalog Mapping) syncs your custom metafields and metaobjects to the AI discovery feed. That's where you add the attributes agents use to filter: skin type, concern, ingredients, vegan/cruelty-free status, size, compatibility notes.

Social proof fields are a second layer. ACP supports `star_rating`, `review_count`, and `q_and_a` as structured fields at the product level. These are listed as recommended rather than required - but agents use them at the ranking layer, comparing products that are otherwise equal on category and use case. A product with structured star_rating and review_count data is easier for an agent to rank confidently than one with no social proof in the feed. Google's Merchant Listing markup also lists `aggregateRating`, `shippingDetails`, and `hasMerchantReturnPolicy` as strongly recommended for the same reason.

One technical point worth flagging: Shopify's agentic readiness guidance specifically notes that JavaScript rendering dependencies hide product data from AI. If key product attributes (ingredients, size options, variant details) only appear after a JavaScript interaction - a tab click, an accordion open, a color swatch selection - they're invisible to crawlers. The structured data needs to be in the page source, not injected after load.

The principle across all of this is simple: listing is automatic for enrolled Shopify merchants. Ranking and recommendation are not. The field-level work - variant grouping, social proof fields, attribute metafields, JS dependency removal - is what moves a product from listed to recommended. Run your free AI Visibility Score to see exactly where your catalog stands on this layer right now.

Sources: Products (Feed Spec) - Agentic Commerce | OpenAI Developers - How To Add Merchant Listing Structured Data | Google Search Central - Shopify Catalog and product discovery for agentic storefronts - Agentic-Ready Product Data: How to Get It & the Cost of Inaction (2026) - Shopify

Conclusion

The six steps here build on each other in order: start with the shared core fields both major platforms require, then understand how ACP and Google Merchant Center diverge on feed delivery and schema, then fix your product titles and complete GTIN fields, then set up the right tools, then confirm crawler access, then add the variant grouping and social proof fields that determine recommendation rate. None of these steps is technically complicated. Most can be done in Shopify without a developer. The constraint is usually time and knowing which layer to fix first.

If you want to know where your catalog stands before you start, run a free AI Visibility Score at UpClick Labs. It's a 5-minute check against your URL - you'll get your AI visibility score, your maturity level, and your single highest-priority gap. No cost, no commitment. If you want it done rather than DIY'd, the Sprint covers all six steps in two weeks at a fixed cost. Start with the score and the six-step path gets a lot clearer.