Selling on ChatGPT: the complete guide to ChatGPT Shopping and the Agentic Commerce Protocol (2026)

What is ChatGPT Shopping?

ChatGPT Shopping is the umbrella term for the buying experiences built into ChatGPT. When someone describes a need, "a waterproof jacket for hiking in Scotland in October", "a gift under $50 for someone who's into coffee", ChatGPT can answer with rich product cards showing image, price, merchant and availability, rather than a plain list of links.

Three distinct pieces sit under that name, and conflating them is the first mistake merchants make:

• Organic product discovery: ChatGPT surfaces products inside its answers, with no payment from the merchant.
• Instant Checkout: the shopper completes the purchase without leaving the conversation, on eligible products from eligible merchants.
• ChatGPT Ads: a paid placement, separate from the model's answer, covered in our ChatGPT Ads guide.

This guide is about the first two. Neither can be bought, they're earned with clean product data and a technical integration.

How does ChatGPT find products today?

Here's the part most merchants miss: you may already be showing up in ChatGPT, described by data you don't control. OpenAI's documentation states that the list of merchants offering a product is generated from merchant and product metadata coming either from third-party providers (aggregators, comparison engines, catalog databases) or directly from merchants.

The gap between those two paths is wide. Through a third party, your prices can be stale, your stock wrong, your product title approximate, and you have no direct way to correct any of it. Through a product feed sent to OpenAI, you become the source of truth for your own catalog.

One practical consequence worth knowing: the price shown in ChatGPT's initial answer typically reflects the first merchant listed, which is not necessarily the lowest price available. ChatGPT then works to highlight the lowest-priced option it knows about on the product detail page and in the merchant ranking.

What is the Agentic Commerce Protocol (ACP)?

The Agentic Commerce Protocol is an open standard co-developed by OpenAI and Stripe. It acts as the connective layer between merchants and ChatGPT users, defining how an AI agent discovers a catalog, builds a cart, resolves tax and shipping, and triggers payment, while orders, payments and compliance stay on the merchant's existing commerce stack.

It breaks down into three specifications:

• Product Feed Spec, how you hand over your catalog.
• Agentic Checkout Spec, how the agent talks to your order system.
• Delegated Payment Spec, how payment reaches your payment provider.

With a single integration, a merchant can sell through AI agents while keeping control over what is sold, how the brand appears, and how orders are fulfilled.

Why an open protocol changes the calculation

"Open" isn't marketing language here. It's a verifiable property with two direct consequences for merchants.

You don't have to use Stripe. The protocol was co-developed with Stripe, but merchants who aren't on Stripe can adopt it with their existing payment providers. The spec is explicit: OpenAI is not the merchant of record, and the merchant processes payments exactly as they would for any other digital transaction, through their own PSP.

You're not building for a single agent. ACP is designed to work across AI agents, not only ChatGPT. That's what separates this investment from a proprietary integration: the work you put into cleaning up your catalog and standardizing checkout pays off beyond one platform. It's why we treat this as a priority project even for merchants who don't yet have Instant Checkout access.

The product feed: formats, delivery and refresh cadence

The product feed is how merchants share structured product data with OpenAI, so ChatGPT can surface their products in search and shopping experiences. You provide a secure, regularly refreshed feed containing identifiers, descriptions, pricing, inventory, media and fulfillment options.

Formats. The current developer spec documents UTF-8 flat files: tab-delimited .txt or .tsv, comma-delimited .csv, and their gzip-compressed variants (.tsv.gz, .csv.gz, .txt.gz). One header row with canonical lowercase, underscore-separated field names, then one product or variant per row. Merchant-facing documentation also refers to TSV, CSV, XML and JSON depending on the exchange method, check the expected format in the spec at implementation time, this is one of the parts that still moves.

Two delivery modes. File upload pushes the full catalog on a regular schedule: you overwrite the same file (or the same shard set) with your latest snapshot. The API sends updates throughout the day via upserts, and promotions data is available through the API only. OpenAI's own recommendation is to combine both: the full feed once a day by file upload, then intraday updates through the API.

