ChatGPT product feed: the complete merchant guide

Tarun Kapoor Published July 10 · Updated August 7, 2026 20 min read

A ChatGPT product feed is a structured export of your catalog, delivered to OpenAI, that makes your products visible inside ChatGPT. As of mid-2026 there are actually two feed systems — the organic commerce feed and the Ads Manager feed — powering three surfaces: ChatGPT Shopping results, Shopping Research buyer's guides, and product-feed ad campaigns. Almost every guide on the internet conflates them. This one doesn't. It covers the current spec and eligibility flags, SFTP and API delivery, the three access paths (including Shopify's default-on auto-integration), how organic ranking works, and an action plan for each merchant type — every load-bearing claim sourced to OpenAI's own documentation, checked July 13, 2026.

What a ChatGPT product feed is — and why it suddenly matters

The feed is how your catalog gets into ChatGPT's commerce experiences: a structured export of your products, with fields defined by OpenAI's products spec, delivered to OpenAI on a schedule. If ChatGPT is going to recommend, compare, or link to your products, this data is where it learns what you sell, what it costs, and whether it's available. It is infrastructure, not advertising — the catalog layer that everything else sits on.

The "why now" is scale meeting intent. ChatGPT reached 900 million weekly active users (OpenAI, February 2026), and shopping behavior inside it is no longer novelty traffic: Adobe Analytics measured AI-referred traffic to US retail sites converting 31% better than other sources during the 2025 holidays, and by May 2026 the gap was reported at 54% — a full reversal from early 2025, when AI referrals converted worse. Volume is still small relative to Google (fractions of a percent of total traffic for most merchants), but it is the highest-intent small channel in ecommerce, and the feed is its admission ticket.

Two feeds, three surfaces — the map nobody gives you

Here is the single most important thing to understand, and the thing most articles get wrong: OpenAI currently runs two separate product feed systems, and during the ads beta they do not feed each other.

The practical consequence: a merchant who wants both organic visibility and feed-based ads needs both pipelines. Uploading a catalog to Ads Manager does nothing for your presence in organic Shopping results today, and an approved commerce feed does not create ad campaigns. Both use the same base schema — OpenAI's Ads product feeds guide confirms ads feeds are "the same base schema" plus the ads-eligibility flag — so build the export once and ship it twice.

The spec: 79 fields, 19 required, three flags that decide everything

The current products spec defines 79 fields, of which 19 are required (including conditionals). The required core:

The three OpenAI flags are the control panel for where each product can appear — they change nothing on your own site, only ChatGPT's permissions:

• is_eligible_search — can the product surface in ChatGPT search results at all. This is the master switch.
• is_eligible_checkout — can the product be purchased directly inside ChatGPT. Requires is_eligible_search=true, plus seller privacy-policy and terms URLs.
• is_ads_eligible — can the product be processed for ChatGPT ads. The legacy alias is_eligible_ads is still accepted; is_ads_enabled is not a real field and is silently ignored — a nasty trap OpenAI explicitly warns about in the ads guide.

Two spec-drift warnings, because most ranking articles were written against the 2025 spec: the old flag names enable_search and enable_checkout are gone, and XML was never a supported upload format despite what several vendor pages claim. Beyond the required core, the highest-leverage optional fields are the ones that feed ranking and answer quality: gtin/mpn identifiers, variant modeling (group_id, variant_dict), sale_price, q_and_a, reviews, star_rating/review_count, and two signals unique to OpenAI's spec — popularity_score and return_rate, which let you hand ChatGPT performance data it can't infer from a crawl. There's also ads_metadata, an object for custom key-values like bidding_tier or product_line — meaningless organically, but the backbone of ad-group structure in feed campaigns (below).

Delivery: snapshot pipeline + API upserts

The file-upload model is a full snapshot: a complete catalog export, treated as the source of truth, pushed over SFTP on a predictable cadence of at least daily. Every publish says this is my entire catalog; anything not in here does not exist.

What's new in 2026 — and what makes the old "snapshot-only, no deltas" description obsolete — is the REST API layer: a Feeds, Products, and Promotions API that supports upserting partial changes. OpenAI's own recommended architecture is hybrid: full feed once a day via file upload, updates throughout the day via the API. Small catalogs can run API-only. And note the quiet exclusive: promotions data can only be delivered via the API — if you run frequent price promotions, the API isn't optional.

This split maps cleanly onto team ownership: the nightly snapshot is a warehouse job (a dbt or Spark export of the catalog table), while API upserts belong to whatever system already fires price and inventory change events. The three ingestion failure modes OpenAI warns about are unchanged: missing required fields, outdated field names, and malformed values — and its recommended rollout is still phased: a ~100-item sample with every required field populated, then a QA'd first full snapshot, then steady-state automation.

The three access paths — which door is yours

1. Shopify merchants: you're already in (check the toggle)

OpenAI's shopping documentation states Shopify product data is integrated into ChatGPT through Shopify Catalog — "no additional work is required." Since Shopify launched agentic storefronts in late March 2026, eligible stores are discoverable in ChatGPT by default. Eligibility: the store serves US customers, products meet Shopify Catalog standards, the merchant has accepted the Agentic Storefronts supplemental terms, and policy pages (terms, privacy, returns) are completed. The control lives in Shopify admin under Sales channels → Agentic → ChatGPT. Your job isn't submission — it's data quality (titles, GTINs, attributes, reviews) and verifying the toggle reflects your intent, in either direction.

2. Everyone else, organic: apply for direct feed access

Direct commerce feeds are application-gated — OpenAI describes onboarding as "currently available to approved partners," with applications through its merchant program (chatgpt.com/merchants). After approval you receive SFTP credentials and validate a sample before pushing the full catalog. Vendor guides report the cycle typically runs one to two weeks; OpenAI itself commits to no timeline, so treat that as a plausible median, not a promise. Why bother when ChatGPT can crawl your site? Control and freshness: OpenAI positions the direct feed as the way to "ensure ChatGPT always reflects the most up-to-date information" — and AI-visibility vendor Profound reports that products backed by direct feeds overwhelmingly win the first-offer position when cited (a vendor stat, but directionally consistent with how every marketplace treats first-party data).

3. Retail advertisers: the Ads Manager feed

Separate program, separate door: in Ads Manager, Tools → Feeds → Create Feed generates SFTP connection details (password or SSH-key auth). Products are ads-eligible by default when created this way. Full campaign walkthrough below.

How ChatGPT ranks products — what OpenAI actually says

OpenAI is unusually explicit that organic product results are not ads: "selected independently by ChatGPT and are not ads, nor influenced by any OpenAI partnerships." Selection considers four things: the user's query and context (including Memory and custom instructions — ChatGPT will skip clown costumes for a user who said they dislike clowns, OpenAI's own example), structured metadata from first- and third-party providers, the model's prior response before search results arrive, and safety standards. Which factor dominates depends on the ask: name a $30 budget and price outranks everything else.

