Which Online Stores Can AI Agents Actually Buy From Right Now?

Yes, but only at a handful of retailers, and only if a machine can actually read the product page. Google's Universal Commerce Protocol (UCP), OpenAI's Agentic Commerce Protocol (ACP, built with Stripe), and Shopify's own agent-facing checkout endpoint are all live right now, and each one already has real merchants behind it. The catch: none of them will let an agent buy from a store that hasn't published the structured product data those protocols require. Most ecommerce sites haven't.

Can an AI agent actually complete a purchase on an ecommerce site today?

Yes, on a specific and growing list of stores, and the buying flow is not a demo. Three separate checkout paths now exist where an agent can search, select a product, and pay without handing the person back to a browser tab: Google's UCP, OpenAI's ACP (running through Stripe), and Shopify's agent commerce endpoint. Each has named retail partners live in production, not in a beta waitlist.

This is a meaningfully different claim from "AI can help you shop," which has been true since chat assistants started summarizing product reviews. Assisted browsing means the agent talks, the human clicks buy. Agent checkout means the agent completes the transaction inside the conversation. The distinction matters for readiness planning, because the requirements are not the same: a page written well enough for an assistant to summarize is not automatically a page an agent can transact against.

Which protocols let an agent add a product to cart and pay?

Three protocols currently do the heavy lifting, and a store's readiness work looks different depending on which one its customers arrive through. Google's Universal Commerce Protocol standardizes how a merchant exposes a product catalog, pricing, and checkout to an agent acting on Google's surfaces. OpenAI's Agentic Commerce Protocol, built jointly with Stripe, handles the same job for agents operating inside ChatGPT, with Stripe processing the actual payment. Shopify took a third route: rather than a bespoke commerce protocol, it exposed a standard Model Context Protocol server so any properly authenticated agent can query a merchant's catalog and place an order using the same open protocol, documented at modelcontextprotocol.io, that already powers agent tool use elsewhere.

None of the three require a store to guess at a proprietary integration. All three converge on the same underlying expectation: a machine-readable product record with unambiguous identifiers, current pricing, and real-time availability, expressed as structured data rather than buried in page copy an agent has to interpret.

Which stores can a shopping agent actually reach right now?

The retailer list is short but no longer experimental. UCP's early adopters include large-format retailers with the catalog scale to make agent checkout worth the integration cost, alongside a wave of Shopify merchants who picked it up through their platform rather than a direct deal with Google. ACP launched inside ChatGPT with payment processing partners including PayPal and Shopify on the merchant side. Shopify's own move was the more consequential one for smaller stores: since mid-2026, any developer can register an agent against Shopify's public storefront MCP endpoint without going through an approval process first.

That last point changes the shape of the problem. When agent checkout required a direct partnership with a platform, only stores with enterprise sales relationships needed to care. An open, no-approval registration path means the population of agents attempting to browse and buy from any Shopify store, regardless of size, is growing on its own. A store doesn't need to sign anything to become reachable. It needs its product data to be readable when an agent shows up.

What does a product page need before an agent will buy from it?

An agent will not add a product to a cart based on marketing copy, hero images, or a persuasive description; it needs a structured, machine-parseable record it can trust. The baseline is schema.org's Product type, paired with an Offer object carrying price, currency, and availability. The set of schema types agentic commerce specs are converging on runs six deep: Product, Offer, AggregateRating, Review, FAQPage, and ReturnPolicy. Most stores have the first two from years of Google Shopping work and are missing the last one entirely, which matters because an agent completing a purchase on a customer's behalf has no way to ask about your return policy mid-checkout. If it isn't in the schema, the agent either skips the purchase or invents an answer, and neither outcome is good for the merchant.

Underneath the schema, the specs also expect a defined set of core product attributes an agent can extract without inference: title, description, brand, GTIN or MPN, a standard product category, price, sale price, availability, condition, an image URL, and a canonical product URL. A store that has GTINs sitting in a spreadsheet but not in the page's structured data looks, to an agent, exactly like a store that never collected them at all.

How is this different from ranking in Google Shopping?

Ranking well in Google Shopping and being buyable by an agent solve overlapping but distinct problems, and treating them as the same project is the most common mistake stores make first. Shopping feed optimization is built to win a human's click: competitive pricing, image quality, review counts, and feed freshness all push a listing higher in a results grid a person scans and chooses from. Agent checkout readiness is built to survive a machine's parsing pass with zero ambiguity: the agent isn't scanning a grid, it's executing a decision tree that fails closed the moment a required field is missing, malformed, or only present as free text.

