What is Universal Commerce Protocol (UCP)?

Universal Commerce Protocol is an open commerce standard co-developed by Google and Shopify. It gives AI platforms, agents and merchants a common machine-readable contract for commerce capabilities including product discovery, checkout, orders, post-purchase state and negotiated payment handling.

How does a shopping agent discover UCP support?

UCP defines a machine-readable profile that can be exposed at /.well-known/ucp. The profile declares the protocol version, supported commerce capabilities and payment handlers so an agent can negotiate what the merchant actually supports before starting a transaction.

Is UCP the same as Agentic Commerce Protocol (ACP)?

No. UCP and ACP overlap around agent-to-merchant commerce state, but they are separate specifications with different ecosystems. UCP was co-developed by Google and Shopify and emphasizes capability negotiation across a broad commerce lifecycle; ACP is maintained by OpenAI and Stripe. Merchants may support more than one protocol for different agent surfaces.

Does UCP replace AP2, MCP or x402?

No. UCP describes commerce semantics. AP2 can supply delegated payment authorization, MCP can be used as a transport or tool-access layer, and x402 is a payment protocol for HTTP resources. These layers can compose when an architecture needs them.

What is the current stable UCP specification version?

The public UCP documentation currently lists 2026-08-25 as a stable specification release, alongside earlier stable snapshots from 2026-04-08, 2026-01-23 and 2026-01-11.

Editorial

Explainer · agentic commerce

Universal Commerce Protocol gives shopping agents a common contract from discovery through post-purchase.

Universal Commerce Protocol, or UCP, is an open standard co-developed by Google and Shopify for connecting AI platforms, shopping agents and merchants without rebuilding the commerce contract for every new interface. It defines machine-readable commerce capabilities, lets merchants and agents negotiate what both sides support, and keeps payment handling composable instead of hard-wiring one wallet or processor into the protocol.

Published 12 September 2026 · current stable-spec status and sources below

2026-08-25

current stable UCP specification snapshot listed by the public docs

/.well-known/ucp

merchant discovery profile shown in the UCP flow

REST · GQL · JSON-RPC · A2A · MCP

transports Shopify lists for the same commerce logic

What UCP solves

Every new AI storefront should not require a brand-new commerce integration

Human storefronts hide a lot of state in UI. A person can interpret a disabled button, notice that a discount disappeared, re-read a shipping rule or recover from a changed inventory message. An autonomous shopper needs those conditions expressed as structured capabilities and transaction state.

UCP standardizes that conversation. Shopify describes universal primitives for negotiation and versioning, standardized operations for product discovery, checkout, orders and post-purchase, plus extensions for discounts, fulfillment and other merchant-specific rules. The UCP repository also describes checkout, identity linking, order and payment-token-exchange capabilities.

The useful commercial effect is interoperability. An agent can discover a merchant's current capability profile, negotiate what both sides support and then use a transport appropriate to the environment instead of treating the human storefront as the API contract.

Discovery and negotiation

The agent should learn what the merchant supports before the purchase depends on it

Shopify's UCP walkthrough shows discovery through GET /.well-known/ucp. The profile advertises a protocol version, commerce capabilities and supported payment handlers. The agent can compare that profile with its own capabilities before creating checkout state.

This negotiation model is important because commerce varies by merchant and transaction. Discounts, fulfillment choices, subscriptions, loyalty, legal terms and embedded checkout may exist for one seller and not another. A truthful capability contract lets the agent select a supported route rather than discovering incompatibility after it has already committed state.

Payments

UCP does not prescribe one payment rail

Shopify describes UCP payment handlers as negotiated rather than prescribed: a merchant and agent can select a compatible handler instead of every UCP transaction being forced onto one processor or wallet. That is why UCP should not be described as “the payment protocol” in the same sense as x402. UCP carries commerce semantics and payment-handler negotiation; the underlying authority and settlement layer remains a separate architectural decision.

The public UCP repository explicitly points to advanced security patterns including AP2 mandates and verifiable credentials. This is a useful boundary: commerce state, user authority, agent identity and settlement can be composed while remaining independently auditable.

UCP vs ACP vs AP2 vs MCP vs x402

The protocols sit at different layers of the same agent-commerce stack

Surface	Primary contract	Best-known job	Current steward / ecosystem
UCP	Agent ↔ merchant commerce lifecycle	Discovery, capability negotiation, checkout, orders, post-purchase and negotiated payment handlers	Google + Shopify / open UCP ecosystem
ACP	Agent ↔ merchant commerce contract	Product/feed state, cart, checkout, delegated payment and orders	OpenAI + Stripe
AP2	User authority ↔ payment execution	Cryptographic mandates and delegated payment authorization	Google + payments ecosystem
MCP	Model/runtime ↔ tool contract	Tool discovery, schemas and invocation; can carry UCP interactions	Agent/tool ecosystem
x402	HTTP resource payment	Machine-readable payment challenge, authorization and settlement	Open payment ecosystem

UCP and ACP overlap most directly because both standardize agent-to-merchant commerce state. AP2 is narrower around delegated payment authority. MCP can carry tools or UCP interactions. x402 is narrower again around paying for an HTTP resource. A production system can support several of these without contradiction when each layer has a clear owner and evidence boundary.

Merchant implementation checklist

What makes a UCP-capable storefront useful to an autonomous buyer?

Publish a UCP profile

Expose a truthful machine-readable merchant profile, including the UCP version, capabilities and payment handlers the storefront actually supports.

Keep product truth authoritative

Use stable product and variant identifiers with current price, inventory, fulfillment, policy and eligibility state. A protocol does not fix stale source data.

Negotiate before acting

Let the agent discover capability mismatches before checkout. Unsupported discounts, fulfillment or payment methods should fail early and explicitly.

Make consequential calls idempotent

Cart, checkout and order operations need durable IDs and retry-safe behavior so network retries do not create duplicate purchases.

Separate commerce from authority

A valid checkout request is not unlimited spending permission. Keep user intent, payment authorization and merchant action boundaries independently verifiable.

Return outcome evidence

Expose order, failure and post-purchase state in a form an agent can reconcile instead of forcing it to infer success from page text.

zFinia interpretation

The merchant's machine-readable contract is becoming part of distribution

Traditional ecommerce optimization ended at discoverability and conversion on the human storefront. Agentic commerce adds another selection layer before the click: can the agent understand the merchant, negotiate a compatible transaction and verify the result? UCP turns those questions into protocol surface area. Merchants that keep product truth, capability state and transaction evidence current give autonomous buyers fewer reasons to route elsewhere.

AI shopping discoverability Agentic Commerce Protocol Mastercard Agent Connect Safe agent payments WebMCP zFinia machine-service catalogue