How to optimise your Shopify store for UCP checkout and AI driven orders

Your product data is clean. Your knowledge base is structured. AI agents can find your store and understand what you sell. Now comes the part that decides whether any of that turns into revenue: can an agent actually complete a purchase?

For most Shopify stores the honest answer today is no, or not reliably. The reason is rarely technical difficulty. It is that merchants are still thinking about checkout as a page a person looks at, when the Universal Commerce Protocol treats checkout as a conversation between two systems.

When ChatGPT, Gemini or Copilot tries to buy from your store, nothing is clicked and nothing is typed. The agent negotiates capabilities, handles payment credentials programmatically and moves a checkout session through defined states over an API. If your store cannot state clearly what it has, what it needs and why something failed, the transaction stalls and the buyer is served a competitor instead.

This guide covers how UCP checkout works, what your store has to support, where checkouts break in practice, and how to sequence the work over ninety days.

Why UCP checkout is different

Traditional checkout is linear. Cart, shipping, payment, confirmation. You control the order of events, you control the interface, and when something goes wrong a human shopper will squint at the form and work it out.

UCP checkout is negotiated. The agent asks your store what is possible. Your store answers. The agent supplies what it can. Your store reassesses and answers again. This continues until the order can be placed or a human has to step in.

Three consequences follow from that, and they shape everything else in this guide.

Your responses are your interface. There is no layout, no microcopy and no visual hierarchy doing work for you. The structured message your store returns is the entire experience.

Ambiguity is fatal rather than merely annoying. An agent will not guess at what an unclear error means. It will escalate or abandon.

Failure is invisible. An abandoned agentic session never touched your storefront, so it does not appear in your analytics. You will not see the drop off, only the absence of orders you never knew were attempted.

The UCP checkout state machine

Every UCP checkout session sits in one of three states.

Incomplete. Required information is missing. The agent should attempt to resolve it through the API without involving the buyer.

Requires escalation. The buyer has to provide something the agent cannot. The agent tries the API route first and, failing that, hands off to a human through a continue URL.

Ready for complete. Everything needed has been collected and the agent can finalise the order programmatically.

A clean session runs like this:

1. The agent creates a checkout session. Your store returns incomplete, because there is no shipping address.
2. The agent supplies the shipping address. Your store returns incomplete, because there is no payment method.
3. The agent attaches a payment handler. Your store returns ready_for_complete.
4. The agent calls the complete endpoint. The order is placed and a confirmation is returned.

Read that sequence again and notice what carries the weight. At every step your store is telling the agent precisely what is missing. Vague responses break the loop. Specific, structured responses let the agent collect exactly the right thing and move forward.

Core capabilities every store must support

UCP defines a required core, plus optional extensions you add only when your business genuinely needs them.

Required for all merchants:

• Checkout session creation and management. The agent initiates a session, receives a session ID and makes all subsequent updates against it.
• Line items with proper pricing. Products, quantities, unit prices, taxes and any item level detail.
• Discount code application. The agent submits a code and receives updated totals in the same exchange.
• Buyer information collection. Shipping address, email and anything else you genuinely use.
• Payment handler attachment. Shop Pay, Google Pay, cards or your configured processor.
• Purchase completion with confirmation. A real order number and confirmation details returned to the agent.

That is the whole floor. A store that does these six things well will complete more agentic orders than a store with every extension implemented and unclear error messages.

Optional extensions, and how to decide

Four extensions cover most of what sits above the core.

• Fulfilment (dev.ucp.shopping.fulfillment) for multiple shipping methods, in store pickup, local delivery, or delivery date and time selection.
• Subscriptions (dev.ucp.shopping.subscription) for recurring products where the buyer chooses a billing cadence.
• Loyalty (dev.ucp.shopping.loyalty) for points or rewards a customer can earn and redeem at checkout.
• Pre orders for products not yet in stock, sold against an expected ship date.

The decision is not which extensions exist but what your checkout actually requires.

If you are a standard direct to consumer brand shipping physical products, you need a shipping address, an email and a payment method. Nothing else. Do not make agents collect information you never use.

