What Is UCP and How to Check It
Last updated:
UCP — the Universal Commerce Protocol — is the open standard that lets an AI assistant shop on a store's behalf. A store publishes a small machine-readable profile at /.well-known/ucp, and any assistant that speaks the protocol can read it to find out which version the store speaks, how to reach its catalog and checkout, and which payment handlers it accepts — no custom integration per store, no screen-scraping, no guessing. It is the same problem llms.txt solves for content, applied to commerce: a human reads a storefront, but an agent needs a manifest. You can paste any store into the UCP Checker and read its profile as a verdict — reachable, well-formed, current, or not UCP at all — but this article teaches you to read the document yourself, so the next time a profile fails, you can see why in the text.
What UCP is — and why AI assistants need it
UCP is an open standard from Google, co-developed with Shopify, that gives AI assistants one shared language for shopping: discover a store, search its catalog, build a cart, check out, and track the order afterwards. The assistant talks to the store through the protocol instead of through a bespoke integration, and the merchant stays the merchant of record — keeping its customer data and relationships, as Google's own guide puts it. The point of the standard is to collapse an N-by-N integration problem: without it, every assistant would need a separate deal with every merchant; with it, both sides implement once and interoperate.
The need is new because the shopping surface is new. Assistants now meet shoppers inside AI Mode in Google Search and the Gemini app, where a question can turn into a purchase without ever opening a storefront tab. A chat window cannot click "add to cart", so the assistant needs a way to ask the store, in machine terms, what it sells, how to buy it, and what happens after the sale. UCP is that way: it covers the full journey from discovery through checkout to after-sales — orders, fulfillment, discounts — and it is designed to interoperate with the neighbouring standards for transport (MCP, A2A) and payment proof (AP2), rather than replacing them.
The discovery file: /.well-known/ucp and its three required fields
The whole protocol starts with one file. A business publishes its profile — a JSON object with a required ucp member — at /.well-known/ucp, and a platform fetches it before doing anything else. Inside ucp, three fields are required: version, the protocol version as a date; services, the API surfaces the business offers, keyed by reverse-domain name such as dev.ucp.shopping, each entry pairing the service with one transport binding (REST, MCP, A2A or embedded) and an endpoint; and payment_handlers, the payment methods it accepts. The last two must be present even when empty — an empty object is a valid statement ("we offer no services yet"), a missing field is a broken profile. A fourth member, capabilities, is optional but is what makes a profile useful: it lists the individual features — checkout, cart, order, catalog search — each with its own version, spec and schema URLs.
The file also has hosting rules, and they are strict for a reason. Published profiles must be served over HTTPS, must not redirect, and must carry Cache-Control: public with a max-age of at least 60 seconds — never private, no-store or no-cache. A profile is a store's stable identity and capability list, not a per-transaction response, so it is meant to be cached and fetched cheaply; a redirect or a no-cache directive tells a platform the publisher has not set the document up as the stable manifest the protocol expects. Platforms advertise their own profile in the other direction, in the UCP-Agent request header, which is what makes onboarding permissionless: any platform with a discoverable profile can talk to any business with one, without prior registration.
Reading a real document by hand: Allbirds
Shopify storefronts publish a UCP profile by default, so any of them is a live example — take Allbirds, fetched on 21 November 2026. Its ucp.version is "2026-08-25", the current release, and a supported_versions object maps two older releases — 2026-04-08 and 2026-01-23 — to versioned profile URLs on its myshopify.com domain, so older clients can still negotiate. Under services, dev.ucp.shopping appears twice: once with transport mcp at /api/ucp/mcp and once with transport embedded — and note what is absent: there is no rest entry. A store does not have to offer every transport; it advertises the ones it actually runs. A second service, dev.ucp.common, is also offered over MCP.
The capabilities object is where the document gets specific. Allbirds advertises dev.ucp.shopping.checkout, cart, order, catalog.search and catalog.lookup, plus extensions: fulfillment and discount, both of which declare that they extend checkout and cart, and buyer_consent, identity_linking and a permalink capability. The names are reverse-domain by design: dev.ucp.* names are governed by the UCP body, while dev.shopify.* entries — here dev.shopify.catalog and the dev.shopify.shopping.declared_fields extension — are Shopify's own. Under payment_handlers sit three handlers: com.google.pay, dev.shopify.card and dev.shopify.shop_pay, each with its own version, spec and schema. One thing is missing, and its absence is fine: the document carries no top-level keys array. Signing keys are optional — a profile only publishes them when the store signs requests — so a profile without keys is not a broken profile.
Versions are dates — and 2026-08-25 broke things
UCP versions are calendar dates in YYYY-MM-DD form, and the specification is blunt about it: a business must not advertise a non-date version string such as "draft" in its profile. The current release is 2026-08-25; earlier releases live on through supported_versions, each pointing at a complete, self-contained leaf profile for that date. Compatibility is established by exact version equality, not by "newer is better": a platform and a business intersect the versions they both support, and if there is no shared version the business must answer version_unsupported. There is one more tripwire worth knowing: every dev.ucp.* service, capability and extension entry in a profile must declare the same version as the profile's ucp.version, and a platform that meets a mismatched entry must reject that entry outright, treating it as absent.
That is why an old version earns a warning rather than a pass. The 2026-08-25 release was the protocol's largest structural change: it removed the old signing_keys[] field from the profile schema and made the top-level keys[] array — a JWK Set — the only canonical place for signing keys, so a client built for the new release that reads signing_keys finds nothing; it moved the payment extensions out of the dev.ucp.shopping.* namespace into dev.ucp.common.payment.*; it restructured buyer consent from fixed boolean flags into a dynamic map; and it consolidated the fulfillment configuration. A store still on 2026-04-08 keeps working for clients that speak 2026-04-08, which is exactly what supported_versions is for — but an assistant that only speaks the new release will find no mutually supported version, and any tooling that keys off the old names or fields will silently miss. Old, in UCP, means "frozen in time", not "broken" — and the warning is the difference.
UCP vs ACP vs AP2 vs x402
ACP — the Agentic Commerce Protocol, co-developed by OpenAI and Stripe — covers the checkout step inside a chat surface such as ChatGPT: the buyer approves the purchase in the conversation, and the business checks out through its own payment provider. It is checkout-scoped, not a full shopping journey: it answers how the buyer pays in the chat, and leaves catalog discovery and after-sales to something else. Think of it as UCP's parallel on OpenAI's surfaces, where UCP is the equivalent on Google's.
AP2 — the Agent Payments Protocol, published by Google — answers a different question: not how checkout runs, but what the user actually authorised. It produces signed, verifiable mandates — a checkout mandate for the purchase itself and a payment mandate for the payment side — so a merchant, a network and an issuer can each check the same proof instead of trusting the agent's word. It is designed to work alongside UCP, supplying the signed authorisation inside a UCP flow, rather than competing with it.
x402 — created by Coinbase — answers a third question: how does an agent pay for one thing, once, with no account and no checkout page? It revives the dormant HTTP 402 Payment Required status code: the agent requests a paid resource, the server answers 402 with a price, and the agent retries with a signed payment, usually in stablecoins settled on-chain. It is a pay-per-call meter for APIs, data and content — the right tool when the purchase is a single request, and the wrong shape for a shopping cart.
The four are complements, not rivals, and most real systems combine them: UCP runs the shopping journey, AP2 can supply the signed proof inside it, x402 prices individual calls along the way, and ACP is the checkout path on OpenAI's surfaces. That is also the boundary of this site's checker: the UCP Checker reads UCP profiles only. It does not fetch or validate ACP, AP2 or x402 documents, so a store can be UCP-ready and still have no ACP or AP2 presence at all — the protocols are independent, and a missing one is not a failure of the other.
What the UCP checker does — and what it does not do
The checker fetches https://<target>/.well-known/ucp through the server-side checker service — your browser never fetches the target directly, because cross-origin rules would block most stores — and then works through the profile the way the specification does. It checks the document is reachable over HTTPS with no redirect (a redirect is a fail, per the spec), reads the Cache-Control header and quotes its actual value, parses the JSON and reports the exact parse error if it fails, and verifies the three required fields are present, the version is a date, and the version is not older than 2026-08-25. It lists every service with its transport and version, every payment handler, and every capability with the service it belongs to, and it probes each declared endpoint for reachability. The verdict is one of three: UCP-ready, partial, or not-UCP — a 404 on the profile is the common negative, and the checker says so explicitly.
What it does not do matters just as much. It does not place an order, does not authenticate as a buyer, and does not validate the cryptography of payment handlers — the presence of a keys[] array proves provenance (the keys belong to the domain that published them), not trust, and the specification says so in so many words. It does not check ACP, AP2 or x402 documents. And a clean result is not a promise that checkout will succeed: the profile is advertising, not a transaction, and the endpoint behind it may still demand authentication, a buyer account, or merchant approval before it does anything. A clean check means the store describes itself correctly and can be discovered; whether the purchase completes is a question for the store's own systems. For the broader picture — whether a site is ready for agents at all, discovery file included — the Agent Readiness Checker checks for the UCP file among its other signals.
Try it yourself: a minimal UCP profile, annotated by its own shape
{
"ucp": {
"version": "2026-08-25",
"services": {
"dev.ucp.shopping": [
{
"version": "2026-08-25",
"transport": "rest",
"endpoint": "https://business.example.com/ucp/v1",
"spec": "https://ucp.dev/2026-08-25/specification/overview/",
"schema": "https://ucp.dev/2026-08-25/services/shopping/rest.openapi.json"
},
{
"version": "2026-08-25",
"transport": "mcp",
"endpoint": "https://business.example.com/ucp/mcp",
"spec": "https://ucp.dev/2026-08-25/specification/overview/",
"schema": "https://ucp.dev/2026-08-25/services/shopping/mcp.openrpc.json"
}
]
},
"capabilities": {
"dev.ucp.shopping.checkout": [
{
"version": "2026-08-25",
"spec": "https://ucp.dev/2026-08-25/specification/shopping/checkout",
"schema": "https://ucp.dev/2026-08-25/schemas/shopping/checkout.json"
}
]
},
"payment_handlers": {
"com.example.processor_tokenizer": [
{
"id": "processor_tokenizer",
"version": "2026-08-25",
"spec": "https://example.com/specs/payments/processor_tokenizer",
"schema": "https://example.com/specs/payments/merchant_tokenizer.json"
}
]
}
}
}