This is the single most underestimated setting in the whole system. A catalog refreshed weekly will inevitably serve wrong prices and show sold-out items as available, and in an experience where the shopper can buy immediately, bad data doesn't just degrade the experience, it breaks the transaction.

Product feed fields: required, conditional, recommended

For a non-Ads feed, the spec sorts fields into three tiers. The field names below are those in the developer spec at the time of writing, re-check them before you build, OpenAI keeps iterating on them.

Required (10 fields): item_id, title, description, brand, url, image_url, price, availability, is_eligible_search, is_eligible_checkout.

Conditional: gtin or mpn is required unless identifier_exists is set to no; availability_date is required when availability is preorder or backorder; seller policies (seller_privacy_policy, seller_tos) are required if checkout is enabled.

Recommended: condition, product_category, material, dimensions, weight, age_group for item detail; additional_image_urls, video_url, model_3d_url for media; sale_price with its start and end dates for pricing; group_id, variant_dict, color, size, size_system, gender for variants; shipping, pickup_method, is_digital for fulfillment; review_count, star_rating, q_and_a, reviews for social proof; accepts_returns and return_deadline_in_days for returns.

Two flags deserve special attention. is_eligible_search controls whether the product appears in ChatGPT search at all. is_eligible_checkout enables direct purchase inside the conversation, and it depends on is_eligible_search: a product that isn't search-eligible can't be bought. A technically valid feed with these two flags set wrong produces an invisible catalog.

How ChatGPT decides which products and which merchants to show

Nobody can answer this with an exact formula, and any content claiming otherwise should be treated with suspicion. What OpenAI's documentation does say: merchant ranking takes into account factors like availability, price, quality, and whether the merchant is the maker or primary seller of the item. OpenAI adds that it expects these criteria to evolve, including toward more personalized merchant rankings based on user preferences.

Four operational readings of that sentence:

• Availability, wrong stock data costs you ranking, not just the sale. Feed freshness becomes a visibility factor.
• Price, competitiveness against other merchants selling the same item weighs directly, which makes the exercise closer to a comparison engine than to classic search.
• Quality, deliberately broad on OpenAI's side, but in practice it maps to how complete and accurate your product data is, plus review signals when you supply them.
• Maker or primary seller, a brand selling its own product starts with a structural advantage over a reseller. Excellent news for direct-to-consumer brands, a real constraint for multi-brand retailers.

Note that these are merchant-ranking factors, which is a separate question from how ChatGPT picks the relevant products for a given request in the first place. That second step comes down to interpreting a need expressed in natural language, which is where the semantic richness of your titles, descriptions and attributes does the work.

Instant Checkout: what it is and where it actually works

Instant Checkout lets users buy directly inside the chat: on an eligible product, a buy button appears, the shopper confirms the order, shipping address and payment method, and never leaves ChatGPT.

The current footprint, stated plainly: the feature is available to approved partners. US ChatGPT Plus, Pro and Free users can buy from US Etsy sellers in chat, and Shopify merchants, over a million of them, including brands like Glossier, SKIMS, Spanx and Vuori, are the announced next wave.

Put bluntly: if you're a European merchant, Instant Checkout isn't open to you yet, and anyone offering to "switch it on today" is selling something other than what they're describing. What is open to you right now is the groundwork, catalog quality, product identifiers, data structure, and applying for product feed onboarding, which is itself limited to approved partners and goes through OpenAI's merchant application form.

That's precisely what makes this window interesting. Merchants who clean up their catalog while access is still restricted will be eligible on day one; merchants who discover the topic on launch day will have six months of data remediation ahead of them.

The two technical specs: Agentic Checkout and Delegated Payment

Agentic Checkout Spec. The merchant exposes five REST endpoints: create a checkout session, update it (items, shipping, discounts), complete it with a payment method, cancel it, and read its current state. Every response must return a full cart state, items, pricing, taxes and fees, shipping, discounts, totals, status. The merchant receives buyer information (name, email, phone), fulfillment and billing addresses, quantities and selections, a payment token, never full card data, and tracks the order lifecycle through webhooks (created, confirmed, shipped, fulfilled, canceled).

