ChatGPT product feed: the complete merchant guide

Tarun Kapoor Updated 13 October 2026 24 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 nine required fields and eligibility flags, digital goods, Google-format uploads, 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, first checked July 13, 2026 and re-checked against the current spec on October 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.

Connecting a feed is part of our ChatGPT Ads setup service; if your feed is already live and underperforming, the ChatGPT Ads audit checks it alongside the rest of the account.

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.

Required fields: the 9 every row needs, and three flags that decide everything

OpenAI simplified the contract. The current products spec (checked October 13, 2026) lists nine fields that every row must carry. Everything else is either optional or only required when you switch a feature on, such as variants, checkout, or ads. If a guide tells you there are 15 or 19 mandatory columns, it was written against an older version of the spec.

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, and it defaults to true when you leave it out.
• 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. It defaults to off unless your feed has a feed-level Ads default configured. 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 superseded (the spec still accepts legacy names, but when both are sent the newer name wins, so don't mix them), and XML was never a supported upload format despite what several vendor pages claim. Two validation rules catch people often: a gtin must be exactly 8, 12, 13 or 14 digits with a valid check digit (keep leading zeros, no spaces or dashes), and the standard upload targets the US market only until OpenAI confirms additional countries and currencies for your feed. 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).

A minimal valid row

This is the smallest JSONL record that satisfies the nine required fields. Build your export so this passes before you add anything else:

{"item_id":"TENT-2P-GRN","title":"Two-Person Backpacking Tent, 1.4 kg, Green","description":"Freestanding two-person tent with two doors and two vestibules. Packed weight 1.4 kg. Aluminium poles, 20D ripstop fly. Pitches in about five minutes.","url":"https://example.com/tents/2p-green","brand":"Example Outdoor","seller_name":"Example Outdoor","image_url":"https://example.com/img/tent-2p-green.jpg","availability":"in_stock","price":"249.00 USD"}

Digital goods: what is_digital does and doesn't do

If you sell courses, ebooks, templates, software licences or gift cards, the spec has exactly one digital-specific field: is_digital. Set it to true for an item with no physical shipment and false for a physical item. Three details matter:

• It requires setup. The spec marks the field "optional; requires setup", meaning digital support has to be enabled for your integration. Adding the column on its own changes nothing.
• Omission isn't a value. A blank leaves the item unspecified. Don't rely on leaving it out to signal a digital product, especially if you plan to use checkout.
• The nine required fields still apply. A digital item still needs a brand, seller name, image, availability and price. For an ebook, availability is normally in_stock, and shipping and return fields that don't apply can stay empty.

If digital products are a large share of your catalog, raise it when you apply for feed access rather than finding out after your first snapshot.

Can you upload your Google Merchant Center feed?

Partly. The spec now documents a Google-compatible product data feed, but you can only use it after OpenAI confirms it for your registered feed. On that path:

• Each row needs nonempty id, title, description, link, image_link, availability, price and brand, which are Google's own column names.
• Files are UTF-8 tab-delimited .txt/.tsv or comma-delimited .csv, plain or gzipped. JSON, spreadsheets, XML, RSS and Atom are not accepted.
• Accepted products have search on and checkout off, and an uploaded is_eligible_search=false does not opt a product out on this path. If you need per-product control, use the native OpenAI format instead.

For most merchants that makes the Google path a good way to get started and the native format the long-term home, because only the native format carries the eligibility flags, ads_metadata and the OpenAI-only signals covered in the optimization section.

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 to submit your products to ChatGPT, step by step

Whichever path you're on, a submission comes down to the same five stages. Shopify merchants skip steps 1 and 4 because Shopify Catalog handles delivery for them.

1. Pick your door and apply. Organic visibility goes through OpenAI's merchant program at chatgpt.com/merchants, and ads go through Ads Manager → Tools → Feeds. If you want both, do both (see the two-feed map).
2. Build the export against the current spec. Start with the nine required fields, then add GTINs, variants, reviews and the eligibility flags. Use stable item_ids, because OpenAI matches products by ID and not by filename.
3. Validate a sample of about 100 items. OpenAI's own rollout guidance is a small sample with every required field populated, then a QA'd first full snapshot. Schema errors cost minutes at this stage and days later.
4. Automate the daily snapshot. Push a full catalog over SFTP at least daily to a stable filename, then layer API upserts on top if prices or stock change during the day. Tag feed URLs consistently. Our ChatGPT Ads URL parameters guide covers the tagging conventions.
5. Check how products actually appear. Run shopping prompts for your category and compare what ChatGPT says against your feed. Our guide to tracking ChatGPT visibility shows how to turn that into a weekly measurement rather than a one-off spot check.

Listing products organically doesn't cost anything. The feed is a data contract, not a paid placement. Money only enters when you run product-feed ad campaigns on top of it.

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 and September 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 began testing a carousel format for product feed ads in August 2026, showing multiple products from one advertiser in a single unit. It is now serving and measurable — as of September 2026 Ads Manager reports carousel card impressions and clicks, with product-level fields in the Insights API. OpenAI has not declared general availability, so treat it as a live format you can measure rather than one you can request. It 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: 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.

Carousel card reporting arrives (September 2026)

The carousel stopped being a black box. When a product feed campaign serves in the multi-product carousel ad unit, reporting now includes carousel card impressions and clicks in Ads Manager, and product-level fields in the public Insights API. A carousel card impression is counted when an individual product card becomes viewable — card-level, not unit-level.

Two more constraints define how you should use it. Complete data is available beginning August 20, 2026, on a rolling 30-day basis. That means the history starts there, and it is a moving window — anything older than thirty days leaves. If you intend to compare this quarter's carousel performance to next quarter's, you need your own export job now, because the platform will not keep it for you. Pull the product-level fields from the Insights API on a schedule and warehouse them.

What it is actually good for: this is the first product-level visibility feed ads have had. Until now a feed campaign reported in aggregate and the catalog inside it was undifferentiated — you knew the campaign worked, not which SKUs earned the attention. Card impressions and clicks let you ask real questions of the catalog. Which products get shown but never clicked? That is usually an image or a price problem, not a relevance one. Which get clicked far above their share of impressions, and should therefore be promoted into more product sets? Which positions in the carousel actually earn attention — and does your best margin item ever appear in one?

The honest caveat: card-level engagement is not conversion. A high card CTR on a low-margin SKU that cannibalises a better one is a worse outcome that looks like a better number. Read card metrics alongside conversion data and margin, exactly as you would read impression share on any other channel — as a diagnostic of what the unit is doing, not as a measure of whether it is working.

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, and once OpenAI confirms it for your feed you can even upload it in Google-compatible format. 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 has already drifted twice: the enable_* → is_eligible_* rename, then the 2026 cut to nine always-required fields.
• 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.

Why your products aren't showing up in ChatGPT, and how to fix it

Most "ChatGPT shows the wrong price" and "my products aren't in ChatGPT" problems come down to a short list of causes. Work through it in this order:

ChatGPT product feed management tools: build or buy?

You can build the feed yourself or let a feed tool generate it. The search results for "ChatGPT product feed" are full of tools offering OpenAI-format exports: Shopify's native Agentic channel, multichannel feed platforms such as Feedonomics and DataFeedWatch, cart plugins like PrestaShop feed modules, and catalog-ad vendors adding ACP outputs. How to choose:

• On Shopify? Start with the native integration and only add a tool if you need field-level control that Shopify Catalog doesn't expose.
• Already running Google Shopping through a feed platform? Ask whether it outputs the native OpenAI format, including is_eligible_*, is_ads_eligible and ads_metadata, or only the Google-compatible columns. That answer decides whether you can segment ad campaigns.
• Large catalog with a data warehouse? Building it yourself is usually simplest: a nightly export to Parquet, pushed over SFTP, with API upserts driven by your existing price and inventory events.

Whichever you pick, the tool only produces the file. The work that moves results is the segmentation and testing on top of it, which our bulk product-feed campaigns guide covers in detail.

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. Legacy names are still accepted, but the newer name wins when both are sent, so mixed exports behave unpredictably. Use the current is_eligible_* and is_ads_eligible names.
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. A product dropped from the snapshot can linger for up to 14 days on its last record. Set is_eligible_search=false when it needs to go now.
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.

Feed work is media work in this channel — if you would rather not own the catalog hygiene, weekly hint iteration and purchase-event plumbing yourself, our ChatGPT Ads service for ecommerce brands covers all three inside your own OpenAI Ads account.

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.
• OpenAI for Developers — Products spec re-checked October 13, 2026 for the nine required fields, is_digital, the Google-compatible feed path, GTIN and price-format rules, flag defaults and the US default market; file-upload overview for the 14-day retention of omitted products.

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.