Agentic Commerce Protocol (ACP): Enabling AI Agent Checkout
ACP is the OpenAI and Stripe standard that lets AI agents execute purchases on behalf of users. A config at /.well-known/acp/config.json declares your checkout capabilities, Stripe Payment Tokens handle delegated payment, and ChatGPT Instant Checkout completes purchases without the user visiting your site. ACP is the execution layer of the agentic commerce stack.
What is ACP?
Agentic Commerce Protocol (ACP) is the checkout execution standard co-developed by OpenAI and Stripe. Where UCP handles discovery — telling agents what you sell — ACP handles execution: the mechanics of how an AI agent actually completes a purchase on a user's behalf. It is the protocol powering ChatGPT Instant Checkout and any future AI-native commerce surface that Stripe powers.
ACP works through three interlocking components. First, the product feed: a structured catalog of your offerings that agents ingest to match products against user intent without browsing your site. Second, the negotiation API: a standardized endpoint at /api/acp/negotiate where agents confirm product selection, price, and availability before committing to a transaction. Third, Stripe Payment Tokens (SPT): single-use payment credentials that carry the user's pre-authorized payment method, scoped to specific merchants and amounts, so agents can charge payments without storing card details or requiring user re-authentication at checkout.
The combination of these three components enables what ACP calls delegated payment authorization: a user authorizes an AI agent to shop within defined rules (spend limits, merchant categories, date windows), and the agent exercises that authority autonomously. For merchants, ACP integration means appearing in ChatGPT commerce flows, being transactable by the next generation of AI shopping assistants, and enabling frictionless purchase completion that converts at rates traditional checkout cannot match — because the user never leaves the AI conversation.
ACP Checkout Flow
Step-by-step: how an AI agent goes from user intent to confirmed purchase order using the full ACP stack.
Agent fetches /.well-known/ucp/manifest.json to confirm merchant capabilities and ACP support
Agent calls /api/acp/negotiate — sends intent, receives session token + confirmed price
Agent reads product feed to match user criteria: size, color, availability, price
Stripe issues a Shared Payment Token bound to the user's pre-authorized payment method
Agent submits checkout request with session token + SPT. Merchant charges and confirms.
Merchant returns order ID + fulfillment status. Agent notifies user with receipt.
ACP Config Structure
The complete /.well-known/acp/config.json structure with field-by-field annotations. This file is the first document ACP-compatible agents fetch when evaluating your checkout capabilities.
{
// ACP protocol version
"acp_version": "1.0",
// Merchant identity
"merchant": {
"id": "acme-commerce",
"name": "Acme Commerce Co.",
"url": "https://www.acmecommerce.com",
"category": "retail", // merchant category code
"subcategory": "outdoor_gear"
},
// Checkout capabilities
"checkout_configuration": {
"instant_checkout_enabled": true, // enables ChatGPT Instant Checkout
"guest_checkout_allowed": false, // require account for physical goods
"requires_shipping": true,
"digital_delivery": false,
"supported_currencies": ["USD", "CAD", "EUR"],
"tax_handling": "merchant_calculated"
},
// Payment methods accepted
"payment_methods": {
"stripe": {
"enabled": true,
"shared_payment_tokens": true, // accepts Stripe SPT from AI agents
"supported_types": ["card", "link", "spt"]
},
"paypal": {
"enabled": true,
"express_checkout": true
}
},
// What AI agents are permitted to do
"agent_permissions": {
"can_view_catalog": true,
"can_request_quote": true,
"can_initiate_checkout": true,
"can_complete_purchase": false, // user confirmation required
"requires_user_confirmation": true,
"max_transaction_amount": {
"amount": "500", // per-transaction limit for agent checkout
"currency": "USD"
}
},
// Negotiation API configuration
"negotiation": {
"enabled": true,
"endpoint": "/api/acp/negotiate",
"supported_actions": [
"get_product_details",
"check_availability",
"request_quote",
"initiate_checkout"
],
"response_format": "json",
"timeout_seconds": 30
},
// Order fulfillment settings
"fulfillment": {
"type": "physical",
"delivery_methods": ["standard_shipping", "express_shipping"],
"estimated_delivery": "3-5 business days",
"refund_policy": {
"refund_window_days": 30,
"conditions": "unopened_items"
}
},
// Security requirements
"security": {
"tls_required": true,
"minimum_tls_version": "1.3",
"api_authentication": "bearer_token",
"rate_limiting": {
"requests_per_minute": 60,
"requests_per_hour": 1000
}
}
}Key ACP Integrations
The three core components that make ACP-enabled checkout work in practice.
ChatGPT Instant Checkout
The primary ACP use case. Users authorize ChatGPT to shop on their behalf within defined spending limits. The GPT commerce agent discovers merchants via UCP, negotiates via ACP, and charges the user's pre-authorized Stripe payment method — completing purchases without site visits.
Requires: ACP config, Stripe SPT integration, negotiation API
Stripe Payment Tokens (SPT)
SPT is Stripe's delegated payment credential. Users create a payment authorization policy in Stripe settings — setting merchant categories, per-transaction limits, and time windows. ACP merchants receive this token as payment and charge it via Stripe's standard API with a new payment_method_type of "shared_payment_token."
Requires: Stripe Connect platform integration, SPT beta access
Delegated Payment Authorization
The policy layer governing what AI agents are allowed to purchase. Users define authorization rules (spend limits, merchant categories, date ranges) that ACP enforces. Merchants check authorization claims in the SPT payload before processing. Non-compliant charges are rejected by Stripe at the token level.
Requires: AP2 mandate integration for enterprise-grade authorization
How to Integrate ACP
Five steps from no agent support to full ChatGPT Instant Checkout capability.
Publish the ACP config at /.well-known/acp/config.json
Create /.well-known/acp/config.json on your server. The config declares your ACP version, merchant identity, checkout configuration (instant checkout enabled, digital vs physical delivery, supported currencies), and payment method settings. Serve it publicly with Content-Type: application/json. This is the first endpoint ACP-compatible agents fetch when evaluating your checkout capabilities.
Build the product feed and negotiation endpoint
Expose a structured product/service feed at a documented URL so agents can ingest your catalog. Implement the negotiation endpoint at /api/acp/negotiate (or your declared path). The negotiate endpoint accepts agent requests for service details, quotes, and availability confirmation. It returns a structured JSON response with a session token and price confirmation that the agent uses to proceed to checkout.
Integrate Stripe Shared Payment Tokens (SPT)
Configure your Stripe integration to accept Shared Payment Tokens from ChatGPT and other ACP-enabled agents. In your Stripe dashboard, enable the Shared Payment Token feature and configure which AI agent platform IDs are permitted. In your checkout flow, add a payment type branch that handles "stripe_spt" token types — these bypass the usual card entry UI and charge the pre-authorized token directly.
Implement the checkout API endpoint
Build the checkout API endpoint declared in your ACP config. It receives an agent checkout request containing: the session token from negotiation, the Stripe Payment Token (or other payment method), user shipping/contact info (for physical goods), and the agreed price. Process the payment via Stripe, fulfill the order, and return a structured confirmation response with order ID, fulfillment status, and receipt details.
Test the full ACP flow with agent simulation
Use OpenAI's ACP test harness (available to Stripe Connect platform partners) to simulate agent checkout flows against your implementation. Validate: (1) config.json is accessible and parses correctly, (2) negotiate endpoint returns valid session tokens, (3) Stripe SPT charges process without errors, (4) checkout endpoint returns properly structured confirmations, (5) refund and dispute paths work correctly. Run a live test with a real ChatGPT Instant Checkout session before going to production.
ACP Questions Answered
What is Agentic Commerce Protocol (ACP)?
Agentic Commerce Protocol (ACP) is the OpenAI and Stripe co-developed standard that enables AI agents to execute purchases on behalf of users. It defines how AI agents ingest merchant product feeds, negotiate transaction terms via a standardized API, obtain Stripe Payment Tokens (SPT) for delegated payment authorization, and confirm order completion. ACP is the standard powering ChatGPT Instant Checkout.
How does ChatGPT Instant Checkout use ACP?
When a ChatGPT user says "buy this for me," the GPT commerce agent fetches the merchant's ACP config at /.well-known/acp/config.json to understand checkout capabilities. It then calls the /api/acp/negotiate endpoint to select a product and price, requests a Stripe Payment Token (SPT) using the user's pre-authorized payment method, and submits a checkout request. The merchant confirms the order via the checkout API and ChatGPT reports back to the user — all without the user visiting the merchant site.
What is a Stripe Payment Token (SPT) in the ACP context?
A Stripe Payment Token (SPT) is a single-use, merchant-scoped payment authorization issued by Stripe on behalf of a user who has pre-authorized AI agent purchases. The user authorizes the Stripe token once (in their ChatGPT or Stripe settings), and ACP-compatible merchants can charge it for approved transactions without additional user friction. The SPT includes amount limits, merchant restrictions, and expiry controls defined by the user's authorization policy.
Does ACP require Stripe? Can I use other payment processors?
ACP v1.0 natively supports Stripe Shared Payment Tokens as its primary delegated payment mechanism because Stripe is OpenAI's infrastructure partner for ChatGPT Instant Checkout. The config.json also includes a PayPal Express Checkout block for broader compatibility. Other payment processors can integrate with ACP via the negotiation API if they implement the SPT equivalent — though Stripe SPT integration provides the deepest ChatGPT Instant Checkout compatibility.
What does "delegated payment authorization" mean in ACP?
Delegated payment authorization means the user pre-authorizes an AI agent (like ChatGPT) to charge payments on their behalf within defined rules — maximum amount, approved merchant categories, time window. The agent holds a Stripe Payment Token that represents this authorization. When the agent finds a product the user wants, it exercises the delegated authority to complete the purchase without requiring the user to enter payment details at checkout time. The user receives a confirmation notification but does not manually approve each transaction.
Enable AI Agent Checkout for Your Business
Adam Silva Consulting implements the complete ACP stack — config file, negotiation API, Stripe SPT integration, and ChatGPT Instant Checkout verification. Paired with UCP discovery and AP2 trust infrastructure for full agentic commerce readiness.