The Universal Commerce Protocol (UCP) is an open standard that enables AI agents to discover, interact with, and transact at online stores programmatically. Instead of scraping websites or navigating checkout flows built for humans, agents read a structured manifest that declares exactly what a store supports — its capabilities, tools, transports, and payment methods.

Every UCP-enabled store publishes a JSON profile at /.well-known/ucp. This profile is the entry point for all agent interactions. It tells the agent: here's what I can do, here's how to talk to me, and here's how to pay me.

UCP Checker monitors 18,759 verified stores and tracks protocol adoption across the ecosystem. This page explains the key building blocks of the protocol.

When an agent wants to shop at a store, it fetches the store's business profile — a JSON document at https://{domain}/.well-known/ucp. The profile declares:

• Spec version — which version of the UCP protocol this store implements
• Services — API surfaces the store exposes (e.g. shopping), each with a transport and endpoint
• Capabilities — features the store supports (checkout, fulfillment, discounts, etc.)
• Payment handlers — accepted payment methods and their configuration
• Signing keys — JWK public keys for webhook signature verification

The agent and store then negotiate — computing the intersection of what both sides support, pruning orphaned extensions, and settling on a set of active capabilities for the session.

Namespaces follow reverse-domain convention: dev.ucp.* for official spec capabilities, com.{vendor}.* for vendor extensions. This prevents collisions and lets the ecosystem grow organically.

Capabilities are the core features a store advertises. They define what a store can do — like processing checkouts, tracking orders, applying discounts, or handling fulfillment. Each capability has a version, specification URL, and schema that defines its contract.

Capabilities can extend other capabilities. For example, dev.ucp.shopping.discount extends dev.ucp.shopping.checkout, adding coupon and promotion logic on top of the base checkout flow. Extensions use JSON Schema allOf composition so schemas remain modular.

Tools are the specific operations an agent can invoke on a store. They're discovered via MCP's tools/list method and define the input schema, description, and behaviour for each action — like searching a catalog, reading a cart, or updating line items.

A single capability may be served by multiple tools. For example, the checkout capability might expose get_cart, update_cart, and get_product_details as separate tool calls. Tools are the agent-facing API surface that maps to the higher-level capability contracts.

Transports define how an agent communicates with a store. UCP supports four transport protocols, and stores can offer multiple simultaneously:

Payment handlers define how an agent pays for goods. UCP uses a trust triangle between the business (merchant), platform (agent host), and credential provider (e.g. Google Pay, Shopify Payments).

The payment lifecycle has three steps:

1. Negotiation — the store advertises which payment handlers it accepts, filtered dynamically by cart context
2. Acquisition — the platform obtains a payment token from the credential provider
3. Completion — the platform submits the opaque credential to the store to finalize the transaction

Credentials flow in one direction only (platform to business), preventing key confusion attacks. Each handler carries a handler_id to disambiguate when multiple providers are available. This architecture keeps platforms out of PCI-DSS scope by using opaque, tokenized credentials.

For autonomous agent commerce, the AP2 (Agent Payments Protocol) extension adds cryptographic non-repudiable authorization — letting agents commit to purchases without human-in-the-loop confirmation.

UCP uses date-based versioning in YYYY-MM-DD format. The protocol itself, individual capabilities, and extensions can all version independently — so a store can run the latest checkout capability while staying on an older protocol version.

Changes are classified as either backwards-compatible or breaking:

• Backwards-compatible: adding optional fields, new endpoints, new error codes, new enum values
• Breaking: removing or renaming fields, changing types, making optional fields required, removing operations

Stores declare a primary version and can optionally list supported_versions for backwards compatibility. Official dev.ucp.* capabilities version with the protocol by default, while vendor capabilities (com.{vendor}.*) version independently.

View all 7 spec versions currently in use across verified stores.

All UCP communication happens over HTTPS with no redirects allowed for profile hosting. The security model covers three layers:

• Platform → Business: authenticated via Authorization: Bearer <token> headers
• Business → Platform (webhooks): signed using HTTP Message Signatures (RFC 9421) with JWK public keys declared in the store profile
• Payment data: tokenized credentials keep platforms out of PCI-DSS scope; all PII handling follows GDPR requirements

UCP Checker continuously crawls the /.well-known/ucp endpoint of 18,759 stores to track protocol adoption across the agentic commerce ecosystem. We extract and index every capability, tool, transport, payment handler, and spec version declared in each manifest.

Use our protocol pages to explore adoption data:

• Capabilities — which commerce features stores actually support
• Vendors & Extensions — who governs each capability, and which are authority-bound
• MCP Tools — what MCP operations agents can invoke
• Transports — how stores expose their APIs
• Payment Handlers — which payment methods are accepted
• Spec Versions — which protocol versions are in use
• Verticals — UCP across retail, lodging, travel & food

For individual store status, visit the Merchant Directory or check any domain at /check. See runtime performance on the Leaderboard, or explore the full Developer Tools stack. Validate your manifest JSON with the UCP Validator, audit live catalog.search and catalog.lookup responses with the Catalog Validator, or compare UCP tools side by side. Our methodology page explains the full validation process including both static analysis and live runtime agent simulations.