Three merchant-relevant subtleties from the same documentation:

• ChatGPT rewrites your listing. It may generate simplified titles and descriptions, model-generated labels like "Budget-friendly" or "Most popular" (not verified statements), and review summaries drawn from public sites. Your feed is input, not final copy — one more reason factual, attribute-dense descriptions beat marketing language.
• The price shown first isn't necessarily yours — or the lowest. The initial carousel price typically reflects the first listed merchant; the product detail page then works to surface the lowest-price option, sometimes labeled "Best price." Price-update delays are acknowledged by OpenAI, which is exactly why feed freshness (and API upserts) matter.
• Merchant ranking is its own contest. When a user taps a product, ChatGPT ranks the merchants offering it by availability, price, quality, and whether the seller is the maker or primary seller — with more personalization explicitly planned. Brands selling through resellers should decide who they want winning that box before ChatGPT decides for them.

For the broader organic-visibility play beyond product carousels — citations, brand mentions, entity building — see our guide to appearing in ChatGPT answers.

Shopping Research and the Agentic Commerce Protocol

Shopping Research (launched November 24, 2025) is the deep-research mode for buying decisions: users select products and hit "Research," ChatGPT asks clarifying questions, runs a multi-step discovery pass, and returns a personalized buyer's guide — plain-language tradeoffs, top picks with rationale, side-by-side comparisons, and merchant links. For considered purchases, this is where the decision gets made, and merchants who aren't in the data simply aren't in the guide. This is buyer-evaluation visibility in its purest form.

Two facts matter operationally. First, OpenAI names its sources: merchant product data provided through the Agentic Commerce Protocol (ACP), publicly available product information, and other retail sources — and it reads product pages directly, citing them. Second, OpenAI states plainly that some retailers block automated access and get skipped. OpenAI references an "allowlisting process" for merchants without spelling out its mechanics; in practice it resolves to two moves: join the merchant program (feed in via ACP) and make sure your robots.txt and bot protection (Cloudflare and friends) aren't blocking OpenAI's crawlers, especially OAI-SearchBot — which OpenAI says is used for search visibility, not model training.

