A Site for the Agent Shopper: Readiness Checklist

On 9 September 2026 OpenAI opened a separate service for running autonomous agents: programs that get a task and carry it through to the end, including placing the order. Which means a shopper now arrives at your store who does not look at the product page with their eyes but reads the data. I reread OpenAI's commerce documentation and folded everything into one list of fixes: what has to be in the markup, in the feed and in the payment flow so that this kind of shopper gets to the button and does not get stuck on a captcha.

How an agent differs from an ordinary search crawler

A search crawler comes to put a page in the index and later show a human a link. After that a human makes the decisions: they will figure out that the price appears once you pick a size, and they will close the newsletter popup.

An agent cannot do that. It performs an action: picks a product, puts it in the cart, passes the payment through. Everything a human handles on intuition has to be written into the data explicitly: price, availability, delivery time, return terms.

Buying has generally stopped living on the product page alone. On 13 September 2026 Snapchat added product cards straight into direct messages: they used to be shown in the app's storefront, now a product can be sent to a person in a chat. The site never opens, and everything that reaches the buyer comes from your data, not from your design.

Instant Checkout and ACP: where the purchase happens inside the chat

Instant Checkout is placing an order right inside the ChatGPT interface, without going to the store's site. It runs on the Agentic Commerce Protocol (ACP), an open standard for buying inside an AI assistant, which Stripe built together with OpenAI.

Three things are required from the store: a product feed, an implementation of the Agentic Checkout Spec (exchanging order state) and the Delegated Payment Spec (passing the payment). Access is limited to approved partners for now, applications go through chatgpt.com/merchants, and the integration starts with a test feed review. According to Stripe, shoppers in the US first got products from Etsy sellers, and more than 1,000,000 Shopify merchants are coming next, including Glossier, Vuori, Spanx and SKIMS.

An important detail for anyone weighing the risks: the money and the order stay on the store's side. OpenAI is not the merchant of record, meaning not the seller in the legal sense: the store calculates tax, the store runs fraud checks, the store charges the card through its own acquirer and returns "accepted" or "declined" to ChatGPT.

The Delegated Payment Spec works like this: OpenAI creates a single use payment request with a maximum charge amount and an expiry, and the payment provider returns a token. The first compatible implementation is the Stripe Shared Payment Token, and eligible cards are additionally converted into network tokens.

And an honest boundary: the standard feed upload to OpenAI is aimed at the US by default, the target_countries and store_country columns do not change that, and the common format currently covers US, CA and MX. If your store is outside those countries, a week of work means preparing data, not launching sales inside the chat.

Markup: Product and Offer that are visible without JavaScript

The minimum everyone needs, even without a checkout integration: Schema.org structured data on the product page. A Product type with a name and an image, and inside it an Offer with price, currency and availability. These are the same fields Google asks for in product results, so the work is not a one off.

The test is simple, and I run it first. I turn off JavaScript in the browser and open a product page. If the price, availability and order button are visible, the data is in the HTML. If they are not, a script draws them after a click, and the agent gets an empty page with a title on it.

The same test catches the second problem: a price that only appears after a variant is selected. If a product has five sizes and the price is injected by a script, the markup needs one offer per variant, otherwise there is not a single price in the data.

The feed: 9 required fields and the values that kill a row

To get products into ChatGPT answers you need a feed, and in OpenAI's spec each row carries 9 required fields: item_id, title, description, url, brand, seller_name, image_url, availability, price. Format is CSV or JSON.

The availability field accepts only five values: in_stock, out_of_stock, pre_order, backorder, unknown. A missing, empty or unrecognised value rejects the whole row, which means the product simply does not exist for the agent. Price is written as "79.99 USD", with no thousands separators.

Content limits in the same feed: title up to 150 characters, description up to 5,000 characters of plain text. The url and image_url fields must open publicly over http or https, with no login and password: a feed behind authentication is useless. GTIN is strictly 8, 12, 13 or 14 digits with a valid check digit.

A separate trap I would have walked into myself: OpenAI has a second, Google compatible feed profile, and there the same meanings are written differently. Columns are id, title, description, link, image_link, availability, price, brand; preorder is written preorder, not pre_order; the value unknown is not accepted; availability_date is required for preorder and backorder. A zero price is allowed only for mobile phones (category 267) and tablets (category 4745) together with subscription_cost.

• item_id, title, description, url, brand, seller_name, image_url, availability, price in every row
• availability only from the five allowed values
• price in the 79.99 USD format
• title up to 150 characters, description up to 5,000
• url and image_url open without a login
• GTIN of 8, 12, 13 or 14 digits

