Your store must clearly communicate what’s missing at each stage. Vague error messages kill conversions. Specific, structured responses enable agents to collect the right information and complete the purchase.
Your product data is clean. Your knowledge base is structured. AI agents can discover your store. Now comes the moment that actually matters: can they complete a purchase?
Here’s what I’ve learned after watching Shopify roll out the Universal Commerce Protocol across thousands of merchants: most stores aren’t ready for AI-driven checkout. Not because the technology is complicated, but because merchants don’t understand how different it is from traditional web checkout.
When ChatGPT or Claude attempts to buy from your store, they’re not clicking buttons and filling out forms. They’re negotiating capabilities, handling payment credentials programmatically, and managing checkout states through API calls. If your store can’t communicate what it needs clearly, the transaction fails and the customer goes elsewhere.
This article is part of our comprehensive Agentic Commerce for Shopify guide. Here, we break down exactly how UCP checkout works, what your store needs to support, and how to optimize for AI-driven orders that actually convert.
Traditional web checkout is linear: cart → shipping → payment → confirmation. UCP checkout is negotiated – the agent and your store communicate back and forth to determine what’s possible and what’s required.
Every UCP checkout session moves through three core states:
Incomplete: Missing required information; the agent should attempt to resolve via API
Requires Escalation: Buyer input needed; agent should attempt API resolution first, and if unable, hand off via continue_url
Ready for Complete: All information collected; agent can finalize programmatically
Here’s what this looks like in practice:
Agent creates checkout session → Your store responds with status: “incomplete” (missing shipping address)
Agent provides shipping address → Your store responds with status: “incomplete” (missing payment method)
Agent attaches payment handler → Your store responds with status: “ready_for_complete”
Agent calls complete endpoint → Order placed
The key insight: your store must clearly communicate what’s missing at each stage. Vague error messages kill conversions. Specific, structured responses enable agents to collect the right information and complete the purchase.
UCP defines core capabilities every merchant should implement, plus optional extensions based on your business requirements.
Core Checkout Capabilities (Required for All Merchants):
Create and manage checkout sessions – Agents initiate a checkout, receive a session ID, and make updates using that ID
Line items with proper pricing – Products, quantities, prices, and any item-level details
Apply discount codes – Agents must be able to submit promo codes and receive updated totals
Collect buyer information – Shipping address, email, phone number (what you actually need, not everything)
Attach payment handlers – Support for Shop Pay, Google Pay, or your preferred payment processor
Complete purchases with confirmation – Final order placement with order number and confirmation details
Optional Extensions (Based on Your Business):
Fulfillment (dev.ucp.shopping.fulfillment) – If you offer multiple shipping methods, pickup, local delivery, or delivery windows
Subscriptions (dev.ucp.shopping.subscription) – If you sell subscription products with billing cadences
Loyalty (dev.ucp.shopping.loyalty) – If you have a loyalty program where customers can earn/redeem points
Pre-orders – If you sell products not yet in stock with expected ship dates
Here’s the strategic question: what does your checkout actually require?
If you’re a standard DTC brand shipping physical products, you need: shipping address, email, payment method. That’s it. Don’t force agents to collect information you don’t use.
If you’re a furniture retailer requiring delivery date selection, you need the fulfillment extension to communicate those requirements.
If you sell subscriptions, you need the subscription extension to let customers choose billing frequency.
The protocol is designed to be flexible – implement what you need, skip what you don’t.
One of UCP’s most powerful features: two-sided payment negotiation.
Traditional checkout forces customers into whatever payment methods you’ve configured. UCP lets both sides declare what they support, then dynamically negotiates per transaction.
Here’s how it works:
Your store declares available payment handlers:
The agent declares what credentials it can provide:
UCP negotiates the intersection:
Change the buyer’s location, change the cart contents, change any variable, and the available handlers may shift. A buyer in Germany might see different options than a buyer in the US. A high-value cart might trigger different fraud rules.
What this means for your store:
If you only support one payment method, you’re limiting AI-driven conversions. The more handlers you support, the more likely an agent can complete checkout without escalation.
Recommended payment strategy:
Some transactions will always require human involvement. Regulatory constraints, merchant policies, or capabilities an agent doesn’t yet support.
When an agent hits a capability gap, UCP provides a structured handoff via the Embedded Checkout Protocol (ECP).
Here’s the flow:
Agent attempts to complete checkout → Your store responds with status: “requires_escalation” and provides a continue_url
Agent presents the continue_url to the buyer → “I need some additional information to complete this purchase. Click here to finish checkout.”
Buyer clicks and lands in an embedded checkout experience → Familiar Shopify checkout UI, pre-filled with everything the agent already collected
Buyer provides the missing information (delivery date, size confirmation, etc.) → Checkout completes
Order confirmation flows back to the agent → “Your order is confirmed. Here’s your tracking number.”
Common escalation scenarios:
Age verification – Alcohol, tobacco, or age-restricted products
Custom delivery windows – Furniture retailers requiring specific delivery dates/times
Size or fit confirmation – Apparel brands wanting buyers to confirm sizing
Terms acceptance – Final sale items, pre-orders, or special terms requiring explicit acknowledgment
Complex configuration – Products with extensive customization options
The key: escalation isn’t failure. It’s a designed feature of the protocol. Some purchases require human input, and that’s fine. What matters is that the handoff is seamless and the buyer doesn’t lose progress.
AI agents need to apply discount codes and loyalty credentials just like human shoppers do. Here’s how to make that work smoothly:
Discount Code Requirements:
Agents must be able to submit discount codes and receive updated totals in the same API call. Your store should return:
Bad response: “Invalid code” (no context, agent can’t help the buyer)
Good response: “Code ’10OFF’ requires a $50 minimum purchase. Current cart total: $45. Add $5 more to qualify.”
Loyalty Program Integration:
If you have a loyalty program, agents need to:
This requires the dev.ucp.shopping.loyalty extension and clear communication of:
Subscription Billing Cadences:
For subscription products, agents need to present billing options and let buyers choose:
The dev.ucp.shopping.subscription extension handles this, but you must clearly define:
Checkout completion isn’t the end – agents need to help customers track orders, manage returns, and access customer service.
Order Tracking via UCP:
After checkout completes, your store should provide:
The dev.ucp.shopping.orders capability lets agents:
What this enables:
Buyer asks ChatGPT: “Where’s my order from [Your Store]?”
ChatGPT queries your UCP endpoint with the buyer’s email → Retrieves order status and tracking
ChatGPT responds: “Your order #12345 shipped yesterday via UPS. Tracking shows it will arrive Thursday. Here’s your tracking link: [URL]”
Returns and Customer Service:
While UCP doesn’t currently define a returns capability, you should provide:
The goal: reduce friction at every post-purchase touchpoint. The easier you make it for agents to help customers, the more likely those customers return.
Before going live with AI-driven checkout, test thoroughly using Shopify’s UCP Playground: ucp.dev/playground
What to test:
Happy path checkout – Complete purchase with minimal information (shipping address, payment method)
Discount code application – Apply valid codes, test invalid codes, check error messages
Multiple payment handlers – Verify Shop Pay, Google Pay, and credit card all work
Escalation flows – Trigger scenarios requiring human input, verify continue_url works
Order lookup – Query order status by email and order number
Edge cases:
Testing across AI platforms:
Each AI platform implements UCP slightly differently. Test your checkout in:
Look for:
Mistake 1: Requiring unnecessary information
Your store asks for phone number, even though you never call customers. Agents struggle to collect it, escalation rate increases, conversions drop.
Fix: Only require information you actually use. If you don’t need it, don’t ask for it.
Mistake 2: Vague error messages
Agent submits checkout, receives “Error: Unable to complete purchase.” No context, no guidance.
Fix: Return specific, actionable error messages. “Shipping address invalid: ZIP code format incorrect for US addresses.”
Mistake 3: Not supporting Shop Pay
Shop Pay is built into Shopify and works across all AI platforms. If you don’t support it, you’re forcing escalations.
Fix: Enable Shop Pay in your payment settings. It’s the easiest path to AI-driven conversions.
Mistake 4: Complex fulfillment without proper extension
You require delivery date selection, but don’t implement the fulfillment extension. Agents can’t collect this information programmatically, every checkout escalates.
Fix: Implement dev.ucp.shopping.fulfillment if you have complex fulfillment requirements. Or simplify your requirements.
Mistake 5: Ignoring order management
Checkout works great, but agents can’t look up order status. Customers ask “Where’s my order?” and get “I can’t access that information.”
Fix: Implement dev.ucp.shopping.orders capability. Let agents help with post-purchase questions.
Week 1-2: Audit current checkout requirements
Week 3-4: Configure payment handlers
Week 5-6: Implement core checkout capability
Week 7-8: Add necessary extensions
Week 9-10: Build escalation flows
Week 11-12: Test and optimize
Your store can now handle AI-driven orders. Agents can discover your products, understand your offerings, and complete purchases.
But how do you know it’s working? How do you measure AI-referred traffic and attribute conversions?
The next step is testing your complete implementation to ensure everything works together seamlessly. You’ll want to validate that your product data, knowledge base, and checkout flow all function properly across all AI platforms.
Want to see if your current checkout is AI-ready? Go to ucp.dev/playground and simulate an agent interaction against your store. You’ll immediately see where your checkout breaks down and what needs fixing.
For the complete agentic commerce implementation strategy, see our Agentic Commerce for Shopify guide.
The UCP checkout state machine manages AI-driven transactions through three core states: Incomplete (missing required information), Requires Escalation (buyer input needed), and Ready for Complete (all information collected). Unlike traditional linear checkout, UCP uses negotiated communication between the AI agent and your store to determine what’s possible and what’s required at each stage.
Every Shopify store must support: creating and managing checkout sessions, line items with proper pricing, applying discount codes, collecting buyer information (shipping address, email, payment method), attaching payment handlers (Shop Pay, Google Pay, credit cards), and completing purchases with confirmation. Optional extensions include fulfillment, subscriptions, and loyalty programs based on your business requirements.
UCP uses two-sided payment negotiation where both your store and the AI agent declare supported payment methods, then dynamically negotiate the intersection for each transaction. Your store might offer Shop Pay, Google Pay, and credit cards, while the agent declares what credentials the buyer has available. UCP then presents only the mutually supported options, which can vary by buyer location, cart contents, and other transaction variables.
The Embedded Checkout Protocol (ECP) provides a structured handoff when AI agents can’t complete checkout programmatically. When an agent hits a capability gap (age verification, delivery date selection, size confirmation), your store responds with ‘requires_escalation’ status and a continue_url. The buyer clicks through to a familiar Shopify checkout UI pre-filled with information the agent already collected, completes the missing details, and the order confirmation flows back to the agent.
AI agents must be able to submit discount codes and receive updated totals in the same API call. Your store should return whether the code was accepted or rejected, specific reasons if rejected (expired, minimum purchase not met, excluded products), updated line item pricing showing the discount applied, and the updated order total. Vague error messages like ‘Invalid code’ prevent agents from helping buyers, while specific responses like ‘Code requires $50 minimum purchase, current cart total: $45’ enable the agent to guide the buyer.
You need the Fulfillment extension (dev.ucp.shopping.fulfillment) if you offer multiple shipping methods, in-store pickup, local delivery, or require delivery date/time selection. You need the Subscription extension (dev.ucp.shopping.subscription) if you sell products with recurring billing and customers can choose billing frequency. You need the Loyalty extension (dev.ucp.shopping.loyalty) if you have a points or rewards program where customers can redeem at checkout. If you’re a standard DTC brand shipping physical products with basic checkout (address, email, payment), you don’t need any extensions.
Use Shopify’s UCP Playground at ucp.dev/playground to test your implementation. Test the happy path checkout with minimal information, discount code application, multiple payment handlers, escalation flows, and order lookup. Also test edge cases like out-of-stock products, invalid addresses, declined payments, and expired codes. Then test across actual AI platforms (ChatGPT, Google AI Mode, Microsoft Copilot) and monitor checkout completion rate, escalation frequency, payment handler success rate, and error message clarity.
The five most common mistakes are: 1) Requiring unnecessary information that increases escalation rates, 2) Using vague error messages that don’t help agents resolve issues, 3) Not supporting Shop Pay which forces unnecessary escalations, 4) Having complex fulfillment requirements without implementing the proper extension, and 5) Ignoring order management capabilities so agents can’t help with post-purchase questions like order tracking.
Yes, if you implement the dev.ucp.shopping.orders capability. This lets AI agents look up order status by order number or email, retrieve tracking information, check delivery estimates, and access order history for returning customers. When a buyer asks ‘Where’s my order?’, the agent can query your UCP endpoint and provide real-time tracking information and delivery updates without requiring the customer to log into your store.
A complete UCP checkout optimization takes approximately 90 days following this timeline: Weeks 1-2 audit current checkout requirements, Weeks 3-4 configure payment handlers, Weeks 5-6 implement core checkout capability, Weeks 7-8 add necessary extensions, Weeks 9-10 build escalation flows, and Weeks 11-12 test and optimize across platforms. The timeline assumes you’re implementing thoughtfully with proper testing, not rushing to go live with a broken implementation.
