Your customers have started asking ChatGPT what to buy. “A carry-on backpack that fits under the seat,” “a quiet fan for a small bedroom,” and the assistant may answer with real products: images, prices, and a link to a store. Accurate product data helps ChatGPT understand what you sell, and a product feed is the structured way to supply it. Submitting a feed doesn’t guarantee that your products appear in any given answer, but without one, ChatGPT has nothing reliable to work with.
A product feed is a structured file that lists your products and their data (title, price, availability, images, and more) in the format a channel expects. For ChatGPT, that format is OpenAI’s own. You may be able to start from the Google Shopping feed you already have: OpenAI accepts its own format, and for confirmed integrations it can also accept a Google-compatible feed. The first question is which of those applies to your setup, and this guide walks through both the requirements and how to prepare the file with Koongo.
Before you start. Uploading a product feed to OpenAI is currently open to approved partners and registered integrations, and paid ChatGPT Ads availability depends on your market and account. Confirm that the channel is available for your account and target markets before you invest time in the feed. This guide focuses on the CSV product feed and does not cover running paid campaigns.
In this guide
- What this guide covers
- Why accurate product feeds matter
- Discovery, Ads, and checkout: three separate things
- How to set up your ChatGPT product feed with Koongo
- The required fields and a feed example
- Variants, pricing, and other technical detail
- Delivery, updates, and error handling
- Pre-launch checklist
- FAQ
What this guide covers
ChatGPT surfaces products inside its answers to shopping questions. Some placements are organic; some are paid. Both draw on the same underlying product data, and both send the shopper to your own store to complete the purchase.
How ChatGPT Shopping works: a shopper asks, ChatGPT may recommend products, and the shopper clicks through to your own store.
This guide covers what the feed file has to contain, down to how a price is written and how a variant is grouped, how to prepare and deliver it with Koongo, and how to check that it processed. It does not cover setting up or bidding on paid campaigns, which happens in OpenAI’s Ads Manager.
Why accurate product feeds matter
A merchant-supplied feed gives OpenAI structured data about your catalogue directly, rather than leaving the assistant to piece it together. The feed acts as the single source of truth for your product data: titles, descriptions, current price, stock and availability, brand, and identifiers.
What a product feed gives OpenAI: structured, accurate data about what you sell.
That is why the specification is demanding about accuracy, seller identity, returns, and delivery. The assistant reads your data, the shopper clicks through, and you close the sale in your own checkout. What you provide is a complete, accurate catalogue in the exact shape OpenAI asks for.
Discovery, Ads, and checkout: three separate things
It’s tempting to think one correctly-prepared file switches everything on at once. It doesn’t. OpenAI treats discovery, Ads, and checkout as separate layers, each with its own access, eligibility, and requirements. You start with discovery data, then add what each further integration needs. (OpenAI product feed spec.)
Discovery and paid ads draw on the same feed, but have separate access and requirements.
Discovery (organic). ChatGPT can surface your products in answers based on relevance and data quality. This is the base layer: a valid discovery feed in OpenAI’s format.
Ads (paid). Paid product feed campaigns run through Ads Manager on a schema close to Google Merchant Center. The system builds sponsored product units from your feed, but each product you want promoted needs its Ads-eligibility flag set, and campaigns have their own access and setup. A valid discovery feed is a prerequisite, not a paid campaign by itself.
Checkout. If you enable purchase inside ChatGPT, that adds further required fields and policy URLs on top of discovery. It is a separate integration again.
Preparing a valid feed is one important step. Whether your products then appear organically, or run as ads, or support in-chat checkout, depends on these separate layers.
How to set up your ChatGPT product feed with Koongo
Koongo’s Feed Manager builds and refreshes product feeds for 500+ channels from a single copy of your catalogue, so you don’t rename columns or hand-build a CSV. It maps your store data to OpenAI’s field names, transforms values with the Rules Editor (Koongo’s no-code tool for reshaping product data), keeps identifiers intact as text, and formats prices to the right precision per currency.
How Koongo prepares your product data as a ChatGPT-ready feed.
At a high level, setting up the feed looks like this:
- Connect your store. Connect your platform, for example Shopify or WooCommerce, so Koongo can read your catalogue.
- Choose the feed template. Select the ChatGPT product feed template.
- Map your fields. Map your store data to OpenAI’s field names, and use the Rules Editor to fill or derive values where your source data is patchy.
- Review the export. Check the generated file against the required fields and the price format before you deliver it.
- Deliver the feed. Deliver the file to OpenAI through your approved onboarding method (SFTP, file upload, or a hosted URL).
- Confirm processing. After delivery, confirm the feed was accepted and watch for errors on the first runs.
To be clear about scope: Koongo generates and refreshes the feed file. It doesn’t run your ChatGPT campaigns, set bids, or manage budgets, and this is a feed integration, so it doesn’t import orders. Your existing checkout handles the sale.
The required fields and a feed example
This is the section worth reading twice, because it’s where uploads fail. OpenAI’s feed is a flat file, one row per product or variant, UTF-8 encoded. Even fields you already have need renaming to OpenAI’s names. A discovery feed requires these nine on every row. (OpenAI product feed spec.)
| OpenAI field | What it holds |
|---|---|
| item_id | A stable, unique ID per item or variant, never reused for a different item |
| title | Product name (up to 150 characters), including the variant when relevant |
| description | A factual product description in plain text (up to 5,000 characters) |
| url | The product page link, with the variant selected where possible |
| brand | The product brand as shown on the page (up to 70 characters) |
| seller_name | The name of the seller supplying the offer, a real name, not a placeholder |
| image_url | A direct URL to the main product image (JPEG or PNG, HTTPS preferred) |
| availability | One of five exact values (below) |
| price | Amount with the currency inside the value |
The nine required discovery fields in an OpenAI product feed. Price carries the currency inside the value.
Supported formats. OpenAI’s file-upload setup prefers Parquet, and also supports compressed JSONL, CSV, and TSV. It does not use XML. This guide focuses on CSV. (OpenAI feed delivery overview.)
The five availability values
availability must be exactly one of in_stock, out_of_stock, pre_order, backorder, or unknown. An omitted, empty, or misspelled value rejects the row. Use unknown explicitly when you genuinely don’t know; it does not mean “in stock.” Note the underscore in pre_order: the Google-compatible path spells it preorder and doesn’t accept unknown, so the correct spelling depends on which format you upload.
CSV mechanics that break feeds silently
Because this is a CSV integration, these formatting rules matter:
- Quote any cell containing a comma, quote, or newline, and double each embedded quote. Titles and descriptions almost always contain commas, so they must be quoted.
- Keep identifiers as strings so leading zeros survive. A GTIN like 09506000134352 loses its leading zero the moment a spreadsheet treats it as a number.
- Multiple images go in one cell as a comma-separated list; if a URL contains a comma, percent-encode it as %2C.
- A JSON value in a CSV cell, like variant_dict, is serialized as JSON and then quoted, so the doubled quotes look like this: “{“”color””:””Slate blue””,””size””:””750 ml””}”.
A minimal, valid two-variant example with the required fields:
item_id,group_id,listing_has_variations,variant_dict,title,description,url,brand,seller_name,image_url,availability,price
BTL-SLATE-750,BTL-INS,true,”{“”color””:””Slate blue””,””size””:””750 ml””}”,”Larkmont insulated water bottle, 750 ml, slate blue”,”Double-walled stainless steel bottle that keeps drinks cold for 24 hours.”,https://example.com/insulated-bottle?c=slate&s=750,Larkmont,Larkmont Supply,https://example.com/img/bottle-slate.jpg,in_stock,29.00 EUR
BTL-SAND-750,BTL-INS,true,”{“”color””:””Sand””,””size””:””750 ml””}”,”Larkmont insulated water bottle, 750 ml, sand”,”Double-walled stainless steel bottle that keeps drinks cold for 24 hours.”,https://example.com/insulated-bottle?c=sand&s=750,Larkmont,Larkmont Supply,https://example.com/img/bottle-sand.jpg,out_of_stock,29.00 EUR
Variants, pricing, and other technical detail
Variants: group_id, and one row per option
You send a separate row for each variant, one for each colour and size, with its own item_id, price, availability, URL, and image. You tie them together with three fields:
- group_id: a stable parent-listing ID shared by every variant of the same product. It must differ from each item_id.
- listing_has_variations: set to true on every variant row.
- variant_dict: a small map of the selected options, for example {“color”:”Slate blue”,”size”:”750 ml”}.
Keep the option names consistent across a group (“color” everywhere, not “colour” on some rows), and keep every item_id, group_id, and any offer_id stable even when price or stock changes. One rule worth remembering: never put the price inside an offer ID.
Grouping variants with a shared group_id, one row per option.
The price field
Price is written as an amount, a space, and an uppercase three-letter ISO 4217 currency code, for example, 29.00 EUR. Use a decimal point, no thousands separators, and no exponent notation: 1299.00 EUR, never 1,299 EUR. The spec is clear that 79.99 USD means 79 dollars and 99 cents, so don’t drop the decimals. Validate the price format before upload, because a mismatched header row or currency format is a common reason a reused Google export is rejected.
For a discount, add sale_price in the same currency, greater than zero and strictly lower than price. A sale price that is equal to, higher than, or in a different currency from the regular price is ignored, with no error and no discount shown.
Identifiers: GTIN rules that get checked
A GTIN, EAN, or MPN with the brand is the strongest identity signal you can send. If you supply a GTIN, it must be exactly 8, 12, 13, or 14 digits with a valid check digit, with leading zeros preserved and no spaces or separators. A UPC-A is a 12-digit GTIN; an ISBN-13 can go in as a 13-digit GTIN, but an ISBN-10 cannot. Don’t invent an MPN to stand in for a missing GTIN; omit the identifier instead.
Additional fields for discovery, Ads, and checkout
Beyond the nine required discovery fields, OpenAI defines further fields, and which ones you need depends on the layer you’re setting up:
- Optional discovery detail. Fields like additional images, and returns information (a return policy URL and a return window in days) are optional for discovery but worth including where you have them, so ChatGPT can answer “is it easy to return?”
- Eligibility flags. is_eligible_search and is_eligible_checkout control whether a product is discoverable or purchasable; checkout eligibility only applies when search is also on.
- Ads. For paid campaigns, is_ads_eligible is conditionally required: set it to true on each product Ads should process. (Ads product feeds guide.)
- Checkout. Enabling purchase inside ChatGPT adds required policy URLs (privacy policy and terms of service over HTTPS) on top of discovery.
Why other guides list different field names: the beta renames
If two tutorials disagree on field names, this is why. OpenAI renamed several fields during the beta. The old names still work as aliases, but send only one name per value, and the current name wins:
| Old name (still accepted) | Current name |
|---|---|
| id or sku | item_id |
| item_group_id | group_id |
| enable_search | is_eligible_search |
| enable_checkout | is_eligible_checkout |
| is_eligible_ads | is_ads_eligible |
| return_window | return_deadline_in_days |
OpenAI’s beta field renames: old names still work as aliases, but the current names win.
Match your file to the version of the spec in force when you build it, and don’t mix an old name and its replacement in the same feed.
A note for European sellers: the default market
The standard OpenAI-format upload targets a single default market unless multi-country processing is confirmed for your integration, and row-level country columns don’t change that on their own. So a European merchant can’t simply add a target_countries column and expect to serve the Netherlands. Confirm your allowed countries and currencies during onboarding before you plan a market around them.
What makes a strong feed
These aren’t guarantees of visibility, but they give ChatGPT accurate, specific data to work with, and they keep your file valid.
Strong feed data versus common feed errors.
- Titles in the pattern shoppers use: brand, product, key attribute, variant. “Larkmont insulated water bottle, 750 ml, slate blue” reads better than “Larkmont water bottle, free shipping!”
- Descriptions that are factual and complete: materials, dimensions, compatibility, and what’s in the box.
- Price and availability that match the landing page at the moment a shopper arrives.
- Correct variant grouping and a clean primary image, plus additional angles where you have them.
Common reasons feeds get rejected: column names that aren’t OpenAI’s, missing required fields, a price without a currency code or with malformed numbers, invalid image or product URLs, non-unique item_id values, and price or availability that disagrees with the live product page.
Delivery, updates, and error handling
You don’t paste a public feed URL into a form. Onboarding is currently open to approved partners, and you deliver the file via SFTP, file upload, or a hosted URL depending on your setup. Items are treated as perishable, so the feed needs to be refreshed.
Koongo refreshes your feed on a schedule; OpenAI ingests it as a separate step.
Two separate steps matter here. Koongo can refresh your feed file on a schedule (more frequently on paid plans, once a day on the Free plan), which keeps the file you deliver current with your store. OpenAI then ingests that file on its own side, which is a separate step and is not instant. In other words, refreshing more often in Koongo keeps your side up to date, but how quickly a change reaches ChatGPT also depends on OpenAI’s ingestion.
One piece of good news on errors: a single malformed row can be rejected while the rest of your valid rows keep processing, and the upload history tells you which columns or values failed, so you fix the specific problem rather than the whole file.
Pre-launch checklist
- Confirm access. Check that the channel is available for your account and target markets.
- Build the file to OpenAI’s spec: correct column names, currency inside the price, one row per variant.
- Fill the fields your layer needs: the nine discovery fields, plus Ads or checkout fields if you’re setting those up.
- Complete your identifiers: a valid GTIN or MPN, plus brand, wherever you can.
- Write titles and descriptions as facts. Strip promo language; add the attributes a person would say out loud.
- Validate price and stock parity between feed and product page.
- Deliver and confirm processing, then monitor the first runs for errors.
- Tag your links with UTM parameters so ChatGPT-sourced sessions are separable in analytics.
FAQ
What is a ChatGPT Shopping feed?
A ChatGPT Shopping feed is a structured product file that lists your catalogue in OpenAI’s required format, so ChatGPT can use accurate data about your products and link shoppers to your store. It uses OpenAI’s own column names and required fields, which differ from a Google Shopping feed.
Can I use my Google Shopping feed for ChatGPT?
Possibly, as a starting point. OpenAI supports its own format, and for confirmed integrations it can also accept a Google-compatible feed and map the supported fields itself. Which one applies depends on your registered setup, so check that first rather than assuming an existing export will work unchanged. Koongo can generate the feed in OpenAI’s own structure for you.
Does submitting a feed guarantee my products will appear in ChatGPT?
No. A valid feed gives ChatGPT accurate data to work with, but it doesn’t guarantee that your products appear in any given answer or ad placement. Organic discovery, paid Ads, and checkout are separate layers with their own eligibility and requirements.
How do I write the price in an OpenAI product feed?
As an amount, a space, and a three-letter ISO 4217 currency code, for example, 29.00 EUR. Use a decimal point, no thousands separators, and the right number of decimals for the currency. A sale price must be in the same currency and strictly lower than the regular price, or it is ignored.
How are product variants handled?
Send one row per variant, each with its own item_id, price, and stock. Tie them together with a shared group_id (different from each item_id), set listing_has_variations to true, and list the selected options in variant_dict, for example {“color”:”Slate blue”,”size”:”750 ml”}. Keep the option names consistent across the group.
What happens when I remove a product from my feed?
It isn’t necessarily removed from ChatGPT straight away. For the documented snapshot upload, a row you drop isn’t deleted immediately; the last processed record can persist for up to 14 days. To take a product down promptly, follow the removal controls your integration supports rather than only omitting the row.
Does Koongo import orders from ChatGPT?
No. The Koongo integration described here generates and refreshes your product feed; it does not import orders. ChatGPT Shopping sends the shopper to your own site to buy, so orders are handled by your existing checkout, the same as any other feed channel.
Do I need a paid Koongo plan to create a ChatGPT feed?
Feed Manager is included in every Koongo plan, including the free plan. Paid plans refresh your feed file more frequently, which keeps your side current; how quickly a change then reaches ChatGPT also depends on OpenAI’s own ingestion. See the Koongo pricing page for current plans.
Getting started
ChatGPT Shopping is a new way for customers to find products. Getting in is a sequence, not a switch: confirm the channel is available for your account and markets, prepare a valid feed in OpenAI’s format, deliver it, and monitor how it processes after launch. Koongo helps with the part you can control most directly: producing and refreshing a correctly-structured feed from your existing catalogue.
Ready to prepare your feed? Start with Koongo’s Feed Manager. A free plan is available with no credit card required, and paid plans start from €24/month with a 7-day free trial.
Continue reading →