Post

Universal Commerce Protocol (UCP)

UCP is Google's open standard for agentic commerce, covering the full lifecycle from product discovery and comparison through checkout and post-purchase. Backed by a coalition of 20+ partners including Shopify, Walmart, Target, Visa, Mastercard, and Stripe.

Posted
By
7 min read
Universal Commerce Protocol (UCP)

UCP is Google’s open standard for agentic commerce, covering the full lifecycle from product discovery and comparison through checkout and post-purchase. Announced January 11, 2026 at NRF by Sundar Pichai, it is backed by a coalition of 20+ partners including Shopify, Walmart, Target, Visa, Mastercard, and Stripe.

What is it?

UCP defines the building blocks for agent-driven commerce interactions. Where ACP (OpenAI/Stripe) focuses primarily on checkout, UCP is broader in scope – it standardizes the entire commerce journey: discovering products, comparing options, building carts, checking out, tracking orders, handling returns, and managing loyalty programs.

The protocol is designed to be the common language between AI agents (Google’s Gemini, third-party agents), merchant backends, and payment providers. The spec is published at ucp.dev and the code lives on GitHub as an open standard.

UCP is not payment-specific. It delegates payment authorization and settlement to the Agent Payments Protocol (AP2), which handles the financial layer. Think of UCP as the commerce orchestration protocol and AP2 as the payment execution protocol.

Problem it solves

The agentic commerce space was fragmenting before it even matured. By January 2026:

  • OpenAI/Stripe had ACP for ChatGPT checkout.
  • Google had its own shopping infrastructure but no open protocol.
  • Every major retailer was building one-off integrations with each AI platform.

UCP addresses this by providing a single protocol that covers the full purchase lifecycle, not just the checkout step. A merchant implementing UCP can serve any UCP-compatible agent across discovery, comparison, checkout, fulfillment tracking, and post-purchase support.

The specific gaps UCP fills beyond what ACP covers:

  1. Product comparison – Structured schemas for agents to compare products across merchants (price, reviews, availability, shipping speed) before initiating checkout.
  2. Post-purchase orchestration – Order tracking, return initiation, exchange flows, and loyalty point accrual – all standardized.
  3. Multi-provider checkout – A single cart can span multiple merchants with UCP coordinating the split.
  4. Payment-agnostic – UCP does not mandate a specific payment processor. It delegates to AP2, which supports cards, bank transfers, and stablecoins.

Architecture / How it works

Protocol stack

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

┌──────────────────────────────────────────────────┐
│           Consumer Surface                        │
│  (Google Search AI Mode, Gemini, third-party)    │
└──────────────────────┬───────────────────────────┘
                       │
         ┌─────────────┴─────────────┐
         │    UCP Protocol Layer      │
         │  (Commerce orchestration)  │
         │                            │
         │  - Discovery & comparison  │
         │  - Cart management         │
         │  - Checkout sessions       │
         │  - Post-purchase flows     │
         └──────┬──────────┬─────────┘
                │          │
    ┌───────────┴──┐  ┌───┴────────────┐
    │   AP2 Layer  │  │  Merchant APIs  │
    │  (Payments)  │  │  (Fulfillment)  │
    └──────────────┘  └────────────────┘

Transport options

UCP supports multiple transports, making it flexible for different integration patterns:

  • REST – Standard HTTP endpoints, similar to ACP.
  • JSON-RPC – For more structured request/response patterns.
  • MCP – Native Model Context Protocol support, so MCP servers can expose UCP capabilities as tools.
  • A2A – Google’s Agent-to-Agent protocol support for agent-to-agent commerce scenarios (e.g., a buyer agent negotiating with a merchant agent).

Well-known endpoint

Merchants expose a /.well-known/ucp endpoint that declares their UCP capabilities, supported API versions, available product categories, and payment methods. This is similar to how robots.txt works but for agent commerce.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// GET https://merchant.com/.well-known/ucp
{
  "ucp_version": "1.0",
  "capabilities": {
    "discovery": true,
    "comparison": true,
    "checkout": true,
    "fulfillment_tracking": true,
    "returns": true
  },
  "payment_protocols": ["ap2"],
  "transports": ["rest", "mcp"],
  "product_feed_url": "https://merchant.com/ucp/feeds/products"
}

Key concepts

Commerce lifecycle stages

UCP breaks the commerce journey into discrete, standardized stages:

  1. Discovery – Agent queries merchant catalogs using structured search. Supports filtering by price, category, availability, shipping location.
  2. Comparison – Agents can request standardized comparison data across multiple merchants simultaneously. UCP defines the schema for comparable attributes.
  3. Cart & Checkout – Session-based cart management. Supports multi-merchant carts. Checkout delegates payment to AP2.
  4. Fulfillment – Standardized order status updates, shipping tracking, and delivery confirmation.
  5. Post-purchase – Returns, exchanges, refund status, warranty claims, and loyalty program interactions.