If you sell furniture and need the buyer to pick a delivery window, you need the fulfilment extension, because without it every checkout escalates.

If you sell refills or replenishables on a subscription, you need the subscription extension so the buyer can choose frequency inside the conversation instead of on a landing page.

If you run a points programme, you need the loyalty extension, because a programme an agent cannot apply is a benefit you advertise and fail to deliver.

The protocol is deliberately flexible. Implement what you need and skip the rest.

Payment handler negotiation

This is the most powerful part of UCP and the part most merchants underestimate.

Traditional checkout pushes the buyer into whatever you have configured. UCP negotiates from both sides, per transaction.

Your store declares what it supports, for example Shop Pay, Google Pay, cards through Shopify Payments and Apple Pay. The agent declares what the buyer can actually present, for example Google Pay because a wallet is configured, and a saved card. UCP resolves the intersection and only the mutually supported options are live for that transaction.

That intersection is not fixed. Change the destination country, the cart contents or the order value and the surviving set can change with it. A buyer in Germany may see different handlers than a buyer in the United States. A high value cart may trigger different fraud rules.

The implication is blunt. If you support one payment method, you have made escalation your default state. Every handler you leave disabled narrows the set of buyers an agent can close for you.

A sensible baseline:

• Enable Shop Pay. It is native to Shopify and works across AI surfaces.
• Support Google Pay. It carries disproportionate weight inside Google AI Mode and Gemini.
• Keep a card handler live as the fallback for everything the wallets do not cover.

A note for merchants selling into India

If your store runs a third party checkout layer, which is common for Indian brands, the UCP question moves to your vendor. Ask them directly whether they expose a UCP compliant checkout session and, if not, what the roadmap is. Until that answer exists, keep native Shopify checkout viable as the path agents can use, and treat the third party layer as the human facing experience.

Worth noting too: agentic checkout is structurally prepaid. An agent presenting payment credentials is presenting a wallet or a card, not selecting cash on delivery. For brands carrying heavy COD volume, AI driven orders should arrive as a cleaner prepaid cohort with better return to origin behaviour. Measure that cohort separately rather than blending it into your overall numbers.

When AI cannot complete checkout

Some transactions will always need a person. Regulatory constraints, merchant policy or a capability the agent does not support yet.

UCP handles this through a structured handoff called the Embedded Checkout Protocol.

1. The agent attempts to complete. Your store returns requires_escalation along with a continue URL.
2. The agent presents that URL to the buyer, framed as a step to finish the purchase.
3. The buyer lands in an embedded Shopify checkout, already prefilled with everything the agent collected.
4. The buyer supplies the missing piece, whether that is a delivery date, an age confirmation or a size.
5. The order completes and confirmation flows back to the agent, including tracking once available.

Common escalation triggers:

• Age verification for alcohol, tobacco or other restricted products
• Delivery window selection, typical for furniture and large goods
• Size or fit confirmation on apparel and high value items
• Terms acceptance for final sale items, pre orders or special conditions
• Complex configuration where a product has extensive customisation

Escalation is not failure. It is a designed part of the protocol. What matters is that the handoff is seamless and the buyer loses nothing on the way through.

Two things to get right. First, never escalate for something you could have described programmatically, because each avoidable escalation costs you a share of the conversions. Second, remember that the escalation page is one of the few moments where the buyer sees your brand rather than an agent’s summary of it. It should look like you.

Getting discount codes right

Agents apply codes the same way humans do, but they cannot interpret a shrug.

Your store should return, in a single response: whether the code was accepted, the specific reason if it was not, updated line item pricing showing any discount applied, and the updated order total.

A poor response is “Invalid code.” The agent learns nothing and can offer the buyer nothing.

A good response names the obstacle and the remedy. Something like: the code requires a minimum order value of five thousand rupees, the current cart total is four thousand five hundred, and adding five hundred more qualifies. That response converts a dead end into an upsell automatically, with no copy written by you.

The same principle covers expiry, product exclusions and single use codes. Say what happened and say what would fix it.

Loyalty programmes

If you run one, agents need to be able to do four things:

• Identify whether the buyer is a member, usually by email or account lookup
• Read the available points or reward balance
• Apply points to the current purchase
• Return updated totals reflecting the redemption

This runs through the loyalty extension, and it requires you to publish the mechanics clearly: the points balance, the redemption ratio in plain terms such as five hundred points equalling a fixed discount, and any restrictions on minimum redemption or excluded products.

A half implemented loyalty programme is worse than none, because the agent will surface a benefit it then cannot deliver.

Subscription billing cadences

For subscription products, the agent has to present real options and let the buyer choose:

• One time purchase against subscription
• Billing frequency, whether monthly, quarterly or annual
• Any subscription saving, stated explicitly

The subscription extension carries this, but you have to define the available intervals, the price at each interval and the terms, including whether cancellation is open ended or subject to a commitment period. An agent will not infer that quarterly is your best value tier. Tell it.

Order management and post purchase

Checkout completion is not the end of the relationship. Agents increasingly handle tracking, service questions and returns guidance, and most stores are currently unable to help them.

Once an order is placed, your store should be able to return the order number, confirmation that an email was sent, an estimated delivery date and a tracking URL once one exists.

With the orders capability implemented, agents can look up order status by order number or email, retrieve tracking, check delivery estimates and access order history for returning customers. In practice that means a buyer asking an assistant where their order is receives a real answer with a live tracking link, instead of a message saying the information cannot be accessed. To the customer, that second answer reads as a failure of your brand, not of the protocol.

Returns are not yet defined in the protocol, which makes your published content the substitute. Keep a clear return policy in your knowledge base, expose a returns portal URL agents can direct buyers to, keep service contact details current, and offer self service wherever possible. Agents will quote what you publish, so the quality of your policy page is now the quality of your service in that channel.

Testing your implementation

Test thoroughly before any of this is live, using Shopify’s UCP Playground at ucp.dev/playground.

Start with the paths that should work:

• Happy path checkout with the minimum information set
• Discount codes, valid and invalid, checking the clarity of each response
• Every payment handler you have declared
• Escalation flows, confirming the continue URL works and collected data persists
• Order lookup by both email and order number

Then break things deliberately. Out of stock variants, invalid postal codes, declined cards, expired codes, carts below a minimum order threshold. What you are testing is not whether the store fails, but whether it fails legibly.

Finally, test on the surfaces themselves, because each implements UCP slightly differently. That means ChatGPT through the Shopify integration, Google AI Mode and Gemini through Agentic Storefronts, and Microsoft Copilot through Copilot Checkout.

Track four numbers per surface: checkout completion rate, escalation frequency, payment handler success rate and error message clarity. The first three are quantitative and the fourth is a judgement call, but it is usually where the remaining gains sit.

Five mistakes that cost conversions

1. Requiring information you never use. The phone number you have never once dialled is now an escalation trigger. Audit every field and remove anything that is inherited habit rather than genuine need.

2. Vague error messages. “Unable to complete purchase” is not an error message. “Shipping address rejected: postal code format invalid for this country” is. Write errors for a system that has to act on them.

3. Not supporting Shop Pay. It is built into Shopify and works everywhere. Leaving it off manufactures escalations you did not need to have.

4. Complex fulfilment without the extension. If you require delivery date selection and have not implemented fulfilment, every checkout escalates. Implement it, or simplify the requirement.

5. Ignoring order management. Checkout failure is the loud problem. Order lookup failure is the quiet one, and it is the one customers remember.

The ninety day plan

Weeks one and two: audit. List every field your checkout currently collects. Separate genuinely required from historically collected. Document special requirements such as age verification or delivery windows. Decide which extensions you need, and establish where any third party checkout layer sits in the picture.

Weeks three and four: payments. Enable Shop Pay if it is not already active. Verify Google Pay. Confirm card fallback works. Test handler negotiation across at least two destination markets if you ship internationally.

Weeks five and six: core capability. Set up the UCP profile endpoint. Build session creation and updates. Implement discount code application with informative rejections. Configure buyer information collection against the trimmed field list from your audit.