I put both feed profiles into one table: a "field" column, a "how OpenAI writes it" column, a "how the Google compatible profile writes it" column, and a "what breaks on an error" column. It took an hour to fill in, but I stopped opening the documentation every time to guess whether it is pre_order or preorder.

Update frequency: once a day for Google, up to every 15 minutes for ACP

Google Merchant Center, Google's dashboard for product data, requires a current feed refreshed at least once a day. The public ACP product feed spec dated 1 June 2026 states a frequency of up to every 15 minutes, while the OpenAI integration assumes daily catalogue snapshots.

The practical point is one thing: if availability on the site changes more often than the feed refreshes, the agent will order things you do not have and get declined at the payment step. Declines are not just a lost order, they also damage the store's reputation in a channel where a program makes the decision.

The is_eligible_checkout flag and two pages without which checkout stays off

In the OpenAI feed, the ability to buy is controlled by the is_eligible_checkout flag. It only takes effect under two conditions: the is_eligible_search field is also true and checkout is enabled for your integration. So first the product has to be allowed to be shown, and only after that to be bought.

For checkout, two more fields with public addresses are conditionally required: seller_privacy_policy (privacy policy) and seller_tos (terms of sale). If those pages live inside a customer account or in a PDF behind authentication, they will have to be moved into the open.

It is worth knowing separately that discovery and checkout are different jobs. Per Paz.ai's breakdown from 15 August 2026, ACP describes the purchase session specifically, and a product can get into ChatGPT answers through the feed without implementing ACP checkout. There is no commission at the protocol level, you pay only acquiring and your platform.

What stops an agent dead

Three things zero out all the markup work, because a program cannot get past them.

• A captcha on the way to a product page, the cart or checkout. A human solves it in 5 seconds, an agent hits the wall and leaves.
• Mandatory registration before the price is shown. If the price is only visible to a logged in user, there is no price for the agent.
• Payment that exists only as a single screen with a widget, with no separate step for a payment token. An agent needs a path it can split apart: confirm the order contents, get the total, pass the payment.

The fourth one I see most often, and it is the most frustrating: rules for AI crawlers in robots.txt, closed off a year ago "just in case". The robots.txt file sits at the root of the site and tells crawlers where they may go. As long as AI crawlers are blocked there, the store is cut off from agent scenarios entirely, and no markup will help.

Attribution: how to find agent orders in your reports later

An order placed in a chat arrives without the usual visit to the site, so in a channel report it can settle into direct traffic or nowhere at all. In its recommendations section OpenAI explicitly suggests adding parameters to the feed's url field, for example utm_medium=feed, and keeping them identical between catalogue snapshots: otherwise the same product will be counted as different links.

The other half of the accounting happens off the site. As of 10 September 2026 Google Ads accepts offline sales, meaning uploads of sales that did not happen in a browser. For agent orders the mechanism is the same: the deal shows up in your CRM, and it has to be delivered to the ads account by upload, not by pixel.

That also makes the direction of the channel clear: on 10 September 2026 Search Engine Land reported that Amazon is piloting ad placement in ChatGPT through its own ad buying platform. The place where an agent picks a product is turning into a surface with paid slots, and getting in there for free will get harder over time.

If your store runs on a platform, part of the work is already done

Before writing an integration by hand, check your platform. On 16 June 2026 Search Engine Journal wrote that Shopify Agentic Storefronts are on by default for eligible US merchants and distribute the catalogue to ChatGPT, Google AI Mode, Microsoft Copilot and Perplexity from a single admin panel. For a small store, the choice of protocol right now is made by the platform, not by the developer.

1. Day 1the JavaScript off test on 10 product pages, a list of what is not visible
2. Day 2Product and Offer with price, availability and variants in the HTML
3. Day 3a feed with OpenAI's 9 required fields, validation of a test export
4. Day 4reconciling the two feed profiles: pre_order versus preorder, availability_date for preorders
5. Day 5lifting the AI crawler blocks in robots.txt, moving the policy and terms of sale into the open
6. Day 6utm parameters in the feed's url field, identical across exports
7. Day 7refreshing the feed at least once a day and uploading offline sales into the ads account

What to do in an hour today

1. Open 5 product pages with JavaScript turned off and write down what disappeared: price, availability, button.
2. Open robots.txt and check whether AI crawlers are blocked there.
3. Check the availability field in your feed: every value from the allowed list only, no empty ones.
4. Make sure the privacy policy and terms of sale open on a public link without signing into an account.

If you like, I will look at your feed and product page markup and tell you at which step the agent falls off, write to support.