Delegated Payment Spec. The shopper picks a payment method in ChatGPT; OpenAI passes the payment details to the merchant's payment service provider; the PSP returns a single-use, allowance-constrained payment token outside PCI scope; OpenAI forwards that token when completing the order. One point that matters for scoping the project: integrating directly against this spec is only for PSPs or PCI DSS Level 1 merchants running their own vaults. For the overwhelming majority of merchants, this part is handled by the payment provider, not by the in-house engineering team.

The structural takeaway: the merchant retains ownership of the order and the customer relationship, and stays the merchant of record.

What merchants control, and what they don't

An honest read of the protocol gives a fairly clean split.

You control: which products are exposed and which aren't (via the eligibility flags), the prices and availability you transmit, descriptive content and media, promotions, selling and return policies, order fulfillment and logistics, payment processing through your own PSP, the post-purchase customer relationship, and your status as merchant of record.

You don't control: whether you appear in any given answer, your position in the merchant ranking, the exact wording ChatGPT uses to describe your product, the competitors displayed alongside you, or the timeline for Instant Checkout opening in your market.

Structurally, that's the same asymmetry as organic search: you control the quality of the input, not the output decision. The difference is that the data you hand over here is far more standardized than a web page, which makes optimization more mechanical and less speculative.

Shopify, WooCommerce, PrestaShop, Magento: where each platform actually stands

A lot of articles claim "native support" that doesn't exist in the documentation. Here's what's verifiable and what isn't.

Shopify is the furthest along: OpenAI announced Shopify merchants coming to Instant Checkout, covering over a million stores. It's the shortest path to eligibility, but access still depends on OpenAI approval, not on flipping a switch in the store admin.

WooCommerce, PrestaShop and Magento / Adobe Commerce: as of today, OpenAI's official documentation describes no native integration for any of them. Technically nothing prevents it, ACP is an open protocol built on REST endpoints and a flat feed, so it's implementable on any stack, including a fully custom store. But practically, it means either bespoke development or a third-party module or connector, with the usual caution about who maintains that layer.

Our recommendation for those three platforms: don't start with checkout. Start with the product feed. It's the part that delivers value immediately, depends on no third-party module, and stays useful regardless of which connector you eventually pick.

Why your product doesn't show up in ChatGPT

The causes fall into three families, in order of frequency.

1. You have no feed, and third-party data is working against you. Without a direct feed, ChatGPT relies on metadata from third-party providers. If your product is misidentified, miscategorized or simply absent there, you don't exist, and nothing alerts you to it.

2. Your feed exists but fails on specific rules. is_eligible_search set to false, missing gtin/mpn without identifier_exists declared, no availability_date on preorders, seller policies missing while checkout is enabled, non-UTF-8 encoding, non-canonical column headers. These errors silently drop entire rows.

3. You're eligible but poorly ranked. Uncompetitive pricing against other merchants on the same item, stock marked unavailable, incomplete data, reseller status against the maker. You're in the system, just never in the top three lines.

There's a fourth, non-technical cause: the shopper's request simply doesn't match how your product is described. That's where the semantic work covered in our ChatGPT SEO guide meets the catalog work.

The data-quality problems that actually block catalogs

Across the catalogs we review, five problems come up again and again and account for most of the blockage.

Missing product identifiers. The GTIN (EAN, UPC or ISBN depending on the category) is the key that lets your offer be matched against other merchants selling the same item. Without it, and without an MPN or a properly declared identifier_exists, your product becomes an unmatchable object. This is blocker number one, and it's widespread, particularly among brands that manufacture their own references and never needed a barcode for anything else.

Stale prices and stock. A daily feed with no intraday updates is enough to break an experience where purchase is immediate. Freshness here isn't a nice-to-have, it's a ranking factor.