A product can sit in the top position of a shopping feed and still fail agent checkout if its return policy lives in a footer link instead of structured data, or if its price is only computable after a login wall. Conversely, fixing agent readiness rarely hurts feed performance, since the same accurate, complete Product and Offer data that satisfies an agent also satisfies Google's shopping feed requirements. The two projects should run together, not compete for the same sprint.

Ready to see exactly which structured data your product pages are missing? Run a free AI readiness scan before you plan the fix.

What should an ecommerce store fix first?

Start with the fields that block a transaction outright, not the ones that merely improve quality. In order: publish or complete Offer schema with real-time price and availability so an agent isn't computing stale numbers; add ReturnPolicy schema, since its absence is the single most common gap and the one most likely to make an agent abandon a cart; fill in GTIN or MPN identifiers across the catalog rather than a sample of hero products; confirm pricing is visible without a login or a "contact us" step, since agents cannot negotiate access; and verify the product URL structure is stable and canonical, since an agent that can't resolve a consistent URL for a SKU can't complete a repeat purchase or process a return against it.

Faro's AI Schema tool checks a store's product pages against this exact set of requirements and flags which ones are missing before an agent finds out the hard way. For stores that also want their catalog and policies discoverable outside any single protocol, publishing an Open Knowledge Format file gives any agent, not just one tied to a specific checkout partner, a single machine-readable summary of what you sell and how you operate. And because this is squarely an industry-specific problem, the AI readiness guide for ecommerce breaks down the full checklist by store size and platform.

None of this replaces the broader readiness work most stores still owe an agent before it will recommend them at all, covered in Faro's guide to AI readiness for ecommerce stores, or the wider mechanics of what agents need to complete any transaction, detailed in the guide to agent commerce readiness. Checkout is the last step in a chain that starts with an agent being able to find and trust the store in the first place, a chain explained in what WebMCP actually does when an agent visits your site.

Frequently asked questions

Do AI agents actually buy things from online stores today?

Yes, on stores that support Google's UCP, OpenAI's ACP, or Shopify's agent commerce endpoint. The transaction completes inside the agent conversation rather than handing the shopper back to a browser, and each protocol already has live retail partners rather than a pilot waitlist.

What is the difference between UCP, ACP, and MCP for commerce?

UCP is Google's protocol for exposing a catalog and checkout to agents on its own surfaces. ACP is OpenAI's equivalent for ChatGPT, processed through Stripe. Shopify didn't build a new protocol; it exposed a standard Model Context Protocol server so any agent can query its merchants' catalogs through the same open spec used for other agent tool calls.

Does my store need to support all three?

Not necessarily, but the underlying requirement is nearly identical across all three: complete, current Product and Offer schema, real-time availability, and increasingly ReturnPolicy data. Fixing that foundation makes a store closer to ready for whichever protocol its customers' agents actually use.

Will optimizing for agent checkout hurt my Google Shopping performance?

No. Agent readiness and shopping feed performance both depend on accurate, complete Product and Offer data. Improving one typically improves the other, since neither rewards incomplete or stale product records.

How do I know if my product pages are agent-readable?

Check whether Product, Offer, and ReturnPolicy schema are present and complete, whether GTIN or MPN identifiers exist for every SKU, and whether price and availability are visible without a login. A structured data scan against these specific fields will surface the gaps faster than manual review.

Is agent checkout only relevant to large retailers?

No. Shopify's open, no-approval agent registration means any merchant on that platform can already be queried by an agent, regardless of size. Reachability is no longer gated by partnership deals; readiness is what determines whether that reachability turns into a completed sale.

In short

AI agents can already buy from real online stores, not just browse them: Google's UCP, OpenAI's ACP, and Shopify's agent commerce endpoint are live with named retail partners, and Shopify's open registration means any merchant on that platform is reachable without a partnership deal. Reachability isn't readiness. An agent still needs complete Product and Offer schema, a defined set of core attributes like GTIN and price, and increasingly ReturnPolicy data before it will complete a transaction rather than abandon it. None of this competes with traditional shopping-feed SEO; the two run on the same underlying data and should be fixed together, starting with whichever field currently blocks a transaction outright.

See exactly where your store's structured data stands before an agent finds the gap for you. Check your product schema with Faro's AI Schema tool.