Agentic Commerce Protocol (ACP)
The Agentic Commerce Protocol (ACP) is an open standard that enables AI agents and businesses to work together across a purchase on a buyer’s behalf, from product discovery to order placement and tracking. Co-developed by OpenAI and Stripe, it defines how an agent reads catalog data, builds a cart, receives the merchant’s taxes and shipping, and passes a payment token once the buyer approves the merchant-confirmed total.
ACP gives AI interfaces and commerce backends a shared language for these transactions. The business remains the merchant of record, controlling assortment, pricing, order acceptance, and fulfillment. In practice, the buyer explicitly confirms the items, delivery terms, and final price before any payment is processed. The protocol serves as the shared transaction layer within the wider ecosystem of agentic commerce.
What ACP is and is not
ACP is published as an open specification: a written set of rules and data formats, hosted publicly on GitHub, that tells an AI platform and a merchant’s systems exactly how to structure the messages they exchange. Those messages cover product feeds, cart updates, checkout sessions, delegated payment credentials, and order status.
The scope is deliberately narrow, and that shapes what merchants still need to build:
- ACP isn’t an AI shopping assistant. The agent’s reasoning and its conversation with the buyer happen outside the specification.
- It isn’t a payment processor. Payment providers still tokenize credentials, run fraud checks, and settle funds.
- It doesn’t replace a merchant’s commerce stack. Merchants connect ACP to the product information, checkout, inventory management, and order management systems they already run.
Specification status
- Maintainers: OpenAI and Stripe, under joint governance
- License: open source, Apache 2.0
- Release stage: beta, with date-based versions
- Latest released version: 2026-04-17, covering product feeds, carts, checkout, delegated payment, orders, authentication, and MCP compatibility
Platform support also changes independently of the specification. When ChatGPT launched Instant Checkout in 2025, purchases were completed inside the chat. In March 2026, OpenAI shifted its focus to product discovery, and ChatGPT now generally sends shoppers to the merchant’s own checkout to pay. The checkout rules remain part of ACP, and each platform and merchant decides which parts to implement.
Agentic ecommerce describes the whole journey of agents researching, comparing, and buying on a person’s behalf. ACP supplies the technical rules for the programmatic purchases inside that journey.
Core participants and architecture
ACP splits a purchase across four participants, so no single system holds everything. The platform never sets prices, the agent never sees card numbers, and the merchant never has to hand its pricing or inventory logic to anyone else.
- The buyer states what they want, sets limits such as budget or brand, and confirms every purchase before payment.
- The AI platform talks to the buyer, indexes product feeds, calls the merchant’s endpoints, and passes along the payment token.
- The merchant hosts the ACP endpoints, publishes the product catalog, calculates prices, tax, and shipping, and accepts and fulfills the order as the merchant of record.
- The payment provider issues the scoped payment token, protects card data, and processes the charge for the merchant.
Behind the merchant’s endpoints is the commerce stack it already runs. Each ACP response draws on one or more of these systems:
- Product information management and search supply structured catalog data, with clear variants, categories, and availability.
- Pricing and promotion engines check discount eligibility, bundles, and codes when a purchase is priced.
- Cart and checkout services hold the purchase state and calculate shipping tiers and regional tax.
- Order management and ERP systems accept the order, allocate stock, and trigger fulfillment.
- Monitoring and audit logs record each request and notification for reconciliation and troubleshooting.
Three protocol mechanics keep these connections stable as both sides change:
- Capability negotiation: the platform and merchant declare which ACP features they support.
- Date-based versions: merchants can upgrade on their own schedule.
- Idempotency keys: these stop a retried request from creating a duplicate order or charge.
Retailers with a composable commerce architecture can map ACP onto existing services instead of rebuilding them. An agentic commerce platform can then support ACP alongside other protocols on the same foundation.
How the Agentic Commerce Protocol works
ACP defines the messages these participants exchange at four stages. Because the merchant answers every message from its own systems, it stays in control of each commercial decision while an AI platform handles the conversation.
- Catalog discovery through product feeds. ACP defines the feed format merchants use to share their catalog with an AI platform. The format covers product identifiers, titles, variants, images, prices, and stock status. Merchants send a full feed regularly, then update it when prices or availability change. The platform indexes the feed to power its product search. ACP standardizes only the data.
- Checkout sessions through the checkout API. When the buyer chooses an item, the platform calls the merchant’s ACP endpoints to open a checkout session, which is a record of the proposed purchase. The merchant’s systems return the line-item prices, shipping options, taxes, and any discounts its pricing and promotion rules allow. Each response also carries a status: not ready for payment, ready for payment, or completed. The endpoints run over REST or the Model Context Protocol (MCP). Because the merchant answers every call, the agent never sets prices or stock.
- Buyer approval and delegated payment. When the session is ready for payment, the agent shows the buyer the merchant’s final total. The platform requests a payment token from the payment provider as soon as the buyer confirms. ACP’s delegated payment rules limit that token to one merchant and checkout session, a maximum amount, a currency, and an expiry time, so card details never reach the agent.
- Order creation and status updates. The merchant charges the token through its payment provider and creates the order. As fulfillment progresses, the merchant sends signed webhooks for shipment, cancellation, or refund. These are automated notifications the platform can verify.
Why ACP matters to merchants
Buyers who shop through an AI assistant may never see a merchant’s product pages. That shifts the question from how to bring shoppers to the site to how to sell wherever they start. ACP matters in four ways:
- Presence in assistant-led discovery. Discovery is ACP’s most common use today. Product feeds put a merchant’s catalog into assistant conversations, even when the final payment happens on the merchant’s own site. Recommendations still depend on products staying visible to AI agents through complete, accurate data.
- Less friction after selection. Where a platform supports ACP checkout, buyers can go from choosing an item to reviewing the order without rebuilding the cart elsewhere. Whether this lifts completion rates is worth testing against the current journey.
- Policy control per channel. Beyond the merchant-of-record role, merchants can accept or decline transactions per agent or per order, so a new AI channel can start small and grow as confidence builds. They gain control of the transaction, but not of the assistant’s interface or of every conversation the buyer has there.
- Shared integration across compatible partners. ACP is open and works with any compatible payment provider, so the same integration can serve more platforms and processors as they adopt the standard. It also goes beyond one-off orders, supporting digital goods, subscriptions, and purchases that complete later.
Agentic commerce is an emerging channel, not a guaranteed growth engine, even as it changes how retail works. The useful test is whether ACP brings in additional completed orders at an acceptable cost, without increasing errors, disputes, or support work.
How to prepare for Agentic Commerce Protocol integration
An Agentic Commerce Protocol integration serves buyers only when three separate conditions are met. Teams often assume one implies the others:
- Protocol compatibility: Your endpoints follow the specification.
- Platform eligibility: Each AI platform runs its own approval process, so implementing ACP doesn’t list your products anywhere automatically. For example, ChatGPT requires merchants to apply.
- Payment support: Your payment provider must support ACP’s delegated payment tokens.
With those checks in view, preparation follows seven steps:
- Pick one journey. A high-volume category with stable prices and simple fulfillment makes problems easier to spot than a full-catalog launch.
- Clean catalog and policy data. Feeds need complete variants and accurate availability. Return and shipping terms should be written as structured data, not marketing copy. Where attributes are thin or inconsistent, AI catalog enrichment can fill the gaps before feeds go live.
- Assign an owner to each exchange. Decide which system answers feeds, checkout sessions, payment, and order updates, and who fixes each one when it fails.
- Confirm identity and payment. Confirm that your provider supports the chosen payment flow, including ACP’s delegated payment tokens where applicable. Also check how ACP orders will appear in fraud screening.
- Build to one version. Implement against a specific released version of the specification and record which one, so later upgrades are deliberate.
- Test the failure paths. Before launch, run declined payments, mid-session price changes, out-of-stock items, duplicate requests, and cancellations, not just successful orders.
- Measure, then expand. Before adding platforms or categories, compare your results with your existing channels on:
- discovery coverage
- checkout success
- error and retry rates
- conversion and abandonment
- fraud loss
- support escalations
Before choosing a first journey, assess whether your catalog, commerce APIs, payment controls, and operating model are ready for agent-led purchases. An agentic commerce readiness assessment reviews each of these and identifies where to start.
Security, governance, and limits
When software agents act on purchase requests, the risks are concrete. An agent might charge the wrong variant, resubmit a failed order, or expose payment data in a conversation. ACP addresses these risks at the transaction layer, so safety doesn’t depend on an AI model policing its own behavior. The protocol supplies the safeguards, and how a merchant configures, monitors, and governs them decides the outcome.
What the protocol’s design provides:
- Less card data in play. Payment tokens keep card numbers with the payment provider. That narrows PCI scope for the agent and the platform, though not for the merchant’s own payment flows.
- Charges tied to approval. A token covers only the total the buyer approved. If the price rises after approval, it can’t be charged without a fresh confirmation.
- Verifiable messages. Authenticated requests and signed order updates let each side confirm who sent what.
What merchants still need to put in place:
- Data sharing: Share only the buyer data each order needs, and set retention rules for what agents send.
- Fraud screening: Apply the same fraud rules as other channels, with added checks for unfamiliar agents.
- Audit trail: Log each request, token reference, and webhook so you can trace every order to its session and approval.
- Escalation: Decide when an order goes to a person, such as when a total is disputed, or a payment fails.
Existing obligations don’t change just because an agent started a purchase. Returns, chargebacks, PCI, privacy, and consumer protection rules all still apply. Who handles each one depends on the implementation, the contracts between parties, and the jurisdiction. Building consent and escalation in from the start is central to a trust architecture in agentic commerce.
The specification is still in beta, and a new release can change schemas or required behaviors, so test each upgrade before it reaches production.
ACP vs. adjacent protocols
Agentic commerce runs on several emerging standards, not one. Each covers a different layer: connecting agents to tools, delegating work between agents, or proving what a buyer authorized. These protocols are often presented as competing standards, but they serve different roles. While ACP acts as a commerce interaction model and the checkout execution layer that manages commerce exchanges between platforms and merchants, the other protocols provide support for the surrounding layers.
Protocol | Origin and current steward | Primary job | How it connects with ACP |
MCP (Model Context Protocol) | Created by Anthropic, now part of the Linux Foundation’s Agentic AI Foundation | Connects agents to tools and data | Merchants can expose ACP checkout endpoints as MCP tools. |
A2A (Agent2Agent) | Created by Google, now governed by the Linux Foundation | Enables agents to find each other and hand off tasks in multi-agent workflows | A coordinating agent can assign a shopping agent to complete an ACP checkout. |
AP2 (Agent Payments Protocol) | Created by Google, now governed by the FIDO Alliance | Provides verifiable proof of what a buyer authorized, through signed mandates | A signed mandate can sit alongside an ACP checkout as added proof of consent. |
UCP (Universal Commerce Protocol) | Google, co-developed with Shopify and major retailers | Covers the shopping journey from discovery to post-purchase in Google’s AI Mode and Gemini | Overlaps most with ACP. Merchants selling through both ChatGPT and Google’s AI surfaces may implement both. |
These roles reflect the current specifications, and the boundaries may shift as standards evolve. Payment authorization is where the approaches differ most: ACP relies on scoped payment tokens, while AP2 relies on signed mandates. A comparison of ACP vs. AP2 covers both models in detail.
Searches for a “Mastercard agentic commerce protocol” usually refer to Mastercard Agent Pay. It’s a card network framework that verifies agents and issues agent-specific payment tokens. Mastercard says it works alongside ACP, UCP, AP2, and A2A, so it complements these protocols rather than competing with them.
ACP example: one order, step by step
The clearest way to understand ACP is to follow the data carried through one order. The values below are illustrative.
A buyer asks an AI assistant for wireless noise-canceling headphones under $250. The platform searches the merchant’s product feed and may use its own personalized recommendation models to rank suitable products. ACP supplies the structured product data, but it does not decide which item to recommend.
Step | What happens |
Product feed | The platform reads the product ID, title, black color variant, $229 price, availability, and stated fulfillment information. |
Checkout session opened | The platform sends the selected item to the merchant. The merchant returns a $229 subtotal and marks the session as “not ready for payment” because the delivery address and shipping method are still missing. |
Session updated | After receiving the address, the merchant calculates $18.32 in tax and a $12 shipping charge. It returns a total of $259.32, the delivery date, and a “ready for payment” status. |
Buyer approval | The assistant, not the protocol, flags that the final total exceeds the original $250 limit. The buyer can approve the higher amount, choose another item, or cancel. |
Payment token | If the buyer approves, the platform requests a delegated payment token from the payment provider. Following ACP’s delegated payment rules, the token is limited to this merchant and checkout session, a maximum amount, a currency, an expiry time, and a single use. |
Checkout completed | The platform sends the token to the merchant to complete the checkout. The merchant processes the payment, creates the order, and returns a “completed” session status. |
Order updates | As fulfillment progresses, the merchant sends signed webhooks to the platform, such as order confirmed, shipped, or refunded. |
This example shows why ACP uses a checkout session instead of treating feed data as a purchase promise. The merchant recalculates the order using the current address, stock, tax, delivery, and promotion rules. If anything changes, the assistant must show the new terms before payment can proceed. ACP checkout sessions move through defined states, and delegated payment tokens are constrained by amount and expiry.
The merchant’s latest response is authoritative for that session state. The assistant doesn’t set the price, store the card number, or declare the order successful. It presents the merchant’s terms, carries the buyer’s approval, and reports the merchant’s order status.
The same table can serve as a simple readiness check. If the merchant can’t reliably supply one of these values, that capability needs attention before launch. Missing color, compatibility, material, or other decision-making fields may call for merchandising attribute enrichment, with uncertain updates routed to a merchandiser for review. The practical next step is to run one product through this table and verify three things for every value: that it comes from the correct system, that it updates when conditions change, and that it stays traceable from discovery to order confirmation.
To see these pieces work together, watch Grid Dynamics and NVIDIA’s agentic commerce demo. Using enriched catalog data and the ACP, UCP, and MCP protocols, an AI agent understands a shopper’s intent, applies loyalty benefits, cross-sells relevant gear, and completes checkout in a single conversation.

