What is Agentic Commerce Protocol (ACP)?

Agentic Commerce Protocol is an open commerce specification maintained by OpenAI and Stripe for connecting buyers, AI agents and businesses. It defines machine-readable contracts for commerce tasks including product discovery, cart and checkout state, payment delegation and order lifecycle while keeping the merchant as the system of record.

Is ACP the same as MCP?

No. ACP describes commerce interactions between agents and merchants. MCP describes how model runtimes discover and invoke tools. The ACP repository's current stable specification includes MCP support, so the two can compose rather than replace one another.

Is ACP the same as x402?

No. ACP is a commerce contract spanning merchant discovery and transaction state. x402 is a machine-readable HTTP payment protocol for requesting and settling payment for a resource. An architecture can use commerce state from ACP and a separate payment rail where appropriate.

What changed for ACP in 2026?

On 24 March 2026 OpenAI said it was expanding ACP to support richer product discovery in ChatGPT. The ACP repository's latest stable specification directory is labeled 2026-04-17 and adds cart, feed, orders, authentication and MCP support alongside machine-readable OpenAPI and JSON Schema assets.

Editorial

Explainer · agentic commerce

Agentic Commerce Protocol is becoming a machine-readable contract between shopping agents and merchants.

Agentic Commerce Protocol, or ACP, is an open specification maintained by OpenAI and Stripe for connecting buyers, AI agents and businesses. It began around agent-initiated checkout, but the useful 2026 picture is broader: OpenAI expanded ACP into product discovery, while the public specification added feed, cart, order, authentication and MCP surfaces. ACP is therefore best understood as a commerce-state protocol, not as a replacement for every payment, identity or tool protocol around it.

Published 12 September 2026 · sources and status boundaries below

Open standard

Public specification maintained by OpenAI and Stripe

24 Mar 2026

OpenAI announced expanded ACP support for product discovery

2026-04-17

Label of the repository's latest stable specification snapshot

What ACP solves

An agent needs a transaction contract, not just a page it can scrape

Human commerce tolerates a surprising amount of implicit state: a shopper can read a page, interpret a badge, notice a changed price and recover when a checkout screen says something unexpected. Autonomous buyers need those states exposed explicitly. The agent has to know which product is being discussed, what it costs now, which options are valid, what the merchant accepted and whether a purchase actually completed.

ACP formalizes that exchange between the agent and the merchant. The public specification includes machine-readable OpenAPI and JSON Schema assets, while the checkout contract uses persistent session state, request IDs and idempotency controls to make consequential actions easier to reconcile.

The merchant remains the system of record. That matters commercially: ACP is designed to let the agent act as a buyer interface without forcing merchants to surrender their product truth, order lifecycle, fulfillment or customer relationship to the agent platform.

Machine contract

The public ACP repository now exposes a broader commerce surface

The repository's latest stable directory is labeled 2026-04-17. Its published structure includes OpenAPI, JSON Schema, examples and RFCs covering checkout, capability negotiation, payment handlers, seller-backed payment handlers, extensions and discounts. The repository describes the stable snapshot as adding cart, feed, orders, authentication and MCP support.

Discovery / feed

Give an agent current product and merchant data in a structured form rather than relying on page extraction alone.

Capabilities

Negotiate what the merchant and agent can actually do before a consequential flow depends on an unsupported feature.

Cart / checkout

Carry authoritative line items, totals, fulfillment choices, messages and payment selection through a persistent session.

Delegated payment

Pass payment authority without handing the agent unrestricted raw credentials; payment execution remains a distinct control surface.

Orders

Represent the result of a completed transaction so post-purchase systems can reconcile what happened.

MCP support

Compose ACP commerce semantics with MCP tooling rather than treating commerce and tool invocation as competing standards.

ACP vs MCP vs x402 vs Agent Connect

These layers overlap at the edges, but they do different jobs

Surface	Primary contract	Best-known job	Current steward / ecosystem
ACP	Agent ↔ merchant commerce contract	Product/feed data, capability negotiation, cart and checkout state, payment delegation, orders	OpenAI + Stripe
MCP	Model/runtime ↔ tool contract	Tool discovery, schemas, resources and invocation	Agent/tool ecosystem
x402	HTTP resource payment	Machine-readable payment challenge, authorization and settlement	Open payment ecosystem
Mastercard Agent Connect	Merchant ↔ agent-commerce connectivity	Merchant-authorized catalog discovery, cart orchestration and payment enablement	Mastercard

A production workflow can legitimately use more than one of these. An agent might use MCP to reach a merchant tool, ACP to maintain commerce state, KYA or another trust layer to identify the actor, and a separate payment rail to settle value. The useful design question is which layer owns each state transition and which evidence survives a retry.

Merchant implementation checklist

What makes a commerce endpoint usable by an autonomous buyer?

Authoritative product state

Expose stable product IDs plus current price, availability, variants and fulfillment constraints. Agents should not have to infer transactional state from marketing copy.

Idempotent transaction state

Create and update commerce sessions with durable IDs and idempotency so an agent retry does not accidentally duplicate a consequential action.

Explicit capability negotiation

Declare which commerce and payment capabilities are actually supported instead of making the agent discover limits after checkout has begun.

Bounded payment authority

Keep payment credentials and user authorization scoped. A commerce protocol should not turn a shopping goal into unrestricted account access.

Outcome evidence

Return machine-readable order, failure and reconciliation state so an autonomous buyer knows whether to retry, stop or ask for intervention.

Separate trust layers

Treat merchant identity, agent identity, user intent, payment and delivery as composable controls. One valid protocol message is not proof that every layer is safe.

zFinia interpretation

The commercial moat is increasingly the quality of machine-readable state

ACP's evolution from checkout into richer product discovery is the same pressure visible elsewhere in the machine economy: agents select providers when current capability, price, policy and outcome state can be evaluated without guesswork. Merchants and API sellers therefore compete not only on the underlying product, but on how reliably an autonomous buyer can understand and transact with it.

Mastercard Agent Connect Autonomous procurement Know Your Agent Safe agent payments Make a service discoverable Machine-service catalogue zFinia OpenAPI