> ## Content Index > Fetch the complete content index at: https://www.cognativ.com/llms.txt > Use this file to discover other available public pages before exploring further. # Agentic Commerce Protocol (ACP): How Agentic Checkout Works and How to Implement It - URL: https://www.cognativ.com/blog/agentic-commerce-protocol/ - Published: 2026-11-04T08:40:11.000Z - Updated: 2026-11-08T11:15:56.000Z - Description: ACP lets AI agents check out against your own systems with scoped payment tokens. See the 2026 spec, the shift after Instant Checkout and how to implement it. - Author: Kevin Anderson - Tags: AI The Agentic Commerce Protocol (ACP) is an open standard that lets AI agents, buyers and businesses complete commerce programmatically: an agent discovers products from a merchant's feed, builds a checkout session against the merchant's own systems and pays with a scoped payment token instead of raw card details. The merchant stays the merchant of record and keeps control of pricing, fulfillment and the customer relationship. ACP was released by OpenAI and Stripe in September 2025 alongside ChatGPT's Instant Checkout. A lot has changed since then. The specification has gone through several dated revisions, OpenAI stepped back from native in-chat checkout in March 2026, and competing standards such as the Universal Commerce Protocol (UCP) now sit beside it. This guide, updated on November 4, 2026, explains what ACP is, how agentic checkout works, where the protocol stands today and how to approach an ACP implementation without betting your roadmap on a single AI channel. ## What Is the Agentic Commerce Protocol? ACP is a set of specifications that standardize the conversation between an AI agent and a seller. Instead of an agent scraping a website and filling in a checkout form like a human would, the seller exposes structured endpoints that the agent calls directly. The [official ACP site](https://www.agenticcommerce.dev/?ref=cognativ.com) describes it as an Apache 2.0 licensed standard that supports physical and digital goods, subscriptions and asynchronous purchases, and that can be published through REST APIs or the Model Context Protocol (MCP). The promise is simple: a buyer expresses intent in a conversation, the agent handles the mechanics, and the business still processes payment through its existing provider and fulfills the order its own way. ### Who maintains ACP The protocol lives in a public GitHub repository that labels the specification as beta and describes consensus-based governance, with a stated goal of moving to neutral foundation stewardship as the ecosystem matures. The repository's maintainers file lists OpenAI, Stripe and Meta as lead maintainers. Contributions require a contributor license agreement. ### What ACP is not ACP is not a payment network, a marketplace or an AI model; payment service providers still move the money. Nor does it replace MCP. MCP is a general way for models to call tools, while ACP defines the commerce objects (carts, checkout sessions, orders, payment tokens) those calls carry. Since April 2026, ACP even ships an MCP transport binding. ## How the Agentic Commerce Protocol Works An ACP transaction involves the buyer, the agent platform hosting the conversation, the seller and the seller's payment provider. The flow moves through four stages: the seller publishes product data, the agent builds a checkout session with the seller, the buyer approves, and the agent hands the seller a scoped payment credential that the seller charges through its own processor. ### Core components - **Product feed.** Structured catalog data the agent uses for discovery. OpenAI's product feed specification accepts JSONL, CSV or TSV and requires core fields such as item ID, title, description, URL, brand, seller name, image, availability and price. Separate flags control whether an item is eligible for search and whether it is eligible for checkout. - **Agentic checkout.** A small REST surface the seller implements so the agent can create, update, complete, cancel and retrieve checkout sessions. - **Delegated payment.** The specification for passing a payment credential from the agent to the seller without exposing the buyer's underlying card details. - **Carts, orders and authentication.** Added in 2026 to cover basket building before checkout, richer post-purchase order updates and delegated 3DS2 authentication. ### Shared payment tokens Stripe's implementation of delegated payment is the shared payment token. According to Stripe's documentation, the agent issues a token granted to the seller's Stripe profile with usage limits such as currency, maximum amount and expiration. The seller confirms a PaymentIntent with that token, or resolves it once into network credentials for a third-party processor, and a webhook signals when a token is consumed, expired or revoked. Stripe lists availability in the US, Canada and select European countries. ![A seller product feed leads to an agent checkout session, then buyer approval, then a scoped payment token the seller charges.](https://storage.ghost.io/c/cc/dc/ccdca949-0fe4-4119-8990-70a44ad75060/content/images/2026/11/agentic-commerce-protocol-1.png) ACP moves from the seller's product feed to a checkout session, buyer approval and a scoped payment token the seller charges. ## Agentic Checkout Step by Step Agentic checkout is the part of ACP that most teams mean when they say "ACP implementation." OpenAI's agentic checkout specification defines five endpoints that sit on top of a merchant's existing commerce stack. ### The session lifecycle 1. **Create.** The agent posts the selected items and, optionally, the buyer and shipping address. The seller returns the full cart state: line items, fulfillment options, taxes, fees, discounts, totals and any messages. 2. **Update.** As the buyer changes quantity, address or shipping option, the agent updates the session and the seller recalculates everything. The seller remains the source of truth for price. 3. **Complete.** Once the session is ready for payment, the agent sends the payment data, including the delegated token. The seller authorizes the payment through its provider, creates the order and returns an order reference. 4. **Cancel or retrieve.** The agent can cancel an open session or read its current state at any time. Sessions move between states such as not ready for payment, ready for payment, completed and canceled. After completion, the seller sends signed order events so the buyer sees confirmation, shipping and refunds in the conversation. ### Security and reliability requirements Every request carries headers for authorization, idempotency, request tracing, a body signature, a timestamp and the API version. Fraud controls shift from watching browser behavior to verifying signed requests, enforcing token limits and handling agent retries safely. OpenAI also describes certification checks covering schema conformance, error codes, rate limits and webhook delivery before a merchant goes live. ![The agent creates a checkout session, updates the cart, completes it with a payment token, and the seller returns order events.](https://storage.ghost.io/c/cc/dc/ccdca949-0fe4-4119-8990-70a44ad75060/content/images/2026/11/agentic-commerce-protocol-2.png) The agent creates and updates a session, completes it with a delegated token, and the seller sends order events back. ## ACP in 2026: Versions, Instant Checkout and the Shift to Discovery The specification is versioned by date: | Spec version | Main change | | ------------ | -------------------------------------------------------------------------- | | 2025-09-29 | Initial release: checkout, delegated payment, product feed | | 2025-12-12 | Fulfillment enhancements | | 2026-01-16 | Capability negotiation | | 2026-01-30 | Extensions, discounts and payment handlers | | 2026-04-17 | Carts, push feeds, native orders, delegated authentication and MCP binding | The 2026-04-17 changelog is the one implementers should read closely. It adds a public discovery document at `/.well-known/acp.json` that advertises supported versions, capabilities and transports; a push-model feed API; orders with fulfillments and adjustments such as returns and chargebacks; and a delegated 3DS2 flow. It also includes breaking changes: item quantity becomes a decimal to support B2B purchases, and an idempotency key is now required on every POST. The bigger change was commercial. In March 2026 OpenAI deprioritized Instant Checkout as a standalone feature, saying, as MacRumors reported, that it did not offer the flexibility OpenAI wanted. Retail Gazette reported that merchants can now use their own checkout experiences while sharing product feeds and promotions through ACP for discovery, and that retailers wanting deeper integration can build their own apps inside ChatGPT. The lesson for merchants is that ACP's feed and checkout layers are separable. The feed earns visibility today; the checkout layer depends on which agent platforms support it at any given time. ## ACP Implementation Options by Role How you implement ACP depends on where you sit in the transaction. Merchants and brands, AI agent builders and platforms, and payment service providers each take on different parts of the work. ### For merchants and brands Merchants publish a product feed, implement the checkout endpoints and accept delegated payments through their provider. They keep merchant-of-record status, decide which products are eligible and handle fulfillment, returns and support as they do today. The first question is how much your commerce platform already covers. ### For AI agent builders and platforms Agent platforms call the seller's checkout endpoints, collect buyer approval and mint or pass payment tokens through a compatible provider. The hard parts are conversational: confirming intent, showing totals clearly, handling errors the seller returns and knowing when to hand the buyer to a human or a web page. Teams building shopping or procurement assistants usually need that orchestration designed alongside guardrails and logging, which is the core of [custom AI agent development](https://www.cognativ.com/ai/agent-development/) rather than a protocol checkbox. ### For payment service providers Providers implement the delegated payment specification so that agents can obtain scoped credentials and sellers can charge them. Stripe was the first compatible provider. The 2026 payment handler additions make room for other providers and for sellers that keep their existing processor. ![Three parallel columns: merchants publish the feed and checkout, agent platforms run the conversation, payment providers issue scoped tokens.](https://storage.ghost.io/c/cc/dc/ccdca949-0fe4-4119-8990-70a44ad75060/content/images/2026/11/agentic-commerce-protocol-3.png) Merchants publish feeds and checkout endpoints, agent platforms run the conversation, and payment providers issue scoped tokens. ## ACP Implementation Guide for Merchants A sound ACP implementation is mostly ordinary commerce engineering done carefully: clean catalog data, reliable pricing and inventory APIs, and a payment integration that respects idempotency. ### 1\. Audit catalog data first Agents can only recommend what they can understand. Fill the required feed fields, add variants, dimensions, return policies and shipping details, and make sure price and availability update when stock or promotions change. ### 2\. Decide your checkout posture Choose between discovery only (feed, with checkout on your own site), agentic checkout through your provider's managed offering, or a custom checkout implementation against the specification. Discovery only is the lowest-risk starting point in 2026. ### 3\. Build checkout endpoints on your existing stack Map create, update and complete calls to your cart, tax, shipping and order services rather than duplicating business logic. Return complete cart state on every response, sign webhooks and enforce idempotency keys. If your storefront, order management and payment systems are tightly coupled, this is where most of the effort lands, and it is the kind of integration work an [ecommerce software development](https://www.cognativ.com/software-development/ecommerce/) team should scope before any agent channel goes live. ### 4\. Integrate delegated payments With Stripe, confirm PaymentIntents using the shared payment token, or resolve it for a third-party processor. Test limits, expirations and revocations in a sandbox, and listen for deactivation events. ### 5\. Test, certify and monitor Run sandbox sessions end to end, including error paths, partial fulfillment and refunds. Pass the platform's certification checks, then track agent-originated orders separately against your own site. ![Four sequential steps: audit catalog data, build checkout endpoints, integrate payment tokens, certify and monitor.](https://storage.ghost.io/c/cc/dc/ccdca949-0fe4-4119-8990-70a44ad75060/content/images/2026/11/agentic-commerce-protocol-4.png) A merchant ACP rollout starts with catalog data, then checkout endpoints, delegated payments and certification with monitoring. ## ACP, UCP, MCP and AP2: How the Protocols Fit ACP is no longer the only agentic commerce standard. The Universal Commerce Protocol, introduced by Google with Shopify in January 2026, lists co-developers including Etsy, Wayfair, Target, Walmart, Microsoft, Meta, Salesforce and Stripe. UCP also keeps the business as merchant of record and builds in support for MCP, Agent2Agent (A2A) and the Agent Payments Protocol (AP2). Stripe's [agentic commerce documentation](https://docs.stripe.com/agentic-commerce?ref=cognativ.com) now covers both ACP-style shared payment tokens and UCP. A practical way to think about the landscape: MCP and A2A are general agent plumbing; ACP and UCP define commerce objects such as carts, checkout sessions and orders; AP2 and card network programs focus on payment authorization and trust. Because the commerce protocols overlap heavily, the safest architecture is one internal checkout core with thin protocol adapters on top. ## Common ACP Implementation Mistakes to Avoid - **Treating ACP as a single-channel project.** Platform strategies change quickly, as Instant Checkout showed. Build for the feed and checkout core, not for one assistant. - **Letting the agent own pricing.** The seller must recalculate totals, taxes and shipping on every update and reject stale or tampered states. - **Skipping idempotency.** Agents retry. Without idempotency keys and replay protection, retries create duplicate orders and charges. - **Stale feeds.** Out-of-date price or stock data causes failed checkouts. - **Ignoring post-purchase events.** Order, shipping and refund webhooks are part of the protocol. - **Pinning to a deprecated version.** The 2026-01-30 revision is deprecated; read changelogs and advertise supported versions in your discovery document. ## Frequently Asked Questions ### What is the Agentic Commerce Protocol? ACP is an open, Apache 2.0 licensed standard that lets AI agents discover products, run checkout sessions against a seller's own systems and pay with scoped payment tokens, while the seller remains the merchant of record. ### Who created ACP? OpenAI and Stripe released ACP in September 2025\. The public repository now lists OpenAI, Stripe and Meta as lead maintainers. ### Is ChatGPT Instant Checkout still available? In March 2026 OpenAI deprioritized Instant Checkout as a standalone feature and shifted ChatGPT shopping toward discovery, letting merchants use their own checkout. ACP product feeds now power that discovery experience. ### What is the difference between ACP and UCP? Both are open agentic commerce standards that keep the business as merchant of record. ACP came from OpenAI and Stripe; UCP was introduced by Google with Shopify and a wide group of retailers. ### Is ACP the same as MCP? No. MCP is a general protocol for models to call tools. ACP defines commerce objects such as checkout sessions, carts and orders, and since April 2026 it can be served over an MCP transport binding. ### Do I need Stripe to implement ACP? No. Stripe was the first compatible payment provider, but the specification supports other providers and payment handlers, and Stripe's shared payment tokens can be resolved for a third-party processor. ## Conclusion: Building for Agentic Commerce The Agentic Commerce Protocol turned agentic checkout from a demo into a specification: product feeds for discovery, a checkout session API the seller controls and delegated payment tokens that keep card data out of the agent's hands. Just over a year after launch, the protocol is more complete, with carts, orders, authentication and MCP support, and the market is more crowded, with UCP and platform apps competing for the same purchases. For most merchants the right 2026 move is pragmatic: get catalog data agent-ready, build one well-tested checkout core, add protocol adapters as channels prove their value and measure agent-originated orders honestly. If you are planning an ACP implementation or deciding which agent channels deserve investment, [talk to Cognativ about your agentic commerce roadmap](https://www.cognativ.com/contact/).