Universal Commerce Protocol (UCP): Google’s Open Standard

The Universal Commerce Protocol (UCP) is an open-source standard designed to create a common language for agentic commerce — enabling AI agents, merchants, consumer platforms, and payment providers to communicate and transact without requiring custom integrations for every connection.

Launched on January 11, 2026, UCP was developed by Google in collaboration with Shopify, Etsy, Wayfair, Target, and Walmart, and has been endorsed by more than 20 additional global organizations across retail and payments. It is the foundational infrastructure layer for a new era of commerce in which AI agents can discover products, negotiate checkout terms, and complete purchases on behalf of consumers.

This guide covers what UCP is, how it works, what it does today, who built it, and why it matters for merchants and the broader commerce ecosystem. Every fact stated here is sourced directly from official UCP documentation and primary announcements. External links open in a new tab so you can verify every claim for yourself.

What Problem Does UCP Solve?

Before UCP, every retailer, AI platform, and payment provider that wanted to work together had to build a custom technical integration. One platform might structure product data one way; another might handle checkout differently; a third might track order status in its own proprietary format. When those systems tried to connect, engineers had to build a custom bridge for every pair — slow, expensive, and difficult to maintain at scale.

As AI-powered shopping surfaces proliferate — from Google AI Mode in Search to conversational commerce experiences inside Gemini — the number of potential integration pairs explodes. Without a shared standard, the commerce ecosystem fragments. Every AI platform would need bespoke connections to every merchant, and vice versa.

UCP solves this by establishing a single, shared protocol. As stated on the official UCP website, the protocol creates “the common language for platforms, agents and businesses,” allowing all participants to interoperate through one standard without custom builds.

Who Built UCP?

UCP was co-developed by Google and Shopify alongside three additional retail co-developers: Etsy, Wayfair, Target, and Walmart. These organizations did not simply endorse the standard — they participated in building it, contributing real-world commerce complexity from billions of transactions and millions of merchants.

As Ilya Grigorik, Distinguished Engineer at Shopify, wrote in the Shopify Engineering announcement: “Commerce is humanity’s longest-running trade. Universal, but not uniform. We’ve spent 20+ years at Shopify learning just how complex it is — billions of transactions, millions of merchants — and it continues to humble us.”

The protocol has been endorsed by more than 20 additional organizations. The full list of endorsers confirmed at launch, as published by Google’s official blog and on the UCP website, includes:

• Adyen
• Affirm
• American Express
• Ant International
• Best Buy
• Block
• Carrefour
• Checkout.com
• Chewy
• Fiserv
• Flipkart
• Gap
• Klarna
• Kroger
• Lowe’s
• Macy’s Inc.
• Mastercard
• PayPal
• Salesforce
• Sephora
• Shopee
• Splitit
• Stripe
• The Home Depot
• Ulta Beauty
• Visa
• Worldpay
• Zalando

This breadth of participation — spanning global retailers, payment networks, buy-now-pay-later providers, and marketplace platforms — is significant. It reflects deliberate co-design by stakeholders with competing interests, ensuring UCP accommodates the real diversity of commerce rather than a simplified, single-vendor model.

What Are UCP’s Three Core Capabilities?

At launch, UCP’s protocol focuses on three core capabilities: Checkout, Identity Linking, and Order Management. These represent the three foundational phases of a complete commerce transaction.

1. Checkout

UCP’s Checkout capability enables AI agents to support complex cart logic, dynamic pricing, tax calculations, and fulfillment options across millions of businesses through unified checkout sessions. A checkout session in UCP tracks the full state of a transaction — line items, buyer information, totals, payment method, and fulfillment selection — in a structured, standardized format.

UCP defines a checkout state machine with three key statuses:

• incomplete — required information is missing; the agent attempts to resolve via API
• requires_escalation — buyer input is required; the agent attempts API resolution and, if unable, hands off to the buyer via a continuation URL
• ready_for_complete — all required information has been collected; the agent can finalize the transaction programmatically

This state machine ensures that no transaction is ever left behind. When an agent hits a capability it cannot handle autonomously, the protocol routes around it by handing control back to the buyer — who picks up exactly where the agent left off. Source: Shopify Engineering, Building the Universal Commerce Protocol.

UCP also supports two checkout integration paths. Native checkout integrates checkout logic directly with the AI surface. Embedded checkout allows merchants with complex checkout flows — custom UI, specific regulatory requirements, specialized merchant policies — to embed their own checkout experience within the agent surface, with bi-directional messaging between agent and merchant. Source: Google UCP Developer Guide.

2. Identity Linking

Identity Linking allows AI agents to maintain secure, authorized relationships with merchants without sharing user credentials. UCP uses the OAuth 2.0 standard for this capability, enabling account-linked checkout experiences where a buyer’s loyalty program membership, saved shipping addresses, and personalized pricing can be accessed and applied within the agent-mediated transaction.

Merchants publish an OAuth authorization server configuration at a standardized endpoint (/.well-known/oauth-authorization-server), which agents can discover and use to establish secure account links on behalf of buyers. Source: ucp.dev.

