1 octobre 2025
Conversational E-commerce with OpenAI and Stripe: A Complete Guide to the Agentic Commerce Protocol
6 minutes reading
OpenAI and Stripe have announced the Agentic Commerce Protocol (ACP), an open source specification (Apache 2.0) that allows users to purchase directly within a ChatGPT conversation, without going through a third-party website.
Practically speaking, a user can request a product in ChatGPT, see a detailed listing, and complete their purchase via a "Buy" button. On the merchant side, this means setting up three technical components:
- a Product Feed to make your catalog accessible,
- a Checkout API to manage sessions and orders,
- a delegated payment mechanism, mainly using Stripe.
Currently, access is limited to the US and requires OpenAI's approval, but this announcement clearly signals the future direction of conversational e-commerce.
In this article, we break down how the protocol works, its three technical pillars, and provide a roadmap to help you prepare for a future integration.
What is the Agentic Commerce Protocol?
ACP is an open specification that defines how a third-party system (in this case, ChatGPT) can display product catalogs, initiate checkout, and delegate payment to a Payment Service Provider (PSP) like Stripe.
👉 The goal: enable your customers to go from search to payment in a seamless, conversational flow.
How does conversational e-commerce work in ChatGPT?
Let’s take an example: a user asks, “Show me running shoes under $100.”
ChatGPT can then:
- Display products from your catalog (via the Product Feed)
- Offer a “Buy” button
- Trigger a complete checkout right inside the conversation
Three data flows orchestrate this journey:
- Product Feed: ChatGPT indexes your products to make them discoverable
- Checkout API: you manage the shopping cart sessions and order completion
- Delegated payment: your PSPs handle the transaction securely
Pillar 1: The Product Feed 📦
The first piece to put in place is the Product Feed. Before ChatGPT can recommend your products, you need to supply a structured, up-to-date catalog. Without this, your products will remain invisible, even if your Checkout API is flawless.
The format
You have several options: TSV, CSV, XML, or JSON. Choose what integrates best with your existing system. We recommend JSON for flexibility and readability, but CSV works perfectly if your system already exports it naturally.
The feed is pushed to an OpenAI endpoint provided during onboarding. There’s no pulling from OpenAI; you are responsible for sending updates.
Update frequency: every 15 minutes if needed. Keeping your feed in sync with actual inventory is crucial for consistency between what’s shown in ChatGPT and your real stock. Out-of-stock items should never be available for purchase.
The fields
The structure is fairly standard. Here’s an example of a product, as expected by OpenAI:
[
{
"id": "SKU12345",
"title": "Nike Air Zoom Pegasus Running Shoes",
"description": "Lightweight shoes with responsive cushioning...",
"link": "https://yourshop.com/products/SKU12345",
"price": "89.99 EUR",
"currency": "eur",
"availability": "in_stock",
"image_link": "https://yourshop.com/images/SKU12345.jpg",
"brand": "Nike",
"condition": "new",
"weight": "280 g",
"enable_search": true,
"enable_checkout": true
}
]
The last two flags (enable_search and enable_checkout) are OpenAI-specific and provide fine-grained control: a product can be searchable without being directly purchasable.
You’ll find the complete list of fields in the OpenAI documentation.
Handling variants
A key point if you sell products with variants: use item_group_id to group variations such as different sizes or colors. Here’s how this looks:
[
{
"id": "SKU12345-42-BLUE",
"item_group_id": "SKU12345",
"title": "Nike Air Zoom Pegasus - Blue",
"color": "Blue",
"size": "42"
// ...
},
{
"id": "SKU12345-43-BLUE",
"item_group_id": "SKU12345",
"title": "Nike Air Zoom Pegasus - Blue",
"color": "Blue",
"size": "43"
// ...
}
]
ChatGPT will then present the available options at purchase time.
Pillar 2: The Checkout API 🛍️
Once your products are indexed in ChatGPT, you need to handle the purchasing process. This is the core of the system, and where most of your development effort will go.
You need to expose 5 endpoints that ChatGPT will call to manage the purchase lifecycle. The idea is simple: ChatGPT orchestrates, but you do all calculation (price, taxes, shipping) and ultimately decide whether or not to accept the order.
1. Create a session
POST /checkout_sessions
This is the entry point. When the user clicks "Buy" in ChatGPT, this endpoint is called with the selected items and optional shipping address:
Request:
{
"items": [{ "id": "SKU12345-42-BLUE", "quantity": 1 }],
"fulfillment_address": {
"name": "Bptiste Adrien",
"line_one": "18 avenue Parementier",
"city": "Paris",
"postal_code": "75018",
"country": "FR"
}
}
2. Update the session
POST /checkout_sessions/{checkout_session_id}
If the user changes the shipping method or modifies their address, ChatGPT calls this endpoint with the new data. You recalculate taxes and shipping fees and return the same response format as session creation.
This endpoint needs to be fast, since the user may trigger it multiple times as they adjust their choices.
3. Complete the purchase
POST /checkout_sessions/{checkout_session_id}/complete
This is the critical moment—the user has confirmed payment.
Request:
{
"buyer": {
"first_name": "Baptiste",
"last_name": "Adrien",
"email": "hello@premieroctet.com"
},
"payment_data": {
"token": "spt_1234567890",
"provider": "stripe",
"billing_address": {
/* ... */
}
}
}
At this point, you:
- Charge the payment method through your PSP (Stripe, etc.)
- Create the order in your system
- Return the order ID and a tracking link
Response:
{
"id": "checkout_session_abc123",
"status": "completed",
"order": {
"id": "order_789",
"permalink_url": "https://yourshop.com/orders/order_789"
}
// ... rest of the checkout state
}
The permalink_url is crucial—it’s where the user will track their order.
4 & 5. Retrieve and cancel
GET /checkout_sessions/{checkout_session_id}
POST /checkout_sessions/{checkout_session_id}/cancel
These last two endpoints are simpler. The GET lets ChatGPT check the current session status (helpful after a lost context or reconnect). The POST cancel allows the user to explicitly cancel an ongoing session.
In both cases, return the complete session state with the appropriate status.
Webhooks
The Checkout API is not one-way: you also need to send webhooks to OpenAI to notify them of order status changes. This is how ChatGPT will know that an order has been confirmed, shipped, delivered, or cancelled.
{
"type": "order_updated",
"data": {
"type": "order",
"checkout_session_id": "checkout_session_abc123",
"permalink_url": "https://yourshop.com/orders/order_789",
"status": "shipped",
"refunds": []
}
}
Pillar 3: Payment 💳
Last but not least: payment. This is where many have legitimate concerns about security and PCI compliance. OpenAI never touches the money directly. The protocol simply defines how to securely transmit payment info between the user, ChatGPT, and your system. You remain in control and use your preferred PSP.
Option 1: You already use Stripe
This is the easiest path. Stripe has created an “agentic payments” mode you can enable with a single line:
stripe.agentic_payments.enable()
Stripe manages the creation and transmission of the payment token. On your checkout side, you receive a standard payment_data.token and can charge it as usual.
Option 2: You use another PSP
No Stripe in your stack? No problem—you have two options:
A. Using the Stripe Shared Payment Token API
Even if you don’t process with Stripe, you can still use their API just to receive the secure token. This is an intermediate layer and doesn’t change your main PSP (Adyen, Braintree, etc.). You receive a token via Stripe, then charge the payment with your existing PSP.
B. Direct implementation (for PSPs or PCI DSS Level 1 merchants only)
If you’re a PSP or a PCI DSS Level 1 merchant with your own vault, you can implement the endpoint directly. Beware—this means directly handling card data. Only attempt this if you already have PCI compliance and the proper infrastructure in place.
A Few Things to Keep in Mind
Before you dive in, here are some current limitations:
- Geography: US only for now
- Approval: No automatic access; you must apply
- Single-item only: No multi-product carts (yet)
- No complex promo codes: Keep the logic simple at first
Final Thoughts
Now you have a clear overview of what’s involved in implementing the Agentic Commerce Protocol.
For developers, this is a classic REST integration. If you have a robust checkout system, there’s nothing too complex. The main challenge lies in exposing your business logic (pricing, tax, shipping) through an API.
For businesses, it’s a new channel worth testing. 700 million ChatGPT users mean a huge potential audience. Even if access is limited today, getting your infrastructure ready now will give you an edge when things open up.
At Premier Octet, we’re closely tracking these developments and already guiding our first clients through this new landscape. Thinking about implementing the Agentic Commerce Protocol and need technical support? Get in touch—we’d love to discuss your project!
Useful resources:
👋
