Agentic Commerce Protocol (ACP)
ACP is an open standard co-developed by OpenAI and Stripe that defines how AI agents, buyers, and merchants interact to complete purchases programmatically. It powers ChatGPT's Instant Checkout and is the first production-scale agent commerce protocol.
ACP is an open standard co-developed by OpenAI and Stripe that defines how AI agents, buyers, and merchants interact to complete purchases programmatically. It powers ChatGPT’s Instant Checkout and is the first production-scale agent commerce protocol, processing real transactions since September 2025.
What is it?
ACP is a RESTful protocol specification that standardizes the message flow between a buyer’s AI agent (e.g., ChatGPT) and a merchant’s commerce backend. The agent acts as a digital personal shopper: it discovers products, builds a cart, initiates checkout, and passes payment credentials to the merchant – all without exposing raw card data.
The protocol launched September 29, 2025 as a closed collaboration between OpenAI and Stripe. It was open-sourced under Apache 2.0 and published to GitHub in early 2026. The spec is maintained at github.com/agentic-commerce-protocol and a developer portal lives at agenticcommerce.dev.
Problem it solves
Without ACP, every AI-agent-to-merchant integration is bespoke. If ChatGPT wants to buy from Etsy, someone builds a custom integration. If Gemini wants to buy from the same Etsy seller, that is a different custom integration. This does not scale – the same N-times-M problem that MCP solved for tool integrations now appears in commerce.
ACP standardizes three things:
- Product discovery – how an agent fetches structured product data from a merchant.
- Cart and checkout session management – how an agent creates, updates, and confirms a checkout on behalf of a buyer.
- Payment credential exchange – how payment tokens move from buyer to merchant without the agent ever seeing raw card numbers.
The result: a merchant implements ACP once and becomes purchasable from any ACP-compatible agent surface.
Architecture / How it works
Core flow
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Buyer <-> AI Agent (ChatGPT) <-> Merchant ACP Endpoints
| |
| 1. Product feed sync |
|<-----------------------|
| |
| 2. Create checkout |
|----------------------->|
| |
| 3. Update session |
|<-----(cart details)--->|
| |
| 4. Payment via SPT |
|----------------------->|
| |
| 5. Order confirmation |
|<-----------------------|
Three merchant integration requirements
-
Product feeds – Merchants share structured product data with OpenAI via standardized feeds. This is how the agent knows what is available, at what price, and in what variants.
-
Agentic Checkout endpoints – A set of REST endpoints the agent calls to create/update a checkout session, apply shipping and tax, and confirm the order. The spec defines the request/response schemas.
-
Payment handling via Shared Payment Tokens (SPT) – This is the critical innovation. After the buyer authorizes payment (using Apple Pay, Google Pay, or a saved card in Stripe), Stripe issues a Shared Payment Token scoped to a specific merchant and cart total. The agent passes this token to the merchant. The merchant never receives raw card data, and the token cannot be reused for a different merchant or amount.
Implementation options
ACP can be implemented as:
- A RESTful API with the endpoints defined in the spec.
- An MCP server exposing the same capabilities through Model Context Protocol tools.
If a merchant already processes payments with Stripe, enabling ACP can be as minimal as a single line of configuration to activate agentic payments on their existing Stripe integration.
Key concepts
Shared Payment Token (SPT)
A new Stripe payment primitive. SPTs are:
- Scoped to a single merchant and a specific cart total.
- One-time use – cannot be replayed.
- Never expose the buyer’s underlying payment method to the agent.
This is the mechanism that makes agent-mediated payments safe. The agent orchestrates the transaction but never holds payment credentials.
Instant Checkout
The first production deployment of ACP. US ChatGPT users (Plus, Pro, and Free tiers) can buy from US Etsy sellers directly in the chat interface. Over a million Shopify merchants (including Glossier, SKIMS, Spanx, Vuori) are being onboarded.
Merchant fee
ACP charges a 4% transaction fee to merchants on completed purchases. The fee is refunded if the buyer returns the item. This is on top of standard Stripe processing fees. For context, Amazon’s referral fee is 8-15% depending on category, so 4% is competitive – but it is a new cost for merchants who previously had direct customer relationships.
Capability negotiation
Added in spec version 2026-01-16. Allows agents and merchants to negotiate supported features (e.g., discounts, fulfillment options, payment handlers) at session creation time, rather than assuming a fixed feature set.
Code / Integration example
A minimal ACP checkout session creation (merchant-side endpoint):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Merchant implements this endpoint per ACP spec
@app.post("/acp/v1/checkout/sessions")
async def create_checkout_session(request: ACPCheckoutRequest):
session = stripe.checkout.Session.create(
line_items=[{
"price_data": {
"currency": "usd",
"product_data": {"name": item.name},
"unit_amount": item.price_cents,
},
"quantity": item.quantity,
} for item in request.items],
mode="payment",
agentic_commerce={"enabled": True}, # Single line to enable ACP
)
return ACPCheckoutResponse(
session_id=session.id,
checkout_url=session.url,
total=session.amount_total,
)
For Stripe-native merchants, the key addition is agentic_commerce={"enabled": True} on the checkout session. The SPT handling is managed by Stripe’s infrastructure.
Comparison with related protocols
| Dimension | ACP (OpenAI + Stripe) | UCP (Google) |
|---|---|---|
| Scope | Checkout-focused: product discovery, cart, payment | Full commerce lifecycle: discovery, comparison, checkout, post-purchase |
| Payment layer | Built-in via Stripe SPTs | Delegates to AP2 |
| First deployment | ChatGPT Instant Checkout (Sep 2025) | Google Search AI Mode, Gemini (early access Mar 2026) |
| Transport | REST or MCP | REST, JSON-RPC, MCP, A2A |
| Governance | OpenAI + Stripe (founding maintainers) | Google-led coalition |
| Merchant fee | 4% | Not yet disclosed |
| Open source | Apache 2.0 on GitHub | Open spec at ucp.dev |
Dual implementation is becoming the norm. Early 2026 data shows merchants supporting both ACP and UCP capture roughly 40% more agentic traffic than single-protocol stores. Walmart already supports both ChatGPT (ACP) and Gemini (UCP). Shopify made stores “agent-ready by default” across both ecosystems.
Governance
ACP was originally a closed OpenAI-Stripe collaboration. It now sits adjacent to the Agentic AI Foundation (AAIF), established December 2025 under the Linux Foundation by OpenAI, Anthropic, and Block, with platinum members including Google, Microsoft, AWS, Bloomberg, and Cloudflare. The AAIF governs MCP, goose, and AGENTS.md – ACP itself is still maintained by OpenAI and Stripe as founding maintainers, but the roadmap indicates a transition toward broader community governance under the AAIF umbrella.
Current adoption / Maturity
- Production: ChatGPT Instant Checkout is live for US Etsy sellers. Shopify rollout in progress (1M+ merchants).
- Spec versions: Initial release (Sep 2025), Fulfillment enhancements (Dec 2025), Capability negotiation (Jan 2026), Extensions/discounts/payment handlers (Jan 2026), with active development branch.
- Ecosystem: Stripe handles payment infrastructure. Any Stripe merchant can adopt with minimal code changes.
- Limitations: US-only as of early 2026. Requires Stripe as payment processor (or implementing the full ACP spec independently). The 4% fee may deter high-volume/low-margin merchants.
Spec links
- Specification: https://github.com/agentic-commerce-protocol/agentic-commerce-protocol
- Developer portal: https://www.agenticcommerce.dev/
- Stripe integration docs: https://docs.stripe.com/agentic-commerce/protocol
- OpenAI developer docs: https://developers.openai.com/commerce