Coalition backing

UCP was developed with and endorsed by a broad coalition:

  • Retailers: Shopify, Etsy, Wayfair, Target, Walmart, Best Buy, Flipkart, Macy’s, The Home Depot, Zalando
  • Payment providers: Visa, Mastercard, American Express, Stripe, Adyen
  • Platforms: Google

This is notably broader than ACP’s initial OpenAI + Stripe pairing. The inclusion of Visa, Mastercard, and Amex signals that UCP is designed to be payment-processor-agnostic.

Relationship to AP2

UCP handles what to buy and how to orchestrate the purchase. AP2 handles how to pay. They are designed as complementary layers:

  • UCP manages the commerce session, cart, and merchant interactions.
  • When it is time to pay, UCP hands off to AP2 for payment authorization, credential exchange, and settlement.
  • AP2 can also be used independently of UCP (e.g., for agent-to-agent payments that are not commerce-related).

Code / Integration example

A merchant implementing UCP product discovery:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# Merchant-side UCP discovery endpoint
@app.get("/ucp/v1/products/search")
async def search_products(
    query: str,
    category: str = None,
    price_min: float = None,
    price_max: float = None,
    in_stock: bool = True,
    ship_to: str = "US",
):
    products = await catalog.search(
        query=query,
        filters={
            "category": category,
            "price_range": (price_min, price_max),
            "availability": in_stock,
            "shipping_region": ship_to,
        }
    )
    return UCPProductResponse(
        results=[UCPProduct(
            id=p.id,
            title=p.title,
            price=UCPMoney(amount=p.price, currency="USD"),
            comparison_attributes=p.structured_attrs,
            availability=p.stock_status,
            merchant=UCPMerchant(id="merchant-123", name="Example Store"),
        ) for p in products],
        total_results=len(products),
    )

Well-known endpoint setup

1
2
3
4
5
6
7
8
9
10
11
12
13

// .well-known/ucp hosted at merchant root
{
  "ucp_version": "1.0",
  "merchant_id": "merchant-123",
  "endpoints": {
    "discovery": "/ucp/v1/products",
    "checkout": "/ucp/v1/checkout",
    "fulfillment": "/ucp/v1/orders",
    "returns": "/ucp/v1/returns"
  },
  "payment_protocols": ["ap2"],
  "supported_regions": ["US", "EU"]
}
Dimension UCP (Google) ACP (OpenAI + Stripe)
Scope Full commerce lifecycle Checkout-focused
Payment layer Delegates to AP2 (payment-agnostic) Built-in via Stripe SPTs
Transport REST, JSON-RPC, MCP, A2A REST, MCP
Post-purchase Returns, tracking, loyalty – standardized Not in spec
Multi-merchant cart Supported Single merchant per session
First deployment Google Search AI Mode, Gemini (early access) ChatGPT Instant Checkout (production)
Governance Google-led coalition OpenAI + Stripe
Maturity Early access (Mar 2026) Production (Sep 2025)

The dual-protocol reality

The market is not choosing one protocol over the other. Early 2026 data shows:

  • Merchants implementing both UCP and ACP capture approximately 40% more agentic traffic than single-protocol stores.
  • Walmart already supports ChatGPT (ACP ecosystem) and Gemini (UCP ecosystem).
  • Shopify made stores agent-ready by default across both protocols. Shopify reported 7x growth in AI traffic and 11x growth in AI-driven orders since January 2025.
  • Most large retailers are implementing both, treating them like supporting both iOS and Android.

The practical recommendation for enterprise merchants: implement both. The incremental cost of the second protocol is low once you have structured product feeds and a standardized checkout backend.

Current adoption / Maturity

  • Spec status: Published at ucp.dev, GitHub repository open. Spec is live but still evolving.
  • Google surfaces: UCP checkout on Google Search AI Mode and Gemini is in early access, limited to select US merchants and participating partners as of March 2026.
  • Retailer adoption: Major US retailers (Walmart, Target, Best Buy, Home Depot, Macy’s) are in various stages of implementation. Shopify provides UCP support out of the box.
  • International: Zalando and Flipkart signal non-US expansion is planned.
  • Limitations: Earlier stage than ACP. No production consumer-facing deployment yet (early access only). The spec is still adding features. Payment flow depends on AP2, which is itself pre-production.
  • Specification: https://ucp.dev/
  • Google developer docs: https://developers.google.com/merchant/ucp/
  • Google Developers Blog deep dive: https://developers.googleblog.com/under-the-hood-universal-commerce-protocol-ucp/
  • Shopify UCP engineering post: https://shopify.engineering/UCP

References

AI & Agents, Protocols
agent-patterns
This post is licensed under CC BY 4.0 by the author.