# ChatGPT product feed: the complete guide to catalog ads, the file spec and updates

> How ChatGPT product feeds work: required fields, import methods, the two-week expiry, Delta API updates, filters, templates, bidding and product reporting.

Published: 2026-09-28 · ChatAdsAI · https://www.chatadsai.com/guides/chatgpt-product-feed

> **Summary:** A ChatGPT product feed is a structured file of your catalog. In Ads Manager you import it as a CSV or TXT file, from a hosted URL, or over SFTP, then build a Product feed campaign with product filters and one ad template per ad group. Items expire after two weeks, so automate the refresh. During the beta, an Ads Manager feed powers ads only. Organic shopping results come from a separate, application-gated feed program.

## What is a ChatGPT product feed?

A ChatGPT product feed is a file with one row per product or variant, in a schema OpenAI publishes, that tells ChatGPT what you sell, what it costs and whether it is in stock.

A standard ChatGPT ad is written by hand, which does not scale to a shop with hundreds of products. With a feed, you give Ads Manager structured data, and product ads are assembled from it. OpenAI describes the ad format as built for showcasing catalog items, with details such as product images, titles, stars, prices, sale prices and your brand.

OpenAI states that feed-based campaigns are designed for retail advertisers with broad or frequently changing product catalogs. It also says that ads created from product feeds "have been among the strongest-performing ads" in its program to date. That is OpenAI's own description, without published figures, so we treat it as a reason to test the format and not as a forecast.

If you are new to the platform, start with [how ChatGPT ads work](https://www.chatadsai.com/guides/how-chatgpt-ads-work) and [Ads Manager account setup](https://www.chatadsai.com/guides/ads-manager-account-setup), then come back here.

## Are there two different ChatGPT product feeds?

Yes. OpenAI documents two feed programs that share one product schema: a feed you upload in Ads Manager for advertising, and a commerce feed for organic shopping experiences.

| Question | Ads Manager feed | Commerce feed |
|---|---|---|
| What it powers | Product feed ad campaigns | Shopping experiences in ChatGPT |
| Who can use it | Advertisers, from Tools, then Feeds | Approved partners, by application |
| Delivery | CSV or TXT upload, hosted URL, SFTP | SFTP file upload and an API |
| Key flag | `is_ads_eligible` | `is_eligible_search` |

Two statements from OpenAI define the boundary.

First, the ads help article says products from your feed are eligible for use in ads only during this beta. They will not appear in organic ChatGPT conversations, although OpenAI says it may offer that capability in the future.

Second, the commerce documentation says onboarding product feeds in ChatGPT is currently available to approved partners, with an application form.

The practical result: uploading a catalog in Ads Manager does not make you visible in unpaid shopping results. We cover the organic side near the end of this guide, and in more depth in [ChatGPT Ads vs. organic mentions](https://www.chatadsai.com/guides/chatgpt-ads-vs-organic).

## Which fields does the product file need?

The products spec lists nine required fields for basic product data. An ads feed adds the ads eligibility flag on top.

| Field | Required | What OpenAI asks for |
|---|---|---|
| `item_id` | Yes | Stable ID, unique per item or variant. Never reuse it for a different item. |
| `title` | Yes | Product name, including the selected variant when relevant. |
| `description` | Yes | Factual product description, in plain text. |
| `url` | Yes | Product detail page, kept stable, with the variant selected when possible. |
| `brand` | Yes | Brand as shown on the product page. |
| `seller_name` | Yes | Name of the seller supplying the offer. |
| `image_url` | Yes | Main image, as a direct image URL such as a JPEG or PNG. |
| `availability` | Yes | `in_stock`, `out_of_stock`, `pre_order`, `backorder` or `unknown`. |
| `price` | Yes | Regular price in major currency units, such as `79.99 USD`. |

OpenAI asks you to keep titles concise and descriptions in plain text, aiming for at most 150 and 5,000 characters respectively. It also asks for a real brand and seller name, not placeholders.

Four flags and objects control where a product may be used:

| Field | What it controls | Default when omitted |
|---|---|---|
| `is_eligible_search` | Search eligibility | True |
| `is_eligible_checkout` | Opt-in to checkout | Disabled |
| `is_ads_eligible` | Processing for ads | Disabled, unless a feed-level Ads default applies |
| `ads_metadata` | Custom keys for product filters | No metadata |

For advertisers the third row matters most. The help article states that feeds created through Ads Manager make products ads-eligible by default, unless an item is explicitly marked false for ads eligibility. In the developer guide, OpenAI still tells you to set `is_ads_eligible` to true for products you want processed for ads. Our advice is to set it explicitly in every row, so the file means the same thing wherever it is uploaded.

The example file in the ads developer guide uses these sixteen columns: `item_id`, `title`, `description`, `url`, `brand`, `image_url`, `price`, `availability`, `seller_name`, `seller_url`, `return_policy`, `target_countries`, `store_country`, `is_eligible_search`, `is_eligible_checkout` and `is_ads_eligible`. It is a good starting template.

A note on older tutorials. The spec still accepts several aliases, including `id` or `sku` for `item_id`, `enable_search` for `is_eligible_search`, and `is_eligible_ads` for `is_ads_eligible`. OpenAI asks you to send only one name per value. Use the current names in new feeds.

**Optional fields worth filling**

Beyond the required set, the spec documents optional fields that make a product easier to match and describe:

- **Identifiers:** `gtin` and `mpn`. A GTIN must be exactly 8, 12, 13 or 14 digits, including a valid check digit.
- **Attributes:** `condition`, `product_category`, `material`, `color`, `size`, `gender`, `age_group`, `dimensions` and `weight`.
- **Media:** `additional_image_urls` for extra views of the item.
- **Pricing:** `sale_price`, which must be greater than zero and strictly less than `price`, in the same currency.
- **Returns:** `accepts_returns`, `return_deadline_in_days` and `return_policy`.
- **Reviews:** `review_count` and `star_rating`, on a 0 to 5 scale.

One correction to a common belief: the spec states that raw review entries and question-and-answer lists are not part of this discovery contract. Send the aggregates, not the review text.

## How should prices, availability and variants be formatted?

Write money as an amount, a space and a three-letter currency code, and send one row per purchasable variant with its own price, stock status, URL and image.

**Prices.** The spec gives `79.99 USD` as the pattern: a decimal amount in major units, a space, and an uppercase ISO 4217 code. Use a decimal point, no thousands separators, and for USD two decimal places. OpenAI asks you to submit the current price and to update the feed when a sale starts or ends.

**Dates do not schedule anything.** The spec is explicit that sale-window dates, expiration dates and availability dates do not schedule price or availability changes. If a sale ends on Sunday, the feed has to change on Sunday.

**Availability.** Omitted, empty or unrecognized availability values reject the row. Use `unknown` only when stock status really is unavailable. OpenAI notes that `unknown` does not assert that the item is in stock.

**Variants.** For a product sold in several sizes or colors, send a separate row for each selection with:

1. A distinct `item_id` per row.
2. The same `group_id` on every row, different from each item ID.
3. `listing_has_variations` set to true.
4. A `variant_dict` that maps option names to the selected values.

**General value rules.** Use UTF-8 text and absolute URLs, and prefer HTTPS. Keep identifiers as strings so leading zeros survive. In a CSV, quote any cell that contains commas, quotes or newlines. Do not write placeholder strings such as `null` or `n/a` into optional fields. Leave them empty.

**Google-format files.** OpenAI also documents a Google-compatible profile with column names such as `id`, `link` and `image_link`, and custom labels `custom_label_0` through `custom_label_4` for ads filters. It comes with a condition: use this format only after OpenAI confirms it for your registered feed. Note one spelling difference in that profile, `preorder` in place of `pre_order`. XML, RSS and Atom are not supported by this compatibility path.

## How do you create a feed and import products in Ads Manager?

Open **Tools**, select **Feeds**, click **Create Feed**, then choose an import method from the three-dot menu on the feed row.

| Method | OpenAI says it is best for |
|---|---|
| Upload CSV or TXT | Getting started, or occasional manual updates |
| Hosted URL | A catalog available at a stable HTTPS address |
| SFTP connection | Technical teams that automate server-to-server uploads |

Processing can take anywhere from a few minutes to a few hours, depending on the size of the feed. **Upload History** shows processing updates and errors.

**The SFTP route in detail**

The developer guide walks through the same setup over the Advertiser API:

1. **Create the feed** with a name and the countries your catalog supports. Save the returned feed ID.
2. **Configure SFTP access** with password authentication or an SSH public key. Generating a new password replaces the previous one.
3. **Prepare the file** as a UTF-8 CSV with one row per product item or variant.
4. **Upload it** to the SFTP root. OpenAI states that feed files go directly in the root, without nested folders.

If you split the catalog across several files, the files should collectively represent the catalog, with each product appearing once.

Processing is asynchronous. A successful file transfer only confirms that the file arrived. It does not confirm that the products were accepted.

If feed access is unavailable in your account, OpenAI's instruction is to contact your OpenAI account team.

**What bulk upload cannot do**

Ads Manager has a CSV bulk upload for campaigns, which is a different thing from a product feed. OpenAI states that bulk upload does not currently support creating product-feed campaigns. You build them in the guided flow or through the API. See [bulk upload](https://www.chatadsai.com/guides/chatgpt-ads-bulk-upload) for what that tool does cover.

## How long do feed items last, and how often should you refresh?

Feed items expire after two weeks, so a feed needs a recurring refresh. OpenAI recommends a hosted URL or automated SFTP uploads for exactly that reason.

A file uploaded by hand once will stop serving unless someone remembers to upload it again. In our view this is the most common way a working catalog campaign quietly stops.

The commerce file-upload guide explains the retention logic behind the number. A product is not deleted immediately when it is missing from a processed snapshot. OpenAI retains its most recently processed record for up to 14 days, which protects products from disappearing because a file is temporarily missing or delayed.

The same guide sets out how a snapshot pipeline should run:

| Topic | OpenAI's guidance |
|---|---|
| Feed type | Full snapshot, treated as the source of truth |
| Cadence | At least daily |
| Formats | Parquet preferred. `jsonl.gz`, `csv.gz` and `tsv.gz` also supported |
| File names | Stable. Overwrite the same file on every update |
| Shard size | Up to 500k items per shard, files under about 500MB |

That table describes the commerce file-upload path. For an ads feed, the ads developer walkthrough uses a plain CSV, and its diagnostics tell you to check that files use a supported format. If you plan to send anything other than CSV or TXT to an Ads Manager feed, confirm it during setup.

Three habits apply to both paths:

- **Keep identifiers stable.** OpenAI matches products by `item_id`, not by file name.
- **Send the whole catalog.** An SFTP update should include your complete current catalog, including products you want to mark out of stock.
- **Replace, do not accumulate.** Replace the existing file or files and remove outdated ones.

## How do you update prices and stock between uploads?

Use the Delta API for title, price and availability changes on existing items, and a fresh catalog upload for everything else.

| Change | Method |
|---|---|
| Title, price or availability of an existing item | Delta API |
| New products | Updated catalog over SFTP |
| Images, descriptions and other fields | Updated catalog over SFTP |
| Full refresh | Updated catalog over SFTP |

With the Delta API you send only the fields that changed. A response of `accepted: true` confirms submission. Changes apply asynchronously, so allow time before you expect the new price to serve.

The format trap here is the price. The three surfaces use three different notations:

| Surface | Example | Meaning |
|---|---|---|
| CSV price | `79.99 USD` | Major currency units and a code |
| Delta API price | amount `7999`, currency `USD` | Integer minor units and a code |
| Budgets and bids | `50000000` micros | 50 major currency units |

OpenAI adds a warning for currencies without a decimal subdivision: for JPY, a delta amount of 7999 represents 7,999 yen. It also says not to use campaign budget micros for product prices.

Identifiers follow a rule too. The product ID in a delta request is the catalog's `group_id` when variants are grouped, otherwise the `item_id`. The variant ID is always the individual `item_id`.

**To stop serving a product,** set its availability to `out_of_stock` explicitly. OpenAI states that an out-of-stock product stops qualifying for delivery after the change propagates. When it returns, submit `in_stock` with its current details.

Finally, keep your source catalog consistent with whatever you sent through the Delta API. Otherwise the next full upload will overwrite your corrections with old values.

## How do you check that an upload worked?

Read the upload's status and diagnostics in Upload History, or through the upload history endpoint, before you build anything on top of the feed.

| Status | What it means |
|---|---|
| `scanning`, `received`, `processing` | Still underway. Check again later. |
| `completed` | Processed. Check counts and inspect the products. |
| `completed_with_errors` | Some data was processed, errors remain. |
| `skipped` | The upload was not processed. |
| `failed` | Processing failed. Fix the issue and upload again. |

Each upload record reports accepted rows, rejected rows and rows eligible for ads. OpenAI notes that upload counts describe one upload and can differ from the feed's current product count. The product count can also remain zero while the initial upload is processing.

The four diagnostic codes in the guide point to the usual causes:

| Code | What to check |
|---|---|
| `missing_required_column` | Compare your columns with the schema |
| `invalid_value` | Formatting and allowed values, such as price and currency |
| `unsupported_file_type` | The file format |
| `invalid_sftp_directory_layout` | Files must sit in the SFTP root |

The commerce guide names the same three failure patterns in plain words: missing required fields, outdated or non-spec field names, and malformed field values. A malformed row can be rejected while valid rows continue processing.

One sentence from OpenAI deserves attention: a completed upload does not establish that every product can serve. Product data, availability, reviews, product filters and campaign eligibility still apply.

For a new catalog, the commerce guide recommends validating in phases. Start with a small sample of around 100 items, include all required fields in every row, run QA on the first full snapshot, then automate.

## Which crawlers must reach your product pages and images?

You must allow `OAI-AdsBot`, and for product feeds OpenAI also asks you to allow `OAI-SearchBot` to crawl the product image URLs.

Product pages and images must be publicly accessible HTTPS URLs. The risk is usually the image host, which is often a different domain from the shop, behind its own CDN rules. OpenAI notes that a 403 response can block feed processing.

Check three layers, in this order:

1. **robots.txt.** OpenAI crawlers respect it. If access is disallowed, crawling stops immediately.
2. **Firewall, CDN and bot mitigation.** These systems can block legitimate crawlers, often with 403 errors. OpenAI states that `OAI-AdsBot` is officially verified and allowlisted by Cloudflare.
3. **Human verification.** CAPTCHAs and JavaScript challenges can block a crawler that passed the first two layers.

If your security team needs fixed IP ranges, OpenAI publishes them at `openai.com/searchbot.json` and `openai.com/adsbot.json`. If large uploads trigger rate limiting, look for 429 responses in your logs.

Allowing these crawlers is separate from model training. OpenAI's crawler overview says `OAI-SearchBot` is for search, that `GPTBot` is the crawler related to training, and that each setting is independent of the others. It also notes that data collected by `OAI-AdsBot` is not used to train generative AI foundation models.

## How do you build a product feed campaign?

Create a campaign with the type Product feed, add an ad group that selects products with filters, and add one ad template.

In Ads Manager the steps are:

1. In **Campaigns**, create a campaign and select **Product feed** in the campaign type dropdown.
2. Complete the campaign settings: objective, budget, schedule and targeting.
3. Create an ad group and select the feed.
4. Apply product filters and check the product count Ads Manager shows.
5. Review the bid strategy.
6. Create one ad template for the ad group.
7. Review the sample product preview, then submit for review.

The developer guide shows how the three levels divide the work:

| Level | What you configure |
|---|---|
| Campaign | Product feed, objective, budget, schedule and targeting |
| Ad group | Bid configuration and optional product filters |
| Ad | Product-ad template |

**Decisions you cannot undo**

OpenAI states that the campaign's mode, objective and linked feed cannot be changed after creation. Choose them before you create the campaign. In the API the mode value is `product_feed`.

The feed must belong to the same ad account as the campaign. A feed also cannot be archived while it is attached to a non-archived campaign or ad group. Pausing those is not sufficient.

**Targeting is country level**

New product-feed campaigns support geographic targeting and exclusions only at country level. The campaign help article adds that existing product-feed campaigns were not automatically changed, so earlier sub-national selections may remain, but new ones cannot be added.

**What the ad template does**

The template is the base for every eligible product in the ad group. In Ads Manager it currently only supports making a selection for your image field, and only one template is necessary per ad group. Titles and descriptions come from the feed, which is why the preview step matters.

In the API, the template has the creative type `product_ad_template` and uses four macros, written inside double curly braces: brand, product title, product body and product price. You can combine supported macros with text in the title, for example the brand followed by the product title. The selected product supplies the image and destination URL. Each product-feed ad group can contain at most one non-archived product-ad template.

**Tracking parameters**

To add tracking parameters to product URLs, the developer guide points to `landing_page_configuration` on the campaign, ad group or ad. OpenAI's help center lists supported macros including `{campaign_id}`, `{ad_group_id}`, `{ad_id}` and `{ad_account_id}`, filled in at delivery time. Our guide to [URL parameters](https://www.chatadsai.com/guides/chatgpt-ads-url-parameters) covers the syntax.

**Everything starts paused in the API**

Campaigns, ad groups and ads created through the API are created paused so you can inspect them. Delivery can begin once reviews, product availability, budget and other serving requirements are satisfied. If it does not, see [why ChatGPT ads are not serving](https://www.chatadsai.com/guides/chatgpt-ads-not-serving).

## How do product filters and custom labels work?

A product set is a list of filters on an ad group that decides which products from the campaign's feed that ad group may use.

The campaign owns the feed selection and the ad group inherits it. If you add no filters, the ad group uses the whole feed.

Each filter has a field, an operator and a list of values. OpenAI's examples select products by brand, category, price and item ID, with operators such as `in` for a list of brands and `lte` for an upper price bound. Values are sent as strings, including numbers.

Three rules from the developer guide:

- **Filters combine.** Each product must satisfy the filters together.
- **Updates replace.** Treat the filters in an update as the complete desired list, and include the ones you want to keep.
- **Matching is not delivery.** Matching a filter does not guarantee that a product will receive impressions.

**Custom labels**

When built-in attributes are not enough, put your own grouping in the feed. OpenAI's help article suggests values such as `bidding_tier` or `product_line` inside each product's `ads_metadata`, then filtering on them in the ad group.

Two cautions. The spec says not to invent targeting keys and to confirm them during Ads setup. And a label only selects products. In OpenAI's own example, a label of WA selects the products carrying that label, and does not restrict delivery to users in Washington. Location belongs in campaign targeting.

Our judgment: decide the grouping logic in your catalog data, where it can be versioned and reviewed, and keep the ad groups as thin selections on top of it.

**If no products match**

Query the feed with an empty filter list first. If products appear, add filters one at a time to find the condition that excludes them. If the unfiltered result is empty, check upload history. Remember that catalog updates can change which products satisfy a filter, for example after a price change.

## Which bidding options work with product feed campaigns?

Product-feed campaigns can use impressions, clicks or conversions objectives, and both Maximize results strategies are available for them.

**Maximize results.** In Ads Manager it is selected by default for eligible new ad groups. ChatGPT Ads adjusts bids to get as many clicks or conversions as possible within your budget. OpenAI states that it prioritizes result volume and does not guarantee delivery against a specific CPA, CPC or ROAS target. To stay within a specific bid limit, select the manual max bid option.

**Conversion bidding.** The developer documentation states that conversion-optimized cost-per-click, or oCPC, is in open beta for both standard and product-feed campaigns. The conditions:

- Conversion tracking is set up with the pixel, the Conversions API, or both.
- Exactly one active standard conversion event is attached when the campaign is created. Custom events cannot be optimization goals.
- The goal and event cannot be changed after creation.
- The ad account supports conversion bidding.

In an oCPC campaign you still pay per valid click, not per conversion. The ad group's maximum bid is read as a CPA bid. OpenAI's example: `100000000` micros is a 100.00 USD CPA bid for a USD account. OpenAI calls that bid an optimization input, not a conversion charge.

The Ads Manager help article also describes a choice between click billing and impression billing for the Conversion optimization objective, and says impression billing is currently in beta. It adds that there is no recommended bid amount at this time.

**About the numbers in OpenAI's example.** The product feed walkthrough uses a 50 USD daily budget and a 2 USD maximum bid. OpenAI labels both as illustrative amounts for a USD account. They are not minimums or recommendations.

Conversion bidding depends on clean measurement. Set up [conversion tracking](https://www.chatadsai.com/guides/conversion-tracking) and consider [automatic advanced matching](https://www.chatadsai.com/guides/automatic-advanced-matching) first, then read [conversion campaigns](https://www.chatadsai.com/guides/chatgpt-ads-conversion-campaigns) for the full mechanics. For budgets and pricing models, see [ChatGPT Ads cost](https://www.chatadsai.com/guides/chatgpt-ads-cost).

## How do you report on individual products?

Use product-segmented Insights in the API, or the Products tab in Ads Manager, to see which items received impressions and clicks.

The Insights API accepts a product segment and returns fields such as the feed ID, item ID, title, impressions, clicks, spend and CTR per product. OpenAI recommends matching results to your catalog with the feed ID and item ID together, since titles are only there for readability.

Two limits to plan around:

- Product reports do not support hourly granularity. Use daily reporting to follow changes over time.
- Products with no impressions are not included unless you request zero-impression product rows.

**Product cards in multi-product ads**

For product-feed ads that show multiple product cards, the API offers two more fields: `product.carousel_product_card_impressions` and `product.carousel_product_card_clicks`. They measure interactions with individual cards.

OpenAI states that a card impression is not a billable ad impression, and that card clicks are distinct from the ad click metric. So do not divide spend by card impressions to get a cost per thousand. Use card metrics to compare products with each other, and billable impressions for cost.

For purchase value and return on ad spend, OpenAI points to conversion reporting. Our guide to [reporting and privacy](https://www.chatadsai.com/guides/ads-reporting-and-privacy) explains those views.

## Why is the Products tab empty after a successful upload?

Because the Products tab is a reporting view, not an inventory. A product appears there only after it has delivery data from an active product-feed campaign.

If the campaign has not started, has a future start date, or has not yet delivered, the tab may be empty or show fewer products than the feed contains. OpenAI says this does not necessarily mean the upload failed.

| What you are checking | Where to look | Timing |
|---|---|---|
| Feed readiness | Product count in the ad-group flow | During setup |
| First product rows | Products tab | Up to seven hours after delivery begins |
| Impressions, clicks, CTR | Campaign reporting | About every 15 minutes |
| Spend | Campaign reporting | Delayed about 7 to 8 hours |

If expected products are still missing after the campaign has delivered, OpenAI asks you to contact support with the ad account ID, feed ID, campaign and ad-group names, date range and time zone, example product IDs and a screenshot of the Products tab.

## Does an ads feed put your products in organic ChatGPT shopping results?

No. During the beta, products from an Ads Manager feed are eligible for ads only. Organic product results are selected separately.

OpenAI's shopping help article states that product results are selected independently by ChatGPT and are not ads, nor influenced by any OpenAI partnerships. When choosing products, ChatGPT considers the query and context, structured metadata from first-party and third-party providers, model responses generated before new search results, and OpenAI safety standards.

A few points from that article matter to merchants:

- **Listings may be rewritten.** ChatGPT may generate simplified product titles and descriptions, and labels such as "Budget-friendly" that are not verified statements.
- **The first price is not always the lowest.** Prices in the initial response typically reflect the first merchant listed.
- **Merchants are ranked.** Factors include availability, price, quality, and whether the merchant is the maker or primary seller.
- **Updates can lag.** OpenAI acknowledges there may be some delay before price changes are reflected.

**Three routes into organic results**

**Shopify.** OpenAI states that for merchants on Shopify, product data is already integrated into ChatGPT through Shopify Catalog, and that no additional work is required from individual merchants.

**A direct commerce feed.** Other merchants can apply for direct feed access. OpenAI's get-started guide generally recommends providing the entire feed once a day via file upload, then sending updates through the day via the API. Small feeds can use the API for both. Promotions data can only be provided via the API, which has three surfaces: Feeds, Products and Promotions.

**The open web.** Shopping research, which OpenAI introduced on November 24, 2025, builds a buyer's guide from merchant data provided through the Agentic Commerce Protocol, publicly available product information and other retail sources. OpenAI notes that some retailers block automated access, and when that happens shopping research will skip those sources or rely on other sites.

The Agentic Commerce Protocol is the open standard OpenAI announced on September 29, 2025 together with Instant Checkout, and co-developed with Stripe. Checkout is a separate step from a feed: the spec says checkout requires a separately enabled integration, and that setting an eligibility flag does not complete checkout onboarding.

If you use a commerce feed, OpenAI's best-practices page suggests adding a feed attribution parameter to the product URL, for example `utm_medium=feed`, and keeping tracking parameters consistent across snapshots.

For the unpaid side as a whole, read [how to appear in ChatGPT answers](https://www.chatadsai.com/guides/how-to-appear-in-chatgpt-answers).

## Which products are not allowed in a feed?

OpenAI's commerce guide allows only products and services that are legal, safe and appropriate for a general audience.

Its list of prohibited products includes, among others, adult content, age-restricted products such as alcohol, nicotine and gambling, harmful or dangerous materials, weapons, prescription-only medications, unlicensed financial products, legally restricted goods, illegal activities and deceptive practices. OpenAI may remove a product or ban a seller from being surfaced in ChatGPT if these policies are violated.

Ads have their own rules on top. Every product ad still goes through ad review, so read [ChatGPT Ads policies](https://www.chatadsai.com/guides/chatgpt-ads-policies) before you upload a catalog with borderline categories.

## What should you check before you launch?

Run through the feed, the campaign and the measurement in that order.

**Feed**

- Every row has the nine required fields, with current field names.
- `is_ads_eligible` is true for the products you want to advertise.
- Prices use the amount and currency code format, and match the live site.
- Unavailable products are marked `out_of_stock`, not deleted.
- The refresh is automated, so items do not reach the two-week expiry.
- `OAI-AdsBot` and `OAI-SearchBot` can reach product pages and the image host.

**Campaign**

- The correct feed is selected, and the campaign type and objective are final.
- The product count matches the set you intended.
- Titles, descriptions, images and landing pages look right in the preview.
- Budget, bid strategy and country targeting are complete.

**Measurement**

- Conversion events are in place and tested.
- URL parameters are set where you need them.
- Someone owns the weekly product report.

Common mistakes we would avoid, based on the documentation above:

1. Treating the ads feed as an organic listing. It is not, during the beta.
2. Uploading once by hand and forgetting the expiry.
3. Deleting rows to stop a product, in place of marking it out of stock.
4. Sending Delta API prices in major units, or in micros.
5. Reading an empty Products tab as a failed upload.
6. Using a label such as a region code and expecting it to target a location.

If you would rather hand over the feed and campaign work, see our [services](https://www.chatadsai.com/services) and [pricing](https://www.chatadsai.com/pricing), or [contact us](https://www.chatadsai.com/contact).

## Frequently asked questions

**What file format does a ChatGPT product feed use?**

In Ads Manager you can upload a CSV or TXT file, point to a hosted URL, or connect over SFTP. OpenAI's ads developer guide describes a UTF-8 CSV with one row per product item or variant. For the commerce file-upload path, OpenAI prefers Parquet and also supports `jsonl.gz`, `csv.gz` and `tsv.gz`.

**How many fields are required?**

The products spec asks for nine required fields in basic product data: `item_id`, `title`, `description`, `url`, `brand`, `seller_name`, `image_url`, `availability` and `price`. For ads, `is_ads_eligible` is conditionally required for Ads processing.

**How often do I need to update the feed?**

Often enough that items never expire. OpenAI states that items expire after two weeks and recommends a hosted URL or automated SFTP uploads. For snapshot feeds, its recommended cadence is at least daily.

**How do I remove a product from ads?**

Set its availability to `out_of_stock`, through the Delta API or in the next catalog upload. You can also mark an item false for ads eligibility. OpenAI's update guidance is to keep the product in the file and mark it, not to drop the row.

**Can I use a Google Merchant Center file?**

Possibly. OpenAI documents a Google-compatible profile with columns such as `id`, `link` and `image_link`, but says to use it only after OpenAI confirms it for your registered feed. On that path, eligibility comes from registered feed settings, not from uploaded flags.

**Can product feed campaigns optimize for purchases?**

Yes. OpenAI states that product-feed oCPC is available in open beta. You need conversion tracking and exactly one active standard conversion event, such as `order_created`. You are still billed per valid click.

**Can I target a city or region with a product feed campaign?**

Not in new campaigns. OpenAI states that new product-feed campaigns support geographic targeting and exclusions only at country level.

**Do I need a feed if my shop is on Shopify?**

For organic results, OpenAI says Shopify product data is already integrated through Shopify Catalog. For product feed ads, you still create a feed in Ads Manager, because that is where a product feed campaign gets its products.

**Does OpenAI publish a minimum catalog size, budget or bid for feed campaigns?**

We did not find one in the OpenAI pages listed under sources. The only amounts in the product feed walkthrough are labeled illustrative, and the help center says there is no recommended bid amount at this time.

**Will my feed products appear in shopping research?**

Not from the ads feed. Shopping research uses merchant data provided through the Agentic Commerce Protocol, public product information and other retail sources. Keeping your product pages open to automated access helps, since OpenAI says blocked sources are skipped.

## Sources

- [OpenAI Help Center - Create Campaigns from Product Feeds](https://help.openai.com/en/articles/20001268-create-campaigns-from-product-feeds)
- [OpenAI Developers - Product Feeds](https://developers.openai.com/ads/product-feeds)
- [OpenAI Developers - Products](https://developers.openai.com/commerce/specs/file-upload/products)
- [OpenAI Developers - File upload overview](https://developers.openai.com/commerce/specs/file-upload/overview)
- [OpenAI Developers - Commerce API overview](https://developers.openai.com/commerce/specs/api/overview)
- [OpenAI Developers - Get Started](https://developers.openai.com/commerce/guides/get-started)
- [OpenAI Developers - Best practices](https://developers.openai.com/commerce/guides/best-practices)
- [OpenAI Developers - Conversion-Optimized Campaigns](https://developers.openai.com/ads/conversion-optimized-campaigns)
- [OpenAI Developers - Reporting](https://developers.openai.com/ads/reporting)
- [OpenAI Developers - Bidding and Budgets](https://developers.openai.com/ads/bidding-and-budgets)
- [OpenAI Developers - Campaign Management](https://developers.openai.com/ads/campaign-management)
- [OpenAI Developers - Overview of OpenAI Crawlers](https://developers.openai.com/api/docs/bots)
- [OpenAI Help Center - Advertiser Guidance for Allowing OpenAI Web Crawlers](https://help.openai.com/en/articles/20001243-advertiser-guidance-for-allowing-openai-web-crawlers)
- [OpenAI Help Center - Measure Results](https://help.openai.com/en/articles/20001214-measure-results)
- [OpenAI Help Center - Create Campaigns for ChatGPT Ads](https://help.openai.com/en/articles/20001210-create-campaigns-for-chatgpt-ads)
- [OpenAI Help Center - Maximize Results Bid Strategy](https://help.openai.com/en/articles/20001425-maximize-results-bid-strategy)
- [OpenAI Help Center - Conversion-optimized Campaigns](https://help.openai.com/en/articles/20001412-conversion-optimized-campaigns)
- [OpenAI Help Center - Quickstart: Launch Your First Campaign](https://help.openai.com/en/articles/20001224-quickstart-launch-your-first-campaign)
- [OpenAI Help Center - Shopping with ChatGPT Search](https://help.openai.com/en/articles/11128490-shopping-with-chatgpt-search)
- [OpenAI Help Center - Using shopping research in ChatGPT](https://help.openai.com/en/articles/12911370-using-shopping-research-in-chatgpt)
- [OpenAI - Introducing shopping research in ChatGPT](https://openai.com/index/chatgpt-shopping-research/)
- [OpenAI - Buy it in ChatGPT: Instant Checkout and the Agentic Commerce Protocol](https://openai.com/index/buy-it-in-chatgpt/)