What Is the Agentic Commerce Protocol (ACP)?
> The Agentic Commerce Protocol (ACP) is an open specification that enables a programmatic exchange between buyers, their AI agents, and sellers to complete a purchase — allowing AI agents to handle checkout inside surfaces like ChatGPT while merchants keep their existing order management, payment processing, and fulfilment infrastructure.
---
What Is ACP?
The Agentic Commerce Protocol (ACP) is an open standard for AI commerce. It defines a common set of interfaces through which an AI agent can conduct a checkout and securely relay payment credentials on behalf of a buyer. The protocol was developed to solve a specific problem: when AI assistants like ChatGPT want to complete a purchase for a user, browser-based automation is unpredictable and fragile. ACP provides a deterministic, programmatic path — one that is explicit and reliable in the same way that an API is more reliable than screen scraping.
The ACP documentation describes it as similar in concept to the Model Context Protocol (MCP): just as MCP defines how AI models interact with tools and data sources, ACP defines how AI agents interact with seller checkout systems. Any compatible agent can use ACP to discover, initiate, update, and complete a purchase with any ACP-implementing merchant, regardless of which e-commerce platform powers the merchant's backend.
The protocol has three primary actors: the buyer, who expresses purchase intent and authorises the AI agent to act on their behalf; the AI agent, which renders the checkout interface, collects buyer inputs and payment credentials, and keeps the buyer informed; and the seller, who implements the ACP-defined endpoints, processes payment through their existing payment service provider (PSP), and fulfils the order through their existing back end. Critically, ACP is designed so that the seller retains ownership of the order, the customer relationship, and the payment rails.
---
How ACP Works
ACP is built around a session-based checkout model. Every ACP transaction begins with the creation of a checkout session and progresses through a defined lifecycle: session created, session updated (as the buyer provides shipping address and selects fulfillment options), session completed (once payment is processed), or session cancelled (if the purchase does not proceed).
The five-step checkout flow:
1. Create session. The AI agent sends a `POST /checkout_sessions` request to the merchant's ACP endpoint with the items the buyer wants to purchase and, optionally, a fulfillment address. The merchant returns a full cart state: a unique session ID, payment provider details, line items with pricing, fulfillment options, totals (items, subtotal, tax, fulfillment, total), messages, and links (terms of service, privacy policy).
2. Update session. As the buyer provides or changes their delivery address, selects a fulfillment option, or adjusts the cart, the agent calls `POST /checkout_sessions/{id}` with the updates. The merchant returns the full updated cart state so the agent always has an authoritative, up-to-date view.
3. Complete checkout. Once the buyer confirms the purchase, the agent calls `POST /checkout_sessions/{id}/complete` with payment data — a token from a supported PSP (Stripe, Adyen, or Braintree) and, optionally, billing address and buyer details. The merchant processes payment on their PSP and returns the completed session state plus an order object containing the order ID, checkout session ID, and a permalink URL for the buyer to track the order.
4. Cancel checkout. If the purchase does not proceed, the agent calls `POST /checkout_sessions/{id}/cancel`. Any session not in a `completed` or `canceled` state is cancellable.
5. Order webhooks. Throughout the order lifecycle, the merchant emits `order.created` and `order.updated` webhook events to a provided OpenAI endpoint. These events keep the buyer's view in the chat interface in sync with fulfillment-grade order truth.
All ACP endpoints must use HTTPS, return JSON, and include standard request headers including an `Authorization` (API Key), `Idempotency-Key`, `Request-Id`, `Signature` (Base64 encoded body signature), and `Timestamp`. Merchants must authenticate every request, verify signatures, enforce idempotency, validate inputs, and support safe retries.
---
Key Components of ACP
| Component | Description | Source | |---|---|---| | `POST /checkout_sessions` | Create a checkout session with items and optional address | ACP Checkout Spec | | `POST /checkout_sessions/{id}` | Update session with address, fulfillment option, or item changes | ACP Checkout Spec | | `POST /checkout_sessions/{id}/complete` | Complete checkout with PSP payment token | ACP Checkout Spec | | `POST /checkout_sessions/{id}/cancel` | Cancel an in-progress session | ACP Checkout Spec | | `GET /checkout_sessions/{id}` | Retrieve current session state | ACP Checkout Spec | | Trust signals | `accepts_returns`, `return_deadline_days`, `is_digital` in product feed | ACP / FeedBridge | | Structured variants | `variant_dict` mapping for product variations in product feed | ACP / FeedBridge | | JSON-array Q&A | `q_and_a` as structured array format in product feed | ACP / FeedBridge | | Structured reviews | `reviews` as JSON array in product feed | ACP / FeedBridge | | Sale price support | `sale_price`, `sale_price_start_date`, `sale_price_end_date` in product feed | ACP / FeedBridge | | Order webhooks | `order.created`, `order.updated` events pushed to OpenAI endpoint | ACP Checkout Spec |
---
Why It Matters for Merchants
ACP opens a new commerce channel — AI-assistant-native purchasing — without requiring merchants to rebuild their existing commerce stack. A merchant implementing ACP keeps their existing PSP, order management system, and fulfilment infrastructure. They expose a defined set of API endpoints and a structured product feed, and in return they become purchasable by any compatible AI agent.
The channel is distinct from any previous form of product distribution: the buyer has already expressed a clear, specific purchase intent when the agent queries the merchant. An ACP-compliant merchant is not competing for attention in an ad auction or a search result page; they are competing in a structured comparison where data quality — product descriptions, trust signals, variant completeness, return policies — determines selection. Merchants with more complete and accurate product data win this comparison more consistently.
There is also a retention dimension: ACP preserves the merchant's customer relationship. The merchant receives the buyer's order, fulfilment address, and email (within the buyer object) when the checkout completes. This allows merchants to follow up through their own CRM and re-engage the buyer for future purchases, maintaining the brand relationship even when the original discovery and purchase happened inside a third-party AI interface.
---
FeedBridge Relevance
FeedBridge supports ACP at both layers: the product data layer and the feed delivery layer. On the product data side, FeedBridge generates ACP-compliant JSON-LD feeds that include all documented ACP trust signal fields (`accepts_returns`, `return_deadline_days`, `is_digital`), structured variants via `variant_dict`, JSON-array Q&A pairs, structured reviews as JSON arrays, and sale price fields with start and end date support. These fields are generated by FeedBridge's Universal AI Engine and applied through the Preview & Apply Workflow, which allows merchants to review enrichment before publishing.
On the feed delivery side, FeedBridge hosts ACP feeds at CDN-backed unique URLs per brand, with configurable scheduling and health monitoring. Feed health alerts notify merchants of dead URLs, stale feeds, or low validity rates before they affect agent discoverability.
FeedBridge does not implement the ACP Checkout Session API endpoints on behalf of merchants — those must be implemented on the merchant's own commerce stack or through an ACP-integrated PSP. The FeedBridge platform covers the product data and feed layer that feeds into the checkout, not the checkout itself.
---
Frequently Asked Questions
Q: Is ACP an open standard or proprietary to OpenAI? A: ACP is an open specification. The documentation at agenticcommerce.dev states that it is open to all implementers and describes it as a common set of interfaces for how agents can conduct a checkout and securely relay credentials. Building with the protocol is open to all, though Instant Checkout in ChatGPT currently operates through an approved partner program.
Q: What payment processors does ACP support? A: The ACP Checkout Spec defines three supported payment processors in the `PaymentProvider` object: Stripe, Adyen, and Braintree. These are the providers whose token-based credential relay is supported in the `complete` endpoint.
Q: Does ACP replace my existing e-commerce platform? A: No. ACP is designed explicitly to keep orders, payments, and compliance on the merchant's existing commerce stack. The protocol adds an agent-facing interface; it does not replace the back end.
Q: Do I need ACP if I already have a Google Shopping feed? A: These are complementary, not alternatives. A Google Shopping feed helps your products appear in Google's search and shopping surfaces. ACP enables your products to be purchased through ChatGPT Instant Checkout. For Google AI Mode specifically, UCP is the relevant protocol.
Q: What happens if my ACP endpoint is unavailable during a checkout attempt? A: ACP requires merchants to support safe retries, idempotency enforcement, and error responses in the defined error format. If the endpoint returns a 5xx error, the agent can retry using the `Idempotency-Key` header to avoid duplicate orders.
---
Related Topics
Parent hub: ACP Foundations
Related concepts:
- How ACP Works for Merchants
- ACP Instant Checkout in ChatGPT Explained
- ACP Merchant Onboarding Requirements
- ACP Product Feed Requirements
- ACP Checkout API Overview
Breadcrumb:
---
Source Documentation
| Claim | Source | Source Class | Reference | |---|---|---|---| | ACP is open specification enabling programmatic exchange between buyers, agents, sellers | agenticcommerce.dev/docs | T1 – Official ACP Docs | https://www.agenticcommerce.dev/docs | | ACP five checkout session endpoints, request/response fields | OpenAI ACP Checkout Spec | T1 – Official ACP Docs | https://developers.openai.com/commerce/specs/checkout/ | | Supported PSPs: Stripe, Adyen, Braintree | OpenAI ACP Checkout Spec | T1 – Official ACP Docs | https://developers.openai.com/commerce/specs/checkout/ | | ACP trust signals, variants, Q&A, reviews, sale price fields | FeedBridge Platform Capabilities April 2026 v2.0 | T1 – FeedBridge Internal | FeedBridge-Platform-Capabilities-April2026.md | | ACP product feed, CDN hosting, feed health monitoring | FeedBridge Platform Capabilities April 2026 v2.0 | T1 – FeedBridge Internal | FeedBridge-Platform-Capabilities-April2026.md |
---