3. Order Management

The Order Management capability covers everything from purchase confirmation through delivery. UCP uses real-time webhooks to power order status updates, shipment tracking information, and return and refund processing across every channel where the transaction may have originated. An order object in UCP references the originating checkout session and tracks line items, fulfillment expectations, fulfillment events (including delivery confirmation and tracking numbers), and any adjustments such as refunds. Source: ucp.dev.

How Does UCP’s Architecture Work?

UCP is built on a deliberately layered architecture designed for long-term evolution without breaking compatibility. As explained in the Shopify Engineering post, the design draws directly from how TCP/IP separates network layers — applying that proven pattern to commerce.

The architecture has three layers:

• Shopping Service — the core layer, defining transaction primitives: checkout session, line items, totals, messages, and status. This layer is stable and versioned independently.
• Capabilities — major functional areas (Checkout, Orders, Catalog) that sit on top of the core service, each independently versioned so one capability can evolve without disrupting others.
• Extensions — domain-specific schemas that augment capabilities using composition. Extensions allow merchants to add specialized functionality — fulfillment windows, loyalty point redemption, subscription billing schedules — without modifying the core spec.

This structure means merchants implement only what they need. Agents negotiate only what they can handle. The protocol can evolve without breaking existing integrations.

Merchant Profiles and Capability Negotiation

Both merchants and agents publish profiles declaring what capabilities they support. A merchant publishes its profile at a standardized endpoint: /.well-known/ucp on the merchant’s domain. An agent also declares its capabilities in its own profile.

When an agent initiates a request, it passes its profile URL. The merchant computes the intersection — which capabilities both support, which payment handlers overlap, which extensions are mutually understood — and responds with the negotiated result. This negotiation happens dynamically for every transaction. Change the cart contents, buyer location, or transaction amount, and the available handlers may shift accordingly.

As Shopify Engineering notes, this process mirrors how HTTP already performs negotiation on every request through accept headers, content types, and encodings. UCP applies the same proven pattern to commerce capabilities.

Transport Bindings

UCP supports multiple transport bindings, giving merchants and platforms flexibility in how they integrate:

• REST API — the primary transport, using standard HTTP
• Model Context Protocol (MCP) — for AI agent integrations via MCP-compatible frameworks. See also: Gemini Live API & UCP for real-time voice commerce. Learn more at modelcontextprotocol.io
• Agent2Agent (A2A) — for agent-to-agent communication. Learn more at a2a-protocol.org

UCP is also compatible with the Agent Payments Protocol (AP2) for secure payment execution. Learn more at ap2-protocol.org. Source: ucp.dev.

What UCP Is Not

Several misconceptions about UCP have circulated since its launch. To maintain accuracy:

• UCP is not a Merchant Center update. It is a separate open protocol with its own specification, GitHub repository, and governance. Merchant Center is one integration path for merchants using Google’s surfaces, but UCP itself is vendor-agnostic and designed to work across any AI platform.
• UCP is not owned by Google. It is an open-source standard. The specification is published under the Apache License, Version 2.0. The full repository is publicly available at github.com/Universal-Commerce-Protocol/ucp.
• UCP does not replace your existing checkout. Merchants remain the Merchant of Record for all transactions. UCP preserves existing business rules, customer relationships, and data. As Google states in its developer documentation: “You remain the Merchant of Record. Keep all of your customer data and relationships.”
• UCP does not require merchants to abandon their payment providers. UCP’s payment handler design is open and modular. Merchants advertise which payment handlers they accept; agents pick compatible ones. New payment methods can be added without modifying the core protocol.

Security and Privacy in UCP

UCP is built on established security standards. Account linking uses OAuth 2.0. Payment security uses AP2, which relies on payment mandates and verifiable credentials. Every authorization is backed by cryptographic proof of user consent. Merchants retain full ownership of their customer relationships and transaction data.

As Google’s official documentation confirms: “No. You remain the Merchant of Record for all transactions. You retain full ownership of your customer relationships, data, and the post-purchase experience.” Source: Google UCP FAQ.

How to Get Started with UCP

UCP is currently in early access for merchants integrating with Google’s AI surfaces. The complete technical specification, documentation, and reference implementations are publicly available:

• ucp.dev — the official UCP documentation site
• GitHub: Universal-Commerce-Protocol/ucp — the open-source specification and SDKs
• Google UCP Developer Guide — implementation guidance for merchants integrating with Google’s AI surfaces
• Google UCP Waitlist — join the waitlist to participate in early access

Primary Sources for This Article

Every factual claim in this article is drawn directly from the following primary sources. We encourage you to read each one:

• Universal Commerce Protocol official documentation (ucp.dev)
• Google UCP Developer Guide (developers.google.com)
• Google Blog: New tech and tools for retailers to succeed in an agentic shopping era (January 11, 2026)
• Shopify Engineering: Building the Universal Commerce Protocol (January 11, 2026)
• Google Developers Blog: Under the Hood — Universal Commerce Protocol (January 11, 2026)