Weak images. Busy backgrounds, cropped products, low resolution, watermarks, a single shot with no alternate view. In an interface where the product card is a thumbnail and three lines of text, the image carries a disproportionate share of the decision.

Thin descriptions. A two-line description that restates the title gives the model nothing to work with when deciding which need the product answers. Attributes like material, dimensions, weight, age group and use case aren't decoration, they're the hooks a natural-language request latches onto.

Badly modeled variants. Colors and sizes split into standalone products with no group_id, or bundled together with no distinguishing attributes. Either way, the agent can't tell what to offer a shopper asking for a specific size.

ChatGPT Shopping vs Google Shopping: what genuinely differs

A merchant already running Google Shopping starts with a real head start: the product feed discipline is the same, and many fields overlap. But three fundamental differences change the strategy, and the table below summarizes them.

The biggest one: on Google Shopping, visibility is primarily bought per click through Merchant Center and Google Ads. On ChatGPT Shopping, organic discovery isn't a purchased placement, it depends on data quality and freshness, price, and primary-seller status. The budget lever exists separately, as ChatGPT Ads, but it doesn't substitute for organic merchant ranking.

Second difference: checkout. Google mostly sends traffic to the merchant's site. ChatGPT, on eligible products, keeps the transaction inside the conversation, which moves the conversion-rate question away from your product page and onto your product feed.

Third difference: maturity. Merchant Center has been stable for over fifteen years, with settled documentation and thorough diagnostics. ACP is less than a year old and its spec is still moving. That means more opportunity, but also an obligation to re-read the documentation before every implementation.

Organic shopping, Instant Checkout and ChatGPT Ads are three different things

These three get blended together constantly in the available content, including by vendors selling services around them. They follow different logics and move on different timelines.

Organic shopping isn't paid for: it's earned with a clean product feed and competitive data. It's open to any approved merchant, and it's the prerequisite for everything else.

Instant Checkout adds the transaction inside the conversation. Today it's limited to approved partners and a narrow geographic footprint, and it requires implementing the Agentic Checkout Spec, a genuine engineering project.

ChatGPT Ads buys a sponsored placement, distinct from the model's answer, with its own auction and targeting system. OpenAI also offers product-feed-driven ad campaigns, with a dedicated field in the spec (is_ads_eligible). Note the synergy: the same feed work serves all three.

That's the decisive argument for starting with the catalog rather than with checkout. It's the only workstream whose payoff holds regardless of how and when the other pieces open up.

Merchant checklist: getting your catalog ready for ChatGPT and ACP

• Measure identifier coverage first: what share of your catalog carries a valid gtin or mpn, with identifier_exists correctly declared on the rest. This comes before everything else.
• Measure real price and stock freshness: when did the last sync actually run, and how many SKUs currently show as available when they aren't.
• Audit your images: resolution, background, no watermarks, and at least one alternate view via additional_image_urls.
• Take the shortest descriptions in your catalog and fill in the structured attributes (product_category, material, dimensions, weight, age_group) instead of padding the marketing copy.
• Check how variants are modeled: consistent group_id, color, size and size_system across every product family.
• Set is_eligible_search and is_eligible_checkout deliberately, and remember the second depends on the first.
• Prepare your seller policies (seller_privacy_policy, seller_tos): they're required as soon as checkout is enabled.
• Plan the delivery architecture: full feed once daily by upload, intraday updates via API, promotions via API only.
• If you're on WooCommerce, PrestaShop or Magento, don't gate your timeline on a module shipping: the product feed can be built today.
• Apply for OpenAI's merchant onboarding and track Instant Checkout's geographic expansion.
• Don't skip the editorial side: the pages that explain your products also feed ChatGPT's answers outside a buying context, as covered in our ChatGPT SEO guide.

We're currently building an AI Shopping Feed Auditor at Ready2GEO: a tool that checks a catalog against all of these requirements, identifier coverage, missing required fields, eligibility flags, image and description quality, and returns the list of blocking SKUs. It is in development and not yet available; it will join our tools suite once it ships. In the meantime, the checklist above works perfectly well by hand on a catalog export.