ACP itself is worth knowing as a strategic marker: an open standard (Apache 2.0) co-developed by OpenAI and Stripe, versioned by date (latest stable 2026-04-17, adding cart, feed, orders, and auth), covering checkout and delegated payment as well as feeds. It's the "common language" layer for agent-to-merchant commerce — and it's bigger than OpenAI: it's how your catalog becomes agent-readable everywhere.

Product-feed ad campaigns — the retail advertiser's walkthrough

Feed campaigns came to Ads Manager in the June 2026 beta wave, and OpenAI told advertisers that ads created from product feeds "have been among the strongest-performing ads in our program to date" (it also relayed one global DTC brand doubling CTR and halving CPC after switching to feed ads — OpenAI's own unaudited example, so weight accordingly). Instead of hand-building ads per SKU, you connect the catalog and let the system select an eligible product when the ad serves — ad title and description are pulled directly from the feed. The mechanics, condensed from OpenAI's help documentation:

1. Create the feed: Ads Manager → Tools → Feeds → Create Feed. Ads Manager generates SFTP connection details; configure password or SSH-key auth from the feed row's menu.
2. Upload and validate: push the catalog (up to 2M products) and wait — processing takes minutes to hours and items come online gradually; the ad-group creation modal shows how many are ready.
3. Create the campaign: Campaigns tab → new campaign → type "Product feed". (Via the Ads API this is mode: product_feed — and it's locked at creation, like the budget type.)
4. Build the ad group: select the feed and apply product filters to define which products serve; Ads Manager shows the passing product count. When built-in filters aren't enough, this is what ads_metadata is for — pre-compute your segmentation (bidding_tier, product_line, margin bands) in the feed, then filter on it. Structure lives in your data pipeline now, not the ads UI. In a decade of running shopping campaigns for retail clients, the pattern has never changed: account structure decided in the feed beats structure improvised in the interface — and here OpenAI has made that literal.
5. Create the ad template: one template per ad group, currently limited to selecting your image field; titles and descriptions flow from the feed. Preview against sample products before launch.
6. Review and launch: confirm feed, product count, creative previews, budget, bid, and targeting — including context hints, which do for conversation matching what your filters do for product matching.
7. Measure at product level: the Insights API supports a product segment — impressions and clicks per item_id. Feed campaigns without product-segmented reporting are flying blind; this is where you find the 5% of SKUs earning 80% of spend.

Beta constraints worth restating: one feed connection per ad account; feed products serve ads only (no organic spillover during beta — date-stamped July 2026, and exactly the kind of restriction OpenAI may lift quietly); and reported-but-unofficial numbers circulating in trade coverage (1,000-product minimums, ~$25 daily budgets, ~$3 bids) appear nowhere in OpenAI's documentation — the only official capacity figure is 2 million products per feed. For whether the channel's economics clear for you at all, see our cost breakdown and small-business fit guide.

Conversion bidding and the carousel: what changed in August 2026

Two changes landed together that materially alter how a feed campaign is worth running, and both are worth acting on rather than noting.

Feed campaigns can now optimize toward conversions

Conversion-optimized cost-per-click (oCPC) campaigns are now available in beta for product feed campaigns. oCPC is in open beta for both standard and product-feed campaigns, using the same campaign and ad-group endpoints. Until this release, feed campaigns ran on click or impression models only — which meant a retailer could buy catalog clicks efficiently but could not ask the auction to bias toward the clicks that actually became orders.

The beta is scoped:

• Click-billed campaigns only — you still pay per valid click, the optimization changes which clicks you get.
• Fixed or manual bidding — automated bid strategies are not in this initial release.
• A positive conversion bid cap is required — it must be a real value above zero.

Through the Ads API it is the same POST /campaigns endpoint you already use, with three fields doing the work: mode: "product_feed", the linked product_feed_id, and bidding_type: "conversions" alongside conversion_event_setting_ids. Create the child ad group with billing_event_type: "click" — and note that max_bid_micros on that ad group is your CPA bid, not a click bid.

One feed-specific detail worth knowing before you build: the ad group automatically inherits the campaign's product feed. You do not repeat product_feed_id on it. Include product_set only when you actually want product filters, and when you do, its product_feed_id must match the campaign's feed — a mismatch here is a common and confusing setup failure.

The prerequisite most merchants underestimate is on their own side of the wire: conversion optimization needs working conversion tracking and exactly one eligible active standard event, typically order_created. If your pixel or Conversions API implementation is incomplete, oCPC will not save the campaign — it will simply have less signal to work with. Our conversion tracking guide is the prerequisite read, and the full bidding mechanics are in the oCPC guide.

There is a sharper edge here worth stating: conversion optimization amplifies your feed's economics rather than correcting them. A feed carrying stale availability flags, wrong prices, or thin titles will now spend into its own errors faster. Fix the feed first, then turn on conversion bidding — in that order.

The multi-product carousel

OpenAI has started testing a carousel format for product feed ads that shows multiple products from one advertiser in a single unit. This is the first meaningful departure from the single-product sponsored card, and it changes what a good feed looks like.

A single-product unit rewards having one excellent hero item. A carousel rewards coherent sets — several products that make sense next to each other, with consistent image treatment, comparable price points, and titles that read as a range rather than a jumble. If your catalog imagery is inconsistent across SKUs, that inconsistency was previously invisible and is now displayed side by side in one unit.

Practical preparation while it is still a test: audit image consistency within your best-selling product sets, make sure titles are readable at small size without the brand name eating the character budget, and check that the products likely to be grouped together are all actually in stock. Availability errors are more conspicuous in a carousel, because the neighbouring products prove the unit was served for a live query.

Where checkout stands (July 2026) — read before promising "buy in ChatGPT"

Optimizing the feed — writing for a model, not a keyword index

Google Shopping feeds are optimized for a matching engine; ChatGPT feeds are read by a language model that reasons about fit, then rewrites your listing for the user. That changes the craft:

• Factual, self-contained descriptions. OpenAI's own best-practices guidance says concise, factual copy; practitioner consensus adds: answer the conversational questions (who it's for, what problem it solves, when it's used) inside the description, because the model can only reason over what's in front of it.
• Quantify instead of emote. "Operates at 45 dB" beats "whisper-quiet" — a model comparing options can rank 45 against 52; it can do nothing with adjectives. Dimensions, materials, compatibility, care instructions: fill them.
• Model variants properly. Stable parent ID, unique variant IDs, variant_dict for the option dimensions, variant-specific price/availability/images where they differ. Variant soup is a classic reason listings display wrong.
• Ship the trust fields. reviews, q_and_a, star_rating, review_count — ChatGPT summarizes review sentiment in results, and it would rather summarize data you provided than whatever it crawled.
• Use OpenAI's exclusive signals. popularity_score and return_rate have no Google equivalent — they let your sales and fulfillment data argue for you at ranking time.
• Instrument attribution now. OpenAI's guidance: put feed-specific tracking on your URLs (e.g. utm_medium=feed) and keep parameters consistent across snapshots. Without it, ChatGPT-referred revenue hides inside "direct" and you'll underinvest in the channel. Pair with visibility metrics to see the full funnel.
• Mind the policy line. The feed program excludes adult content, age-restricted products (alcohol, nicotine, gambling), weapons, prescription medications, and other restricted categories — OpenAI can remove products or ban sellers for violations.

Coming from Google Merchant Center — the translation

Your GMC export is the right starting point — the attribute overlap is large — but it is a starting point, not a finish line: field names differ, the eligibility flags don't exist in GMC, and the copy that survives Google's character limits is usually too thin for a model that rewards self-contained, attribute-rich descriptions. Budget a real transformation step, not a rename.

Operating the pipeline — the monitoring checklist

• Publish heartbeat: alert if the daily snapshot fails or the file's modified time goes stale. Under snapshot semantics, a silent failure isn't "no update" — it's a stale catalog presented as current.
• Row-count sanity: alert on large swings versus yesterday — a snapshot that shrinks 40% overnight just "removed" 40% of your catalog.
• Schema pinning: validate field names and types against the spec in CI so an upstream rename never ships. The spec is versioned and has already drifted once (the enable_* → is_eligible_* rename).
• Shard integrity: confirm the full shard set was replaced — 5 of 8 shards is a silently truncated catalog.
• Feed-vs-site price parity: reported as a common rejection cause and an obvious trust-killer; diff feed prices against the live site on every publish.
• Encoding gate: reject non-UTF-8 at build time.

Action plans by merchant type

If you're on Shopify

1. Verify the integration state: Shopify admin → Sales channels → Agentic → ChatGPT (default-on for eligible US-selling stores; confirm it matches your intent).
2. Complete the eligibility surface: policy pages (terms, privacy, returns) under Settings → Policies; accept the agentic storefront terms.
3. Audit catalog quality where ChatGPT reads it: descriptive non-keyword-stuffed titles, GTINs, categories, variant hygiene, review apps feeding structured data.
4. Confirm OAI-SearchBot isn't blocked by robots.txt or your bot-protection layer.
5. Add AI-referral tracking (ChatGPT referrals surface in Shopify attribution like any channel) and watch weekly.

If you're a DTC brand or retailer not on Shopify

1. Apply for direct feed access via OpenAI's merchant program — the queue is real, so start the clock now.
2. While you wait: fix crawlability (OAI-SearchBot allowed, server-side Product schema on PDPs), since crawled data is your visibility until the feed lands.
3. Build the export against the current spec: 100-item sample first, every required field populated, is_eligible_search=true, checkout flag off until you're ready for its policy requirements.
4. Stand up the snapshot pipeline (nightly warehouse job → Parquet → SFTP) and plan API upserts for price/availability if you change them intraday. Promotions need the API, full stop.
5. Instrument feed URLs (utm_medium=feed) before the first snapshot ships, not after.

If you're a retail advertiser

1. Create the Ads Manager feed (Tools → Feeds), configure SFTP, upload, and let validation finish before building campaigns.
2. Precompute segmentation into ads_metadata (margin tiers, product lines, bid tiers) — it's your only custom grouping lever, and it lives in the data pipeline.
3. Start with a "Product feed" campaign over your highest-margin, highest-AOV segment; one ad group per meaningful segment, one template each.
4. Write context hints per ad group that describe the conversations — not the keywords — where those products belong.
5. Pull product-segmented insights weekly; kill or re-bid the SKU tail, and feed winners back into segmentation. Layer customer lists as suppression once purchase volume exists.
6. Remember the beta wall: this feed buys ads, not organic presence. Run the organic track (paths 1–2) in parallel — see measuring ROI for how to keep the two honestly attributed.

Mistakes to avoid

1. Treating the two feeds as one. The Ads Manager feed doesn't grant organic visibility (beta rule), and the commerce feed doesn't run ads. Budget both pipelines.
2. Building from stale field names. enable_search-era tutorials still dominate search results. The spec is the contract; the current flags are is_eligible_* and is_ads_eligible.
3. Typing is_ads_enabled. Not a field. Ingestion reads is_ads_eligible (or the legacy alias) — nothing else.
4. Timestamped filenames / append-log thinking. One stable name, whole truth, overwritten in place, every day.
5. Implicit removals. Discontinued products don't age out; they linger, eligible and wrong, until you flag or omit them.
6. Marketing copy in descriptions. Flagged by practitioners as a validation-stage rejection cause, and it strips the model of the facts it ranks on. Save the poetry for the landing page.
7. Skipping the 100-item sample. Schema errors cost minutes in the sample and days in a full snapshot.
8. Publishing without monitoring or attribution. A stale feed misprices you everywhere; untagged URLs make the channel invisible in analytics. Both are silent failures.

Frequently asked questions

Sources and further reading

• OpenAI Help Center — Create Campaigns from Product Feeds, Shopping with ChatGPT Search, and Using Shopping Research in ChatGPT (all retrieved July 13, 2026).
• OpenAI for Developers — Products spec, file-upload overview, Feeds/Products/Promotions API, Get Started & best practices, and the Ads product feeds guide (retrieved July 13, 2026).
• Agentic Commerce Protocol — agenticcommerce.dev and the open-source spec on GitHub (OpenAI + Stripe, Apache 2.0).
• Shopify Help Center — ChatGPT agentic storefront settings and eligibility.
• OpenAI — Buy it in ChatGPT (Instant Checkout launch) and Shopping Research announcement; checkout-pivot reporting via CNBC and Modern Retail (March 2026).
• Adobe Analytics — AI-referred retail traffic and conversion series (holiday 2025 through May 2026 releases).
• Context Hints — how ChatGPT ads work, Ads Manager setup, ad costs, buyer-evaluation visibility, and appearing in ChatGPT answers.

Tarun Kapoor

Founder & CEO, Context Hints

Twelve years of media buying across GroupM, WPP, Ogilvy & Mather, and Neil Patel Digital. Has personally owned media for Nestlé, Sage, Qualcomm, Aetna, Weight Watchers, Chubb and Novotel.