How to Prepare Your Online Store for AI Agents: Feeds, Data, APIs
Table of contents
To prepare an online store for AI agents today, you need to separate two things. Product data (the feed and structured data) and bot access can be put in order right away, because assistants already read offers from them. A purchase completed by an agent inside a conversation, on the other hand, works in selected markets, mainly the US, so for a store selling in Poland or elsewhere in the EU it is something to plan for now and build later.
Agentic commerce is shopping in which an AI assistant searches for and compares products and, in some deployments, also places the order on the customer's behalf. This post covers five areas on the store side: the product feed, structured data, bot access, the order API, and the UCP and ACP protocols. For each one it says what the documentation requires and what applies right now.
Key takeaways. Shopping in ChatGPT is live for users in the US, and UCP checkout on Google covers products sold in the US; Google's documentation expects Australia and Canada in early 2027. Since 24 March 2026, OpenAI has sent the buyer to the merchant's own checkout, and in ChatGPT the ACP protocol is used mainly to deliver product feeds. The OpenAI feed requires nine product fields and two geo fields, and a row without a valid availability value is rejected. A UCP integration starts with a JSON profile at /.well-known/ucp; native checkout on Google means three REST endpoints and mandatory order events. Stripe's Agentic Commerce Suite is available to sellers in Poland and other European countries, but reach among buyers depends on the agent. A sensible order of work: data first, then bot access, then transactions.
What works today and what is still an announcement
ChatGPT: product discovery, purchase at the merchant
The first version of shopping in ChatGPT, Instant Checkout, completed the order inside the chat. On 24 March 2026 OpenAI changed direction: in its post on product discovery in ChatGPT it wrote that this version did not offer the flexibility it wanted, so merchants use their own checkout while the company focuses on searching and comparing offers.
The OpenAI page for merchants states that shopping in ChatGPT is live for users in the United States. A feed is submitted through a form and applications go onto a waitlist; stores on Shopify and Etsy are connected without applying. OpenAI charges no fee on purchases that start in ChatGPT and says a self-serve merchant platform is coming later in 2026.
On 12 May 2026 the Polish marketplace Allegro launched an app inside ChatGPT. According to Allegro’s press release on its ChatGPT app, the assistant shows offers as cards with the price, a photo and ratings, and the “Buy on Allegro” button sends the shopper to a form for choosing payment and delivery.
Google: UCP checkout in the US, more markets announced
UCP (Universal Commerce Protocol) is an open standard through which an agent talks to a store's systems about the cart, the order and payment. Google uses it for purchases in AI Mode and in Gemini. According to Google's UCP integration guide, the integration hub in Merchant Center is rolling out gradually in the US and applies to products sold in the US, with Australia and Canada expected in early 2027. Checkout is available to selected merchants in an early access program.
In May 2026 Google announced on its blog the expansion of UCP checkout to Canada, Australia and later the UK. These sources give no dates for EU countries.
Stripe: an intermediary that covers European sellers
The third route runs through a payment provider. Agentic Commerce Suite in Stripe's documentation is available in the US, Canada and selected European countries, and the list includes Poland. The seller uploads a catalog as a CSV file, Stripe shares it with the agents the store connects to, and Stripe runs checkout and payment.
The country list applies to the seller. Whether a buyer in a given country sees the offer depends on the reach of the agent itself, described above.
An agent that cannot buy in a given market yet still reads the offer. Hence the order: data first, transactions second.
How an agent finds a product: three channels
An AI assistant can learn about a product in three ways, and each asks something different of the store.
- The store's website. A crawler fetches the product page and reads its content and structured data. OpenAI notes on its merchant page that a feed is optional, because ChatGPT may crawl the store's site.
- The product feed. The store sends its catalog to the platform. According to OpenAI, this gives more control over product information.
- The protocol. The store publishes a profile and exposes an API through which the agent creates a cart or an order. This channel requires backend work and, in Google's case, approval of the integration.
The channels complement each other. A store with a complete feed and no protocol can still appear in the assistant's answers; the purchase simply ends on the store's own site.
Product feed: fields, identifiers, freshness
A product feed is a file or data stream with one row for each purchasable product or variant. The OpenAI product feed schema requires nine fields in every row: item_id, title, description, url, brand, seller_name, image_url, availability and price. Two geo fields come on top: target_countries and store_country.
Rules that reject a row or break matching
- Availability. The
availabilityfield takesin_stock,out_of_stock,pre_order,backorderorunknown. A row with an empty or unrecognized value is rejected. - Price. An amount in major units and an uppercase three-letter currency code, for example
79.99 USD. - Variants. Each variant is a separate row with a shared
group_id, thelisting_has_variationsflag and avariant_dictobject describing the selected options (color, size). - Stable identifiers.
item_id,group_idandoffer_idstay the same when the price, stock, title or image changes. An identifier must never be reused for a different product. - Countries. A standard upload has
["US"]intarget_countries, and omitting the field does not mean worldwide.
Optional fields include gtin and mpn, the promotional sale_price, return terms (return_policy, return_deadline_in_days) and reviews (review_count, star_rating). OpenAI says richer data, including images, pricing and reviews, improves how a product is placed. It does not disclose ranking criteria.
Is a Google Merchant Center feed enough
Partly. The Google-compatible feed specification accepts TSV and CSV files with columns familiar from Merchant Center, such as id, link, image_link and item_group_id. It may be used only after OpenAI confirms this format for the registered feed.
There are several differences. A valid GTIN or mpn is required unless identifier_exists is no or false. Availability is written as preorder, and unknown is rejected. Products accepted on this path are enabled for search and disabled for checkout, and per-item visibility controls require the OpenAI format.
How often to update
The OpenAI schema gives no frequency, but Stripe's documentation has concrete numbers for its suite: product data once a day, inventory and pricing every 15 minutes. Stripe states the reason plainly: when the price shown to the shopper differs from the price charged, checkout fails.
The second rule concerns removal. In upsert mode, leaving a product out of the file keeps it in the catalog, so a withdrawn item has to be marked explicitly (delete=true). Otherwise the agent keeps showing it.
Structured data on the product page
Structured data is a machine-readable description of a product, usually JSON-LD with the schema.org vocabulary, embedded in the product page code. Google's merchant listing documentation requires name, image and offers for the Product type, and a price greater than zero (price) plus a currency (priceCurrency) for Offer.
The recommended properties match what feeds ask for:
availabilityanditemCondition,shippingDetailsandhasMerchantReturnPolicy(Google recommends defining a standard return policy at the merchant level),- the identifiers
gtin,mpnandsku, priceValidUntilfor time-limited prices.
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Trail running shoes, black, size 42",
"image": ["https://store.example/img/trail-shoes-black.jpg"],
"sku": "TRAIL-BLK-42",
"gtin13": "5901234123457",
"brand": { "@type": "Brand", "name": "Example" },
"offers": {
"@type": "Offer",
"price": 89.00,
"priceCurrency": "EUR",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition"
}
}
None of the documentation cited here promises that structured data will raise a product's position with an agent. Its job is narrower: the crawler gets the price, availability and identifier in an unambiguous form. The same values should appear in the feed and in the visible part of the page.
Bot access: robots.txt and the firewall
The OpenAI crawler documentation separates the bots' roles, and each one is controlled in robots.txt on its own.
OAI-SearchBotpowers search in ChatGPT. A site that opts out of it will not be shown in ChatGPT search answers. After a robots.txt change, OpenAI's systems need about 24 hours to adjust.GPTBotcollects content that may be used to train models. That is a separate decision from search visibility.ChatGPT-Useracts on a user's request, for example when someone asks to open a specific page. OpenAI notes that robots.txt rules may not apply to it.
The second control point is the web application firewall (WAF) and bot protection. OpenAI's guide to ChatGPT Wallet payments warns that ChatGPT's cloud browser can trigger bot-detection systems and announces support for the Forwarded HTTP header carrying signals such as country or time zone.
A recommendation: review firewall rules and your bot-protection provider together with robots.txt. Allowing OAI-SearchBot in robots.txt achieves nothing if the firewall stops the same traffic.
API and checkout: what the backend must handle
A well-documented example of a transactional path is Google's native checkout, a purchase completed on Google's surfaces without moving to the store. Google's UCP implementation overview sets the order of work: the Merchant Center account, the UCP profile, authentication for the API endpoints, and then one of two paths. Native checkout requires the Google Pay payment handler and order lifecycle support. The cart path transfers the cart from Google to the store's website. Google must approve the integration before it goes live.
Three endpoints and the session lifecycle
The native checkout overview requires three REST endpoints:
POST /checkout-sessionscreates a session with the line items.PUT /checkout-sessions/{id}updates fulfillment, discounts and the payment instrument; the store recalculates costs at that point.POST /checkout-sessions/{id}/completecompletes the order once the shopper clicks to pay.
The session moves through the statuses incomplete, ready_for_payment, ready_for_complete and completed; there are also canceled and error. Google sets service level objectives (SLOs): availability of at least 95%, a median response of up to 1 second for creating and updating a session, and up to 6 seconds for completion. The store returns a payment decline as 200 OK with a structured UCP error so the shopper can pick another card.
After the purchase: order events
The order lifecycle guide obliges the store to push status updates through a webhook, an HTTP call sent to Google. Three events are mandatory: order created with the status processing, order shipped with tracking_number and tracking_url, and order delivered. Retries after a timeout or a 5xx error carry the same Idempotency-Key header.
Conditions on the Merchant Center side
The Merchant Center account requirements include a return policy with the cost, the return window and a link to the full text, plus customer support contact details. A product enters checkout only after the native_commerce(checkout_eligibility) attribute is set; it defaults to FALSE. The identifier in the feed must match the one the checkout API expects; the merchant_item_id attribute maps any mismatch.
Whichever path you choose, the store remains the party to the transaction: Google stresses in its May post that the retailer always remains the merchant of record. On the delivery side this is a backend project with elements of AI integration: mapping identifiers, calculating taxes and shipping at request time, and idempotent events.
UCP and ACP: how they differ and what to implement first
ACP (Agentic Commerce Protocol) is the second open specification for agentic commerce, developed by OpenAI and Stripe. The two protocols at a glance:
- Who maintains it. UCP is published as an open specification and used by Google in AI Mode and Gemini. ACP, according to the ACP repository on GitHub, is maintained by OpenAI and Stripe under the Apache 2.0 license.
- Maturity. UCP uses date-based releases, from 2026-01-11 to the UCP v2026-08-25 release. ACP is in beta, and its latest stable version is 2026-04-17.
- Scope. UCP describes capabilities such as checkout, cart, order and identity linking, with extensions for fulfillment and discounts; the core concepts are explained in the UCP specification overview, version 2026-01-11. ACP covers a checkout API and delegated payment, and since version 2026-04-17 also cart, feed and orders.
- Transport. The UCP specification lists REST, MCP (Model Context Protocol, a standard for connecting models to tools), A2A (agent-to-agent communication) and embedded checkout.
- Where it works for the buyer. UCP powers purchases on Google, in the US for now. ACP in ChatGPT is used today mainly for feeds and product discovery.
The profile at /.well-known/ucp
The entry point to UCP is a JSON file at a fixed address on the store's domain. It must be publicly accessible, with no authentication. It contains the protocol version, the services with the API address, the list of capabilities, the payment handlers and the public keys used to verify signatures. The agent and the store agree on a shared set of capabilities based on this file.
{
"ucp": {
"version": "2026-04-08",
"services": {
"dev.ucp.shopping": [
{ "version": "2026-04-08", "transport": "rest", "endpoint": "https://store.example/ucp/v1" }
]
},
"capabilities": {
"dev.ucp.shopping.checkout": [{ "version": "2026-04-08" }],
"dev.ucp.shopping.order": [{ "version": "2026-04-08" }]
},
"payment_handlers": { "com.google.pay": [{ "id": "...", "version": "2026-01-23" }] }
},
"signing_keys": [{ "kid": "...", "kty": "EC", "crv": "P-256", "use": "sig", "alg": "ES256" }]
}
The layout comes from the profile publishing guide for version 2026-04-08. The version number matters here, because the v2026-08-25 release removed the signing_keys field from the profile in favor of keys, moved the payment extensions to a different namespace and restructured the fulfillment schema. For now, Google’s guides describe profiles for versions 2026-04-08 and 2026-01-23.
A specification that removes the signing-key field in a single release is better kept away from the store's core behind an adapter layer.
What to implement first
For a store that sells only in Poland or elsewhere in the EU, the answer is: neither protocol as a first step. A feed in the OpenAI format and in the Merchant Center format, plus correct structured data, work regardless of which standard reaches your market.
A store selling to the US has two documented routes. The first is Google's path: Merchant Center, the UCP profile and the checkout API. The second is Stripe's suite, which runs checkout itself by default and, according to the documentation, also lets you run your own UCP checkout with Stripe payments.
Your store platform: what is ready and what has to be built
The scope of work depends on what the store runs on.
- Shopify and Etsy. OpenAI says sellers on these platforms are already integrated with ChatGPT and do not need to apply.
- WooCommerce. The WooCommerce AI and agentic commerce roadmap from October 2025 describes an MCP server, experiments with OpenAI's feed specification and work on ACP with Stripe. The post does not present these elements as finished, so check the current documentation before deciding.
- A store using Stripe payments. Agentic Commerce Suite requires a Stripe account, a catalog in CSV and a way to receive orders, such as a webhook.
- Other platforms and custom-built stores. The first question for the platform's documentation: does it generate a feed in the required format, and does it have a UCP or ACP module. If not, the feed, the profile and the endpoints are built as a custom integration.
That last case is typical custom software work in e-commerce: the pricing, inventory and shipping logic already exists in the store, and the new layer exposes it in the format the agent requires.
What this does not solve
- Nobody guarantees exposure. OpenAI does not disclose how products are selected, and feed applications go onto a waitlist.
- Reach is limited. Shopping in ChatGPT and UCP checkout on Google work in the US, and there are no dates for EU countries.
- Specifications change. ACP is in beta, and in August 2026 UCP shipped changes that break profile compatibility.
- Not every product qualifies. Google excludes from checkout, among others, subscriptions, personalized goods, used items and pre-orders.
- Operational commitments come with it. Native checkout means API availability and response times the store is expected to meet, plus Google's approval of the integration.
Summary: the order of work
The documentation points to a three-step plan, ordered by how much each step asks of the store's backend.
- Data. Stable product and variant identifiers, the full set of required feed fields, and the same prices and stock levels in the feed, in JSON-LD and on the page.
- Access. A deliberate decision for each bot in robots.txt, and firewall rules that do not cancel that decision.
- Transactions. A UCP profile and a checkout API, or a payment intermediary, once the store sells in a market where an agent actually completes purchases.
The first two steps apply to any store right now. The third is worth breaking down into tasks and estimating, with the build held until your target market, or your own market, is supported.
Want to check how much of this list your store already covers and what needs integration work? Book a free consultation with the Midapt team.
FAQ
Shopping in ChatGPT is currently live for users in the US, and UCP checkout on Google covers products sold in the US. In the EU an assistant can search for and compare products, and the customer places the order with the seller. One example is the Allegro app in ChatGPT in Poland, where the purchase is completed on Allegro.
Not always. OpenAI accepts Google-compatible files only after confirming that path for the registered feed, and products accepted that way are disabled for checkout. The OpenAI format has its own field names, for example item_id instead of id and url instead of link.
A store that sells only in the EU does not need to implement either today, because the buying features built on both work mainly in the US. If you sell to the US, UCP opens purchases in AI Mode and Gemini, while ACP is used in ChatGPT mainly for feeds. Part of the work, the feed and structured data, is shared by both.
No. Shopify and Etsy are integrated with ChatGPT with no extra steps, but a feed can also be submitted from another platform, and UCP and ACP are open specifications. The difference is that outside a ready-made integration you prepare the feed, the profile and the API yourself or through an intermediary such as Stripe.
It depends on the bot. Opting out of OAI-SearchBot removes the site from ChatGPT search answers, so a store that wants that visibility should not block it. GPTBot relates to model training and can be blocked independently. ChatGPT-User acts on a user's request, and robots.txt rules may not apply to it.



