Getting Started with the Universal Commerce Protocol

What is UCP?

The Universal Commerce Protocol (UCP) is an open standard that enables software agents — AI assistants, browser extensions, automated purchasing systems — to discover products, negotiate prices, complete checkout, and manage orders on behalf of users. Think of it as HTTP for commerce: a shared language that any buyer-side agent and any seller-side storefront can speak without bespoke integration work.

Before UCP, every e-commerce platform exposed its own proprietary API (or no API at all). If you wanted to build an AI assistant that could buy things for a user, you needed custom scrapers, per-merchant adapters, and fragile browser automation. UCP replaces that patchwork with a single protocol layer that sits between the agent and the merchant's backend.

Who Created UCP?

UCP emerged from a consortium of major commerce and payments companies who recognized that agentic commerce — transactions initiated by software rather than humans clicking buttons — needed a shared foundation. The founding members include:

• Shopify — contributed the checkout and storefront discovery specifications
• Google — drove the product schema and agent negotiation layers
• Visa and Mastercard — designed the payment token exchange standard
• Stripe and Adyen — built reference payment handler implementations
• Etsy, Wayfair, Target, and Walmart — provided merchant-side validation and real-world testing

The protocol is governed by the UCP Foundation, an independent body that manages the specification, conformance test suite, and certification program. The spec itself is published under the Apache 2.0 license, so anyone can implement it.

Core Concepts

UCP is organized around four capabilities. Not every merchant or agent needs to support all four, but they form the building blocks of a complete commerce interaction.

1. Checkout

Checkout is the most fundamental capability. It defines how an agent presents a cart to a merchant endpoint, receives a total (including tax and shipping), and obtains a payment intent. The flow looks like this:

1. The agent sends a CheckoutSession.create request with line items, a shipping address, and a preferred currency.
2. The merchant responds with a session object containing the calculated total, available shipping options, and a session token.
3. The agent confirms the session, optionally selecting a shipping method, triggering a CheckoutSession.confirm call.
4. The merchant returns a payment intent that the agent forwards to a payment handler.

This three-step handshake — create, review, confirm — ensures the user (or the agent acting on their behalf) always sees the final price before money moves.

2. Identity Linking

Identity linking lets a user associate their merchant accounts with their agent. Instead of the agent needing stored credentials, UCP uses a delegated authorization flow similar to OAuth 2.0. The user grants the agent a scoped token that says "this agent can view my order history and initiate checkouts on my account at merchant X." Merchants never see the user's agent credentials, and the user can revoke access at any time.

3. Order Management

After a purchase completes, UCP provides a standardized way to track order status, request returns, and receive shipping updates. Agents can poll the Order.get endpoint or register a webhook URL to receive push notifications when an order ships, is delivered, or encounters an exception.

4. Payment Token Exchange

Payment token exchange is the layer between checkout and the actual movement of money. When a checkout session is confirmed, the merchant issues a payment token — a short-lived, single-use credential that encodes the amount, currency, and merchant identity. The agent passes this token to a UCP-compatible payment handler (Stripe, Adyen, Visa Direct, etc.), which processes the charge and returns a settlement confirmation. The merchant never touches raw card numbers, and the agent never handles payment credentials directly.

How UCP Differs from Traditional E-Commerce

In traditional e-commerce, the browser is the universal client. Merchants build HTML pages, and users interact through forms and buttons. APIs exist, but they are merchant-specific and designed for the merchant's own mobile app, not for third-party agents.

UCP flips this model. The protocol assumes the client is a program, not a person. There are no HTML pages to render — just structured JSON payloads. Product discovery uses machine-readable schemas rather than search-engine-optimized web pages. Authentication is token-based rather than cookie-based. Error handling returns structured error codes rather than human-readable error pages.

This makes UCP complementary to existing web storefronts. Merchants don't replace their websites — they add a UCP endpoint alongside them. Shopify stores, for example, can enable UCP through a single toggle in their admin panel, and Shopify handles the protocol translation behind the scenes.

Getting Started

The fastest way to explore UCP is to:

1. Read the spec. The full protocol specification is published at the UCP Foundation's website. Start with the Checkout capability — it's the most mature and the most commonly implemented.
2. Install the schema models. The official JavaScript package is @ucp-js/sdk. It provides generated TypeScript types and Zod schemas for UCP payloads; it is not a network client.
3. Run the conformance tests. Clone the official UCP conformance repository and follow its uv and pytest instructions for your merchant server.
4. Browse the directory. UCPList.ai (this site) catalogs every known UCP-compatible merchant, platform, payment handler, and developer tool. Use it to find integration partners and see who supports which capabilities.

UCP is still early — the ecosystem is growing week by week. But the protocol is stable, the tooling is solid, and the major platforms are already onboard. Now is the time to build.