Home / Blog / What is UCP

What is UCP? Google and Shopify's Universal Commerce Protocol, explained

7 min read · Protocols · Updated 2026

UCP is the Universal Commerce Protocol, an open standard co-developed by Google and Shopify and launched at NRF in January 2026. It is how an AI shopping agent discovers what your store can do, understands your catalogue, and completes a purchase without a human ever touching your site. If you build or run e-commerce stores, this is the single most important specification to understand right now.

The naming in this space gets muddled fast, so let us be precise. UCP is not a vendor product and not a proprietary rubric. It is an open-source specification, published at github.com/universal-commerce-protocol/ucp with implementation guidance at developers.google.com/merchant/ucp. Its adopter list already includes Etsy, Wayfair, Walmart, Target and Home Depot, and its Tech Council has expanded well beyond the original two authors to include Amazon, Meta, Microsoft, Salesforce and Stripe. When a standard attracts that set of names inside a year, it stops being a bet and starts being the floor.

The core idea: your store declares what it can do

UCP is built on a decentralised, merchant-as-source-of-truth philosophy. Rather than every AI platform negotiating a bespoke integration with every retailer, the merchant publishes a machine readable declaration of its own capabilities, and any compliant agent reads it.

That declaration is a JSON manifest hosted at a standardised path: /.well-known/ucp. Think of it as your store's public technical business card for machines. It declares:

• Supported capabilities, namespaced strings such as dev.ucp.shopping.checkout or dev.ucp.shopping.fulfillment, telling an agent exactly which operations your store will honour.
• Schema versions, so an agent knows which revision of the specification your endpoints speak and can negotiate compatibility at runtime.
• Payment handlers, declaring how a transaction can actually be settled.
• Public signing keys, typically ECDSA P-256, so your middleware can verify that an inbound request genuinely came from an authorised agent and not from a bot wearing a costume.

Underneath, UCP is an extensibility protocol built on JSON Schema, using ucp_request and ucp_response annotations so a single schema can serve both directions of an operation without duplication. Capabilities compose, and agents negotiate them dynamically rather than assuming a fixed contract.

UCP is transport-agnostic, which is why it matters

UCP does not force a single wire format. It supports plain REST, Anthropic's Model Context Protocol (MCP), and Google's Agent-to-Agent (A2A) standard as transport bindings. The practical consequence is powerful: a UCP checkout capability exposed as an MCP tool becomes instantly callable by any MCP-compatible agent, including assistants that have never heard of UCP. One implementation, many surfaces.

It also covers the whole commerce journey rather than just the moment of payment. Discovery, cart assembly, checkout, fulfilment and post-purchase support all sit inside scope, expressed as primitives such as search_inventory, assemble_cart and complete_checkout. Crucially, the merchant remains the Merchant of Record and keeps the customer relationship and first-party transaction data. UCP was designed so retailers do not surrender their business to whichever assistant happens to send the traffic.

How UCP relates to ACP, AP2 and MCP

These are complementary layers, not rivals fighting for one slot. We cover each in a sibling article, but in short: MCP is the tool and transport plumbing, AP2 is the cryptographic authorisation layer that proves a human allowed an agent to spend, ACP is OpenAI and Stripe's checkout specification, and UCP is the full-lifecycle commerce standard that can ride on top of MCP or A2A. Serious merchants are implementing more than one, exactly as retailers once optimised for Google Shopping and Amazon simultaneously.

UCP is how your store tells an agent what it can do. Conformance is how you find out whether the agent believes you.

Where Goofre™ fits: measuring conformance

Publishing a manifest is not the same as being ready. A manifest can exist and be malformed, be served without the CORS headers an agent needs, declare a schema version your endpoints do not actually honour, or carry signing keys in the wrong format. Each of those looks fine to a human glancing at the file and fails hard for a machine.

This is the job Goofre™ does. Goofre™'s readiness engine audits a live store and grades its UCP conformance alongside the wider readiness picture: whether the manifest is present and valid, whether it is reachable and correctly versioned, whether signing keys are properly formed, and whether the capabilities it advertises hold up when exercised. The factor set ships inside every audit report, so the merchant and their Agentic Commerce Orchestrator™ (ACO™) see the same evidence: what was tested, what passed, what did not, and why it matters.

The result is not an opinion about your store. It is a statement about how far your store carries a real agent, measured against a public bar that Google, Shopify and most of the industry have already agreed on.

Five layers, and why the score runs tough

Goofre™ grades across five layers, and each gates the next, because that is the order an agent walks: Access (can it reach you), Comprehension (can it understand your catalogue), Identity and trust (can it trust you enough to act), Transactability (can it actually complete a purchase), and Reliability (does it stay true next time).

A free checker asks a shallow question: is the tag present? The harder question is whether an agent could actually act on it. A Product markup can validate cleanly and still carry a price that disagrees with the feed. A return policy can exist and still live only in a PDF an agent cannot quote. So the score is weighted toward transactability on purpose, because being mentioned by an agent is marketing and being buyable by one is revenue.

Honest trajectory, and turning a score into work

Standards move, agents get stricter, and catalogues drift. If the scoring engine changes between two audits, a month-over-month comparison is meaningless because you are comparing two different rulers. Every Goofre™ audit is therefore stamped with the engine version that produced it, so an ACO™ can say with confidence whether the store genuinely improved or the ruler simply changed.

From there the report becomes an ordered queue. Because the layers gate each other, priority is not guesswork: an access failure outranks a comprehension gap, and a trust gap outranks a cosmetic one, since nothing above a broken layer can pay off until that layer is fixed. An ACO™ works the report top down, then re-audits against the same versioned engine to confirm the score moved for real. That is the loop, and it starts with Magento stores.