Weeks seven and eight: extensions. Add fulfilment, subscription or loyalty only where the audit justified them. Test each independently before combining.

Weeks nine and ten: escalation. Map every scenario that genuinely needs a human. Implement continue URL generation. Test the embedded handoff and verify buyer data persists all the way through. Brand the escalation experience.

Weeks eleven and twelve: test and optimise. Full Playground run, live testing across all three surfaces, monitoring of completion rate and iteration on error messages.

Twelve weeks assumes you are implementing thoughtfully rather than rushing something broken into production. The audit alone usually pays for itself, because the fields you remove improve your human conversion rate immediately.

Where this leaves you

Once this work is done, agents can discover your products, understand what you sell and complete a purchase without a human ever touching your storefront. The next question is measurement: how you identify AI referred traffic and attribute the conversions it produces.

If you want to know where your store stands right now, run it through ucp.dev/playground and watch where it stops answering. That is your work list.

Frequently asked questions: UCP Checkout for Shopify

What is the UCP checkout state machine?

It manages AI driven transactions through three states: incomplete when required information is missing, requires escalation when the buyer has to provide something the agent cannot, and ready for complete when everything has been collected. Unlike linear checkout, UCP negotiates between agent and store at each stage.

What core capabilities must my Shopify store support?

Creating and managing checkout sessions, line items with proper pricing, discount code application, buyer information collection, payment handler attachment and purchase completion with confirmation. Extensions for fulfilment, subscriptions and loyalty are optional and depend on your business.

How does payment handler negotiation work?

Both sides declare what they support and UCP resolves the intersection per transaction. Your store might offer Shop Pay, Google Pay and cards while the agent declares the credentials the buyer holds. Only mutually supported options are presented, and the set can shift with location, cart contents and other variables.

What is the Embedded Checkout Protocol?

It is the structured handoff used when an agent cannot complete checkout programmatically. Your store returns a requires escalation status with a continue URL, the buyer opens an embedded Shopify checkout prefilled with what the agent already collected, supplies the missing detail, and confirmation returns to the agent.

How should discount codes work with AI agents?

Agents must be able to submit a code and receive updated totals in the same call. Return acceptance or rejection, the specific reason for any rejection, updated line item pricing and the new order total. Specific responses let the agent guide the buyer to qualify; vague ones end the session.

Which extensions does my store need?

Fulfilment if you offer multiple shipping methods, pickup, local delivery or delivery slot selection. Subscription if you sell recurring products with selectable billing frequency. Loyalty if points can be redeemed at checkout. A standard brand shipping physical goods against an address, an email and a payment method needs none of them.

How do I test before going live?

Use the UCP Playground at ucp.dev/playground. Cover the happy path, discount codes, every payment handler, escalation flows and order lookup, then edge cases including out of stock products, invalid addresses, declined payments and expired codes. Then test on ChatGPT, Google AI Mode and Copilot, tracking completion rate, escalation frequency, handler success rate and error clarity.

What are the most common UCP checkout mistakes?

Requiring unnecessary information, returning vague error messages, not supporting Shop Pay, having complex fulfilment requirements without the fulfilment extension, and ignoring order management so agents cannot answer post purchase questions.

Can agents help with order tracking after the sale?

Yes, with the orders capability implemented. Agents can look up status by order number or email, retrieve tracking, check delivery estimates and access order history, so a buyer asking where their order is gets a real answer without logging into your store.

How does this work with cash on delivery?

Agentic checkout is inherently prepaid, since the agent presents wallet or card credentials rather than selecting cash on delivery. For brands with high COD volume, AI driven orders should behave as a cleaner prepaid cohort with better return to origin rates, and are worth measuring separately.

How long does implementation take?

Around ninety days: two weeks of audit, two on payment handlers, two on core capability, two on extensions, two on escalation flows and two on testing and optimisation. The timeline assumes proper testing rather than a rushed launch.

NOIR & BLANCO builds and maintains Shopify stores for premium and luxury brands across India, Australia, USA, UK, UAE, Canada, and beyond, including the checkout audit, extension decisions, payment configuration, escalation experience and testing regime described here.