How Do You Get Your Products Into ChatGPT in 2026?
You share a structured product feed with OpenAI under the Agentic Commerce Protocol, after being accepted as an approved partner. OpenAI states that onboarding product feeds in ChatGPT is currently available to approved partners, with applications through chatgpt.com/merchants. Once accepted, you deliver product data by file upload, by API, or both, so ChatGPT can index your catalogue and show accurate titles, descriptions, images, price and availability in shopping experiences.
A feed is the foundation for three separate things, and each has its own switch: appearing in search and shopping answers, appearing in ChatGPT Ads, and being purchasable through checkout inside ChatGPT. Most coverage blurs these together. OpenAI's specification keeps them strictly apart, and so does this guide. Below, it covers the feed itself, agentic checkout, promotions and the production launch checklist; field-by-field requirements are in our product feed field requirements guide.
Explain It Like I Am Five
Imagine a very helpful shop assistant who does not own a shop. People ask the assistant what to buy, and the assistant can only recommend things it has a list of. Your product feed is the list you hand over: what each thing is, what it costs, and whether it is on the shelf. A good list means the assistant can recommend you. A list with mistakes means it cannot. If you also build a till the assistant is allowed to use, people can pay without leaving the conversation, but the money still goes to your shop, and you still handle returns. And right now, only shops the assistant has invited can hand over a list at all.
| Capability | What it requires in 2026 | Default |
|---|---|---|
| Discovery in ChatGPT search and shopping | Approved-partner feed with nine required fields per row | Search eligibility on when omitted |
| ChatGPT Ads | Feed rows marked Ads-eligible plus an Ads integration | Off unless a feed-level Ads default applies |
| Checkout inside ChatGPT | A separately enabled integration implementing the Agentic Checkout Spec | Off |
| Promotions | The promotions API | None; not deliverable by file |
What Is the Agentic Commerce Protocol in 2026?
The Agentic Commerce Protocol, or ACP, is the set of specifications OpenAI uses for commerce flows in ChatGPT, covering product feeds, agentic checkout and delegated payment. OpenAI points to agenticcommerce.dev and a public GitHub repository for the protocol itself, and publishes its implementation docs at developers.openai.com/commerce, including a machine-readable index at /commerce/llms.txt and Markdown versions of every page.
It is a different protocol from Google's Universal Commerce Protocol, which we covered in our UCP guide. For a brand, the strategic point is that AI shopping surfaces are converging on structured, machine-readable catalogue data with strict validation, whichever vendor is asking. Our broader guide to preparing a brand for AI shopping agents covers that strategy layer; this series covers OpenAI's actual specification.
Who Is Eligible to Use ChatGPT Product Feeds in 2026?
Approved partners, in markets OpenAI has confirmed for their integration, selling products that pass OpenAI's prohibited products policy. Each of those three conditions removes a meaningful share of brands, and it is better to know which applies to you before investing engineering time.
| Gate | What OpenAI states in 2026 | What it means for you |
|---|---|---|
| Partner approval | Feed onboarding is currently available to approved partners; apply at chatgpt.com/merchants. | You can build to the spec, but not switch it on without acceptance. |
| Market | The standard OpenAI-format upload currently targets the US; the shared format represents US, CA and MX; other markets only after OpenAI confirms them. | An Indian feed does not reach Indian shoppers by default. |
| Product policy | Prohibited products include, among others, adult content, age-restricted products such as alcohol, nicotine and gambling, weapons, prescription-only medications, unlicensed financial products and deceptive practices. | OpenAI may remove products or ban a seller for violations. |
| Checkout payments | The checkout spec lists stripe, adyen and braintree as providers and card as the payment method. | UPI-led checkout is not in the current spec. |
Today, the published specification is built around a US default market and card payments through three named providers. That does not make the work pointless for an Indian brand: a clean, validated feed is reusable across every AI shopping surface, and brands selling into the US are directly in scope. But a brand whose customers are mostly in India and pay mostly by UPI should treat ChatGPT checkout as a watch item rather than a 2026 launch, and should ask OpenAI directly about market availability before committing budget.
How Should You Deliver a Product Feed in 2026?
OpenAI's recommended pattern is the full feed once a day by file upload, then updates through the day by API. If your feed is small, you can provide both the full feed and regular updates via the API. File upload is delivered to an SFTP server, and for file upload you overwrite the same file or shard set with your latest snapshot on a regular cadence. For the API, you upsert products.
- Decide on file upload, API, or both.
- Review the specs for that method and confirm required fields, canonical field names and validation rules.
- Validate required fields for every record.
- Upload through the chosen method.
- Keep the feed current by overwriting snapshots or upserting through the API.
One exception changes the plan for most retailers: OpenAI states that promotions data can only be provided via the API. If discounts matter to your conversion, a file-only integration cannot carry them. The promotions section covers the schema and its three supported benefit types.
What Does a Product Feed Have to Contain in 2026?
Nine fields per row, one row per purchasable item or variant: item_id, title, description, url, brand, seller_name, image_url, availability and price. Two rules cause most rejected rows. Availability is a closed list, and omitted, empty or unrecognised values reject the row. Prices are written as an amount and a three-letter currency code, such as 79.99 USD, with no thousands separators.
The API product schema is structured differently, with products holding a list of variants and money expressed as integer minor units with a separate currency. Teams that use both delivery methods need two formatters, not one. The full field reference, including variants, returns, reviews and the Google-compatible feed path, is in our product feed requirements guide.
| Delivery method | Money format in 2026 | Structure |
|---|---|---|
| File upload (OpenAI format) | 79.99 USD as a string in major units | One flat row per item or variant |
| API | Integer amount in ISO 4217 minor units plus currency | Product with nested variants |
| Google-compatible file | Decimal amount and currency, normalised to two places | Merchant Center style columns, after OpenAI confirms the format |
How Does Checkout Inside ChatGPT Work in 2026?
You host five HTTPS endpoints that ChatGPT calls to create, update, complete, cancel and retrieve a checkout session, and each response returns the full, authoritative cart. Payment runs through your existing PSP using a single-use delegated token, and you send signed webhooks when orders are created and updated. OpenAI is not the merchant of record: customers see your name on their card statement, and refunds and chargebacks stay with you.
Direct integration with the Delegated Payment Spec is only for PSPs or PCI DSS level 1 merchants using their own vaults; everyone else uses their PSP's implementation, with Stripe's Shared Payment Token named as the first compatible one. The endpoint-level detail is in the agentic checkout section, and the tests OpenAI requires before you go live are in the production section.
How Does an Agentic Checkout Flow Work?
OpenAI describes the flow in six steps, and the direction of each call matters: ChatGPT calls you, and you call OpenAI only for webhooks. Every session response must return the full cart state, including items, pricing, taxes and fees, shipping, discounts, totals and status.
- Create session. ChatGPT calls your
POST /checkout_sessionswith cart contents and buyer context. - Update session. As the shopper changes items, shipping or discounts, ChatGPT calls
POST /checkout_sessions/{checkout_session_id}and you return the full cart again. - Order events. Your system publishes lifecycle events such as order created and order updated to the webhook OpenAI provides.
- Complete checkout. ChatGPT finalises with
POST /checkout_sessions/{checkout_session_id}/complete, and you confirm the order and return the final cart and order identifiers. - Cancel or retrieve. Optionally,
POST /checkout_sessions/{checkout_session_id}/cancelandGET /checkout_sessions/{checkout_session_id}. - Payments on your rails. You process payment with your existing PSP, accepting the delegated token if you use Delegated Payments.
OpenAI also notes that in the future the Agentic Checkout Spec will support MCP servers.
What Must Every Checkout Endpoint Handle?
Every endpoint must use HTTPS and return JSON, and every request from ChatGPT arrives with the same set of headers. Those headers are where most of the security and reliability work lives, because they carry authentication, the signature over the request body, the idempotency key, and the API version you must check.
| Header | What it carries | What you must do with it |
|---|---|---|
Authorization | API key used to make requests | Authenticate every request. |
Signature | Base64-encoded signature of the request body | Verify it before acting. |
Timestamp | RFC 3339 time | Use it as part of request validation. |
Idempotency-Key | Key ensuring requests are idempotent | Return the same result for safe duplicates; echo it in the response. |
Request-Id | Unique key for tracing | Log it and echo it in the response. |
API-Version | API version, for example 2025-09-12 | Confirm it is present and matches a supported version. |
Accept-Language | Preferred locale for messages and errors | Localise customer-facing messages. |
What Does the Cart State Have to Contain?
Your create, update, complete and cancel responses all return the same shape: an ID, a status, a currency, line items, fulfilment options, totals, messages and links, with buyer and address details where present. The status values are not_ready_for_payment, ready_for_payment, completed and canceled. Currency follows ISO 4217 in lower case.
The arithmetic is specified, not left to interpretation. A line item's subtotal must equal base_amount - discount, and its total must equal base_amount - discount + tax, with every amount an integer of zero or more. Totals use types such as items_base_amount, items_discount, subtotal, discount, fulfillment, tax, fee and total, expressed in minor units. If your platform rounds tax per order but the spec expects per-line values that sum, this is where a build discovers it.
POST Request to /checkout_sessions
{
"items": [
{
"id": "item_123",
"quantity": 1
}
]
}
That is OpenAI's own first example: a session created with a single item and no fulfilment address, which therefore cannot yet be completed. One detail worth checking when you implement: the example response in the same document shows a status of in_progress, which is not among the four status values the response table lists. Confirm the expected value with OpenAI during onboarding rather than coding to either.
How Do Shipping, Messages and Errors Work?
Fulfilment options come in two types, shipping and digital. A shipping option needs a title, a subtitle describing the timeline, a carrier, earliest and latest delivery times in RFC 3339, and a subtotal, tax and total where total equals subtotal plus tax. OpenAI's production guide notes the protocol models a single shipping address and one selected shipping option per session, and advises consolidating split shipments into a single buyer-visible selection with aggregate totals.
Problems are surfaced to the shopper as messages, not just HTTP errors. An error message carries a code from missing, invalid, out_of_stock, payment_declined, requires_sign_in and requires_3ds, plus an RFC 9535 JSONPath such as $.line_items[1] pointing at the part of the session it concerns. When a request cannot succeed at all, you return an error object with a 4xx or 5xx status.
| Object | Key fields in 2026 | Constraint worth knowing |
|---|---|---|
Address | name, line_one, city, state, country, postal_code | line_one and city max 60 characters; state and country follow ISO 3166-1. |
Buyer | name, email, optional phone_number | Phone numbers follow E.164. |
Link | type and url | Types are terms_of_use, privacy_policy, seller_shop_policies. |
PaymentData | token, provider, optional billing_address | Provider is stripe, adyen or braintree. |
Order | id, checkout_session_id, permalink_url | Customers should reach the order by providing at most their email address. |
How Do Delegated Payments Work?
The Delegated Payment Spec lets OpenAI share payment details securely with you or your PSP. The shopper saves a payment method in ChatGPT, a single-use payload with an allowance is sent to your PSP or vault, the PSP returns a token scoped to that payment, and OpenAI forwards the token on the complete call. OpenAI is not the merchant of record, and settlement, refunds, chargebacks and compliance stay with you and your PSP.
Who should integrate directly is stated precisely: direct integration is only for PSPs or PCI DSS level 1 merchants using their own vaults. For everyone else, OpenAI points to Stripe's Shared Payment Token as the first compatible implementation. The allowance is tight by design, with a reason that must be one_time, a max_amount, a currency, the checkout session and merchant IDs, and an expires_at timestamp.
On PCI scope, OpenAI's production guide says the feed and checkout specs are deliberately kept out of PCI scope and do not transmit cardholder data. Using your PSP's implementation of delegated payments may avoid any change in scope, while forwarding APIs or direct integration involve cardholder data and will likely be in scope. OpenAI says it may require your attestation of compliance before enabling production access, and recommends consulting your PSP and Qualified Security Assessor.
What Do the Webhooks Have to Send?
You send OpenAI webhook events on order creation and update so the buyer's view stays in sync, signed with an HMAC signature in a request header. Event types are order_created and order_updated. Order status values are created, manual_review, confirmed, canceled, shipped and fulfilled, and each event carries a list of refunds typed as store_credit or original_payment.
OpenAI's production FAQs add the operational consequence: because you are the merchant of record, you handle refunds and chargebacks, and you should use the order update webhook to notify ChatGPT when a refund or chargeback status changes. Customers see your name on their card statement, as if they bought directly from your site.
Who Should Build Agentic Checkout?
Teams whose payments already run on Stripe, Adyen or Braintree, whose customers mostly pay by card, and whose products and market are within what OpenAI has confirmed for their integration. For many Indian D2C brands, at least one of those conditions fails today. That does not make the specification irrelevant: the feed work is reusable, and knowing exactly what checkout requires lets you decide when it becomes worth building rather than guessing.
| Readiness question for 2026 | If yes | If no |
|---|---|---|
| Accepted as an approved partner? | Proceed to integration planning. | Apply at chatgpt.com/merchants; prepare the feed meanwhile. |
| PSP is Stripe, Adyen or Braintree? | Use the PSP's delegated payment path. | Checkout is not buildable on the current spec. |
| Customers pay mostly by card? | Checkout matches demand. | Weigh demand before building; the spec accepts card only. |
| Can you compute per-line tax and totals that sum exactly? | Cart state is straightforward. | Fix pricing logic first. |
| Can you sign, verify, and handle idempotency? | Security work is incremental. | Plan engineering time for it. |
The production section covers the certification tests OpenAI requires before launch.
What Are the Common Mistakes With Agentic Checkout?
- Scoping a build before checking the payment provider. The spec lists Stripe, Adyen and Braintree, and card only.
- Treating ChatGPT as the merchant of record. It is not. Refunds, chargebacks and compliance stay with you.
- Returning partial cart state. Every response must return the full cart, not a diff.
- Letting totals drift by rounding. Subtotal and total rules are arithmetic, not guidance.
- Skipping signature verification and idempotency. Both are required and both are tested before launch.
- Assuming direct delegated payments are simpler. Direct integration is for PSPs and PCI DSS level 1 merchants only.
- Coding to an example instead of the schema. Where they disagree, confirm with OpenAI.
How Does the Feed Connect to ChatGPT Ads in 2026?
Through the same product data, with its own eligibility flag. In the OpenAI file format, is_ads_eligible set to true marks a product for Ads processing; omitted or empty means disabled unless a feed-level Ads default applies, and it is independent of search eligibility. Ads feeds follow OpenAI's Ads product feeds guide, and the optional ads_metadata field carries product-filter keys configured for your Ads integration, which OpenAI says you should confirm during Ads setup rather than invent.
For marketers this is the most immediately actionable part of the stack, because a feed that is already validated for discovery can be extended for Ads without a checkout build. Our ChatGPT Ads API guide covers campaign structure, bidding and the controls you actually have.
What Can You Not Control in ChatGPT Shopping in 2026?
Whether you are shown. OpenAI's specification says it in five words on the search eligibility flag: eligibility does not guarantee display. A valid, approved, fully populated feed makes your products available to be considered; it does not buy placement, and nothing in the commerce documentation describes a ranking you can configure. Paid placement is a separate product, ChatGPT Ads, with its own controls.
Several other things sit outside a merchant's control in the published specification, and it is better to plan around them than discover them.
| Outside your control | What the documentation says in 2026 | What you can do instead |
|---|---|---|
| Display | Eligibility does not guarantee display. | Improve data quality; use Ads for paid placement. |
| Acceptance | Feed onboarding is currently for approved partners. | Apply early and prepare the feed in parallel. |
| Market | Additional markets apply only after OpenAI confirms them. | Ask directly about your country and currency. |
| Enforcement | OpenAI may remove a product or ban a seller for policy violations. | Audit your catalogue against the prohibited list before submitting. |
| Scheduling | Sale-window, expiration and availability dates do not schedule price or stock changes. | Push updates yourself when prices and stock change. |
| Reconciliation | Conflicting values between top-level attributes and variant options are not reconciled for you. | Keep one source of truth and validate before upload. |
How Do You Improve the Quality of Your ChatGPT Listings in 2026?
By writing for an answer engine rather than a product grid. OpenAI's best-practice guidance asks for concise, factual descriptions, accepting both plain text and bullet-style text. It notes that optional fields such as description.html, description.markdown, categories.taxonomy and seller.links can improve answer quality but are not required for ingestion, and it adds a sensible caution: if an optional field needs brittle transforms, omit it until the data is stable.
This is where the work overlaps with what Distk does for AI search visibility more broadly. A model choosing between products leans on specific, checkable attributes: material, dimensions, condition, return terms, review aggregates. Marketing copy that says "premium quality" gives it nothing to extract. A description that states what the product is made of, how big it is, and what happens if the customer returns it gives it everything. Variant-specific titles, URLs, images, availability and prices, which OpenAI asks for whenever those values differ by variant, matter for the same reason: an answer that recommends the right size in the wrong colour is worse than no answer.
- State facts, not adjectives. Material, size, weight, compatibility and care instructions.
- Declare condition explicitly. Omitted condition may be treated as new; used and refurbished must always be declared.
- Supply returns data properly. Acceptance, window in days, and a policy URL, as separate fields.
- Use consistent seller attribution. One seller name and durable public policy links across the catalogue.
- Encode URLs correctly. OpenAI asks for valid, encoded URLs, for example
%20for spaces.
What Should a Brand Do First in 2026?
Apply, clean the catalogue, and measure, in that order. The application decides whether anything else happens. The catalogue work pays off on every AI shopping surface regardless of whether OpenAI accepts you this quarter. And measurement is the only way to know whether the channel is worth the checkout build later.
| Step | Why it comes now in 2026 | Owner |
|---|---|---|
| Apply at chatgpt.com/merchants | Nothing goes live without approval. | Founder or e-commerce lead |
| Ask about your market | The default target is the US; confirm yours before budgeting. | Founder |
| Audit availability and price exports | The two most common causes of rejected rows. | Catalogue owner |
| Stabilise item, group and offer IDs | Promotions and variants depend on them. | Engineering |
| Add feed attribution to product URLs | OpenAI recommends parameters such as utm_medium=feed; without them the channel is invisible in analytics. | Marketing |
| Decide on promotions | API-only, so it shapes the integration choice. | Marketing and engineering |
| Check checkout fit last | Payment provider and payment method support decide whether it is buildable. | Finance and engineering |
Why Are Promotions in ChatGPT Shopping API-Only?
Because OpenAI's integration guide says so in one plain sentence: "Promotions data can only be provided via the API." The same guide recommends providing the entire product feed once a day by file upload and sending updates through the API during the day. That pattern works for products. For promotions, the file-upload half does not exist, so a team planning a daily feed with discounts baked in has to build an API path regardless of feed size.
This is easy to miss because most commerce teams think of a sale as a column on a product row. In OpenAI's model, a promotion is its own object with its own endpoint, its own identity and its own time window, linked to products by reference. The usual gate applies: feed onboarding in ChatGPT is currently available to approved partners via chatgpt.com/merchants.
What Is a Promotion Object?
A promotion is a record with an identifier, a title, an active period, and one or more benefits, plus optional description, status, product targets and URL. Four fields are required: id, title, active_period and benefits. Everything that ties a promotion to particular products, the applies_to list, is optional in the schema.
| Field | Type | Required | What it does in 2026 |
|---|---|---|---|
id | string | Yes | Promotion identifier; upserts are matched by it. |
title | string | Yes | Promotion title. |
description | Description | No | At least one of plain, html or markdown when supplied. |
status | PromotionStatus | No | Known values: draft, scheduled, active, expired, disabled. |
active_period | DateTimeRange | Yes | Required start_time and end_time. |
benefits | PromotionBenefit[] | Yes | One or more of amount off, percent off, free shipping. |
applies_to | ProductTarget[] | No | Products, and optionally specific variants, targeted. |
url | string (uri) | No | Canonical promotion URL. |
What Kinds of Discounts Can a Promotion Express?
Three, and only three. PromotionBenefit is a union of AmountOffBenefit, PercentOffBenefit and FreeShippingBenefit. That covers the large majority of retail promotions and excludes the structured ones that are common in Indian D2C, such as buy-two-get-one, bundle pricing, tiered spend thresholds and gift-with-purchase. Those either need to be expressed as one of the three types or left out of the promotion feed.
| Benefit type | Required fields | Example use in 2026 |
|---|---|---|
amount_off | type, amount_off as a Price | A flat discount in currency. |
percent_off | type, percent_off as a number | A percentage discount. |
free_shipping | type only | Shipping waived. |
Money inside a promotion follows the API convention, not the file-upload one. A Price is an integer amount in ISO 4217 minor units plus a currency. So a 200 rupee discount is the integer 20000 in minor units, not the string "200.00 INR". Reusing a file-feed price formatter here produces discounts a hundred times too large or too small.
How Do the Promotion Endpoints Work?
There are two: one to read and one to write. GET /product_feeds/{id}/promotions returns the promotions for a feed. PATCH /product_feeds/{id}/promotions upserts promotions into the feed, matched by id, and promotions not included in the request remain unchanged.
That last sentence shapes how you run promotions operationally. A PATCH is not a replace. Sending today's three live promotions does not remove yesterday's, because promotions not included are left untouched. Ending a promotion therefore means updating it, for example by changing its status or its active period, rather than omitting it from the next request.
| Response | When it is returned | What to do in 2026 |
|---|---|---|
200 OK on PATCH | Returns id and an accepted boolean | Check accepted, not just the status code. |
400 Bad Request | The promotion payload is invalid | Validate required fields and benefit shapes before sending. |
404 Not Found | The feed is not found | Confirm the feed ID belongs to your onboarded integration. |
How Should Promotions Connect to Products?
Through applies_to, a list of ProductTarget objects. Each target requires a product_id and optionally lists variant_ids within that product. That means your promotion targets only work if your product IDs are stable, which is the same identity discipline the product feed specification asks for: never reuse an ID for a different item, and keep IDs stable when price, stock, title or images change.
A separate point applies to the product rows themselves. The file-upload specification supports a sale_price on a product, which must be greater than zero, strictly below the regular price, and in the same currency. That is a price on the product, not a promotion object. Teams should decide deliberately which mechanism represents a given discount, rather than sending both and leaving the platform to reconcile them, because the specification states that neither representation reconciles conflicting values for you in related cases such as variant attributes.
How Do Common Indian D2C Offers Map to the Three Benefit Types?
Some map cleanly, some map with a compromise, and some have no representation at all. The table below applies only the three documented benefit types to offers that Indian D2C brands commonly run. It is our mapping of the schema, not guidance OpenAI has published, and anything marked as a compromise should be checked with OpenAI during onboarding before you rely on it.
| Offer you run | Closest documented benefit | Fit in 2026 |
|---|---|---|
| Flat 200 off on a product | amount_off | Clean fit. |
| 20 percent off sitewide or a category | percent_off with applies_to listing the products | Clean fit if you can enumerate the products. |
| Free delivery above no threshold | free_shipping | Clean fit. |
| Free delivery above a minimum order value | free_shipping | Compromise: the schema has no threshold field. |
| Extra discount for prepaid orders | None | No representation; payment-method conditions are not in the schema. |
| Buy two get one free | None | No representation. |
| Bundle price for a combo | None as a promotion | Consider listing the bundle as its own product with its own price. |
| Coupon code shared on Instagram | None documented | No code field in the schema; do not assume code support. |
The practical consequence for a festive-season calendar is that the offers you can describe to ChatGPT are a subset of the offers you actually run. That is not a reason to skip promotions, because the clean fits are usually the headline offers. It is a reason to decide in advance which offers you will represent, rather than discovering the gap when a Diwali campaign goes live.
What Does a Promotion Payload Look Like?
OpenAI's promotions page documents the schema but does not include a sample payload. The example below is our own illustration, assembled strictly from the documented field names, types and enum values, for a 15 percent discount on two variants of one product. Treat it as a shape to validate against the specification, not as an OpenAI example.
[
{
"id": "promo-diwali-15",
"title": "Diwali 15% off",
"status": "scheduled",
"active_period": {
"start_time": "2026-10-17T00:00:00+05:30",
"end_time": "2026-10-24T23:59:59+05:30"
},
"benefits": [
{ "type": "percent_off", "percent_off": 15 }
],
"applies_to": [
{ "product_id": "KURTA-COTTON", "variant_ids": ["KURTA-COTTON-M", "KURTA-COTTON-L"] }
]
}
]
Two things in that illustration deserve a check against your own integration. The specification describes start_time and end_time only as start and end timestamps without fixing a format, so confirm the expected timestamp format during onboarding. And the request body is an array of promotions, so a single promotion is still sent inside a list.
Why Does API-Only Change the Build Plan?
Because the cheapest integration most teams plan, a nightly file export dropped on a server, cannot carry promotions at all. If discounts matter to your conversion, and for most Indian D2C brands during festive season they matter a great deal, then an API integration is not optional work for a later phase. It is part of the minimum build.
- You need API credentials and a feed ID, which come with onboarding as an approved partner.
- You need a promotions source of truth in your own systems, with stable IDs and explicit start and end times.
- You need a process for ending promotions, because omitting one from a PATCH leaves it unchanged.
- You need a money converter for minor units, separate from any file-feed formatter.
- You need to map rich offers onto amount off, percent off or free shipping, or accept leaving them out.
What Are the Common Mistakes With ChatGPT Promotions?
- Planning promotions into a nightly file feed. OpenAI states promotions can only be provided via the API.
- Treating PATCH as replace. Promotions not included in a request remain unchanged.
- Formatting discounts as strings. Promotion money is an integer in minor units with a currency.
- Expecting buy-X-get-Y support. Benefits are amount off, percent off or free shipping.
- Targeting unstable product IDs.
applies_todepends on the same IDs your feed uses. - Ignoring the
acceptedflag. A 200 response still tells you whether the payload was accepted. - Representing the same discount twice as both a product sale price and a promotion without deciding which is authoritative.
What Is OpenAI's Agentic Commerce Production Checklist?
It is a list of tests OpenAI says you must complete and document in a sandbox before going live with agentic checkout, each demonstrated end to end with request and response logs. It covers session creation, shipping updates, payment tokenisation, order completion, order webhooks, error handling, idempotency, legal links and IP allowlisting. Alongside it sit security and PCI requirements and a short set of FAQs that settle who owns refunds and chargebacks.
A vendor-published launch checklist is unusually useful, because it tells you exactly what certification will look at. It also makes clear that checkout is an engineering project with a defined finish line rather than a plugin. This section assumes you have already been accepted as an approved partner via chatgpt.com/merchants, which OpenAI states is currently required for feed onboarding.
What Tests Must Be Demonstrated Before Launch?
Nine groups of tests, each with specific pass conditions. The table restates them as OpenAI lists them, with the evidence you should keep. Every item should be demonstrated end to end with logs, so plan to capture request and response pairs from the start rather than reconstructing them later.
| Test group | What OpenAI asks you to demonstrate in 2026 | Evidence to keep |
|---|---|---|
| Session creation and address handling | Create a checkout session with and without a shipping address; shipping options and tax totals returned once a valid address is provided; API-Version header present and supported. | Both request and response pairs, showing totals appearing after the address. |
| Shipping option updates | Update the selected shipping option and recompute order totals correctly. | Before and after totals. |
| Payment tokenisation | Create a delegated payment token via POST /agentic_commerce/delegate_payment with a valid payment_method, allowance, billing_address, risk_signals and metadata; all required headers; canonical JSON serialisation and correct detached signature. | Signed request, token response. |
| Order completion | Complete the order with a tokenised payment; final order object in the completed state; HTTP 201 Created. | Completion response with order object. |
| Order updates | order_created and subsequent order_updated webhooks sent with a valid HMAC signature. | Webhook payloads and signature verification. |
| Error scenarios | Trigger and log missing (for example invalid_request / 400), out_of_stock and payment_declined. | One logged example of each. |
| Idempotency | Repeat create and complete calls with the same Idempotency-Key: duplicates return the same result, mismatched parameters return idempotency_conflict with HTTP 409. | Paired duplicate calls and the 409. |
| Documentation and links | Terms of Service and Privacy Policy links present and functional. | Working URLs. |
| IP egress ranges | Allowlist OpenAI's published IP ranges, since OpenAI will call your action from them. | Firewall configuration. |
Why Do Idempotency and Error Handling Get Their Own Tests?
Because an agent retries. A conversational checkout has more places for a request to be repeated than a web checkout does, and the cost of a non-idempotent complete call is a double charge on a real customer. OpenAI's checklist tests both halves: identical duplicates must return the same result, and a reused key with different parameters must fail with idempotency_conflict and HTTP 409 rather than silently doing something new.
Error handling is tested for a related reason. In the checkout spec, errors such as out_of_stock and payment_declined are not only HTTP failures; they are messages surfaced to the shopper with a path to the part of the cart they concern. A store that returns a generic 500 when stock runs out gives ChatGPT nothing to tell the customer, and the session simply fails. The three named scenarios in the checklist are the three a real launch will hit in its first week.
What Are the Security Requirements?
Two are stated precisely. All traffic to you must use TLS 1.2 or later on port 443 with a valid public certificate. And OpenAI will call you from its published IP ranges, which you are expected to allowlist. The checkout specification adds the per-request discipline: authenticate every request, verify signatures, enforce idempotency, validate inputs and support safe retries.
PCI scope is where planning most often goes wrong, so OpenAI's wording is worth keeping close. The product feed and checkout specs are deliberately kept out of PCI scope and do not transmit cardholder data. Using your PSP's implementation of the Delegated Payment Spec may avoid any change in your PCI scope. Using your PSP's forwarding APIs, or integrating directly with OpenAI's delegated payment endpoints, involves handling cardholder data and will likely be in scope. OpenAI says it intends to migrate entirely to network tokens as they become supported, and that it may require your attestation of compliance before enabling production access.
OpenAI's guidance is to check with your PSP and consult your Qualified Security Assessor or other PCI compliance advisor about the impact on your specific obligations. If production access can depend on an attestation of compliance, that conversation belongs at the start of the project, not the week before launch.
Who Owns Refunds, Chargebacks and Shipping Questions?
You do. OpenAI's production FAQs are direct: the merchant actually selling the goods and taking payment is the merchant of record, not OpenAI or the payment provider, and customers see the merchant's name on their card statement as if they bought on the merchant's website. Because you accepted the payment, refunds and chargebacks are yours to handle.
- Sync state back. Use the order update webhook to notify ChatGPT when a refund or chargeback status changes, so order state stays synchronised.
- One shipment per session. The protocol currently models a single shipping address and one selected shipping option per checkout session.
- Consolidate split shipments. If your system splits orders across warehouses, present a single buyer-visible selection and return aggregate shipping and tax totals.
What Feed Quality Work Should Happen Before Launch?
Checkout only works on products ChatGPT already understands, so OpenAI's feed best practices belong in the same launch plan. They are short and practical, and each one prevents a specific class of bad listing.
| Best practice | What OpenAI recommends in 2026 |
|---|---|
| Descriptions | Concise, factual copy; plain text and bullet-style text are both acceptable. |
| Optional fields | Fields such as description.html, description.markdown, categories.taxonomy and seller.links can improve answer quality but are not required. If a field needs brittle transforms, omit it until data quality is stable. |
| URLs | Keep url, media.url and seller link URLs valid and encoded, for example %20 for spaces. |
| Seller attribution | Set seller.name to the seller users should see, use durable public URLs in seller.links, and reuse supported link types consistently. |
| Variants | Stable parent product id, unique variant id per purchasable option, variant-specific title, URL, media, availability and price where they differ. |
| Attribution | Add feed attribution parameters to url, such as utm_medium=feed, and keep tracking parameters consistent across snapshots. |
The attribution point is the one marketing teams should own. Without a consistent feed parameter, sales that start in ChatGPT and finish on your site look like direct or organic traffic, and you cannot tell whether the channel is working. Field-level detail is in our ChatGPT product feed requirements guide.
What Does a Realistic Launch Sequence Look Like?
One that front-loads the decisions that can block launch and back-loads the ones that only need time. The sequence below is our ordering of OpenAI's published requirements, not a timeline OpenAI publishes.
- Confirm eligibility. Approved-partner access, a supported payment provider, and the markets OpenAI has confirmed for your integration.
- Settle PCI scope with your PSP and QSA, and decide on your PSP's delegated payment implementation versus direct integration.
- Ship a clean product feed with stable IDs, valid availability, and feed attribution parameters.
- Build the five checkout endpoints with signature verification, idempotency and full cart state.
- Build signed order webhooks, including refund and chargeback updates.
- Run every checklist test in the sandbox and keep the logs.
- Allowlist OpenAI's IP ranges and confirm TLS on port 443.
- Check legal links and request production access.
For the endpoint-level specification behind steps four and five, see the agentic checkout section.
What Are the Common Production Mistakes?
- Not keeping logs from the start. Every test must be demonstrated end to end with request and response logs.
- Leaving PCI scope until the end. OpenAI may require an attestation of compliance before production access.
- Returning generic errors. Out of stock and payment declined must be handled as recoverable, logged scenarios.
- Assuming retries are rare. Idempotency conflicts must return 409, not a second order.
- Forgetting the IP allowlist. OpenAI calls you from published ranges.
- Skipping feed attribution. Without it, ChatGPT-sourced sales disappear into direct traffic.
- Assuming OpenAI handles refunds. As merchant of record, you do.
What Are the Common Mistakes With ChatGPT Product Feeds in 2026?
- Building before applying. Feed onboarding is limited to approved partners.
- Assuming your market is covered. Standard uploads target the US until OpenAI confirms otherwise.
- Treating discovery, Ads and checkout as one switch. They are three separate eligibility controls.
- Planning promotions into a file feed. They are API-only.
- Exporting availability or price in the wrong format. Both reject rows.
- Assuming OpenAI handles refunds. You remain merchant of record.
- Skipping feed attribution. You will not be able to tell whether the channel works.
- Selling prohibited categories. OpenAI may remove products or ban a seller.
Key Takeaways for 2026
- Product feeds in ChatGPT are currently available to approved partners, applied for at chatgpt.com/merchants.
- Discovery, Ads and checkout are three separate capabilities with three separate eligibility controls.
- Nine required fields per row; availability and price formatting cause most rejections.
- OpenAI recommends a daily full file upload plus API updates, and promotions are API-only.
- The standard upload targets the US, and the shared format represents US, CA and MX.
- Checkout uses five merchant-hosted endpoints, card payments via Stripe, Adyen or Braintree, and leaves you as merchant of record.
- Feed attribution parameters are how you measure the channel at all.
Distk helps D2C and e-commerce brands in India and internationally decide whether AI shopping surfaces are worth building for yet, prepare catalogue data that passes strict validation, and set up the measurement that proves whether the channel pays before anyone commits to a checkout build. If ChatGPT shopping is on your 2026 list, that assessment is where we start.