What Transport Bindings Are Supported by Universal Commerce Protocol (UCP)?

UCP supports four concrete transport bindings—REST, MCP (Message-Channel Protocol), A2A (Agent-to-Agent), and Embedded—which businesses advertise in their /.well-known/ucp profile to declare how platforms should communicate with their services.

The Universal Commerce Protocol (UCP) is architecturally transport-agnostic, allowing merchants to select integration patterns ranging from traditional HTTP APIs to in-process widgets. According to the Universal-Commerce-Protocol/ucp source code, these four bindings are formally defined in docs/specification/overview.md and implemented via specific schema files that dictate message serialization and endpoint behavior. Each binding targets a distinct deployment scenario, from stateless web services to real-time AI agent collaboration.

The Four UCP Transport Bindings

While UCP decouples business logic from transport concerns, it standardizes four specific implementations that platforms can rely on when consuming services.

REST Binding

The REST binding provides classic request/response semantics over HTTPS using an OpenAPI-defined API. Defined in docs/specification/overview.md under the "transport": "rest" declaration, this binding is suitable for web services and mobile back-ends that require stateless, cache-friendly operations. The request and response schemas are formally specified in source/services/shopping/rest.openapi.json.

MCP (Message-Channel Protocol)

MCP is a JSON-RPC 2.0 protocol delivered over streamable HTTP—a single long-lived connection that enables real-time bidirectional messaging. As documented in docs/specification/overview.md with "transport": "mcp", it utilizes the same RFC 9421 signature scheme as REST while supporting continuous data streams like inventory updates or chat-style interactions. The interface definition resides in source/services/shopping/mcp.openrpc.json.

A2A (Agent-to-Agent)

The A2A binding facilitates AI-agent collaboration through a lightweight pull-based discovery mechanism. Platforms retrieve a JSON agent-card from the business's /.well-known/agent-card.json endpoint (specified in docs/specification/checkout-a2a.md), which contains RPC endpoint metadata and method signatures. This binding uses "transport": "a2a" in the profile and allows autonomous agents to communicate without traditional server endpoints.

Embedded Protocol (EP)

Embedded (EP) is a host-side, in-process transport designed for zero-latency UI integration. Detailed in docs/specification/embedded-protocol.md, this binding lets merchants embed UCP capabilities—such as checkout widgets—directly inside their applications. It reuses the JSON-RPC messaging model but executes within the same process, eliminating network hops entirely. Its schema is defined in source/services/shopping/embedded.openrpc.json.

Configuring Transport Bindings in the UCP Profile

Businesses declare supported transports in their /.well-known/ucp profile using the services array. Each service entry includes a transport field identifying one of the four bindings, plus either an endpoint URL (for REST, MCP, and A2A) or a schema reference (for Embedded).

The following profile advertises all four transport types simultaneously:

{
  "ucp": {
    "version": "1.0",
    "services": {
      "dev.ucp.shopping": [
        {
          "transport": "rest",
          "endpoint": "https://business.example.com/ucp/v1",
          "schema": "https://ucp.dev/1.0/services/shopping/rest.openapi.json"
        },
        {
          "transport": "mcp",
          "endpoint": "https://business.example.com/ucp/mcp",
          "schema": "https://ucp.dev/1.0/services/shopping/mcp.openrpc.json"
        },
        {
          "transport": "a2a",
          "endpoint": "https://business.example.com/.well-known/agent-card.json"
        },
        {
          "transport": "embedded",
          "schema": "https://ucp.dev/1.0/services/shopping/embedded.openrpc.json"
        }
      ]
    }
  }
}

Source structure derived from the specification example in docs/specification/overview.md.

Implementation Examples by Transport

REST API Calls

The REST binding uses standard HTTPS with JSON payloads. The endpoint and data shapes are defined in source/services/shopping/rest.openapi.json.

import requests

checkout_url = "https://business.example.com/ucp/v1/checkout"
payload = {
    "order_id": "ORD-12345",
    "payment_method": {"type": "card", "token": "tok_abc123"},
    "buyer": {"email": "alice@example.com"}
}
response = requests.post(checkout_url, json=payload, timeout=5)
print(response.json())

MCP Streamable HTTP

MCP requires streaming HTTP clients to handle the long-lived connection. The schema in source/services/shopping/mcp.openrpc.json defines the available JSON-RPC methods.

import json, httpx

mcp_url = "https://business.example.com/ucp/mcp"
headers = {"Content-Type": "application/json"}

rpc = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "checkout",
    "params": {
        "order_id": "ORD-12345",
        "payment_method": {"type": "card", "token": "tok_abc123"}
    }
}
with httpx.stream("POST", mcp_url, json=rpc, headers=headers) as stream:
    for line in stream.iter_lines():
        print(json.loads(line))

A2A Agent Discovery

First retrieve the agent-card, then invoke methods against the disclosed RPC endpoint as specified in docs/specification/checkout-a2a.md.

import requests

card_url = "https://business.example.com/.well-known/agent-card.json"
card = requests.get(card_url).json()
rpc_endpoint = card["rpc_endpoint"]

payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "checkout",
    "params": {"order_id": "ORD-12345"}
}
resp = requests.post(rpc_endpoint, json=payload)
print(resp.json())

Embedded In-Process Integration

The Embedded binding eliminates HTTP entirely, using a host-side client library with the schema from source/services/shopping/embedded.openrpc.json.

import { createUcpClient } from "@ucp/embedded";

const client = createUcpClient({
  schema: "https://ucp.dev/1.0/services/shopping/embedded.openrpc.json"
});

client.request("checkout", {
  order_id: "ORD-12345",
  payment_method: { type: "card", token: "tok_abc123" }
}).then(console.log);

Summary

• REST provides stateless, firewall-friendly HTTPS APIs defined by OpenAPI specifications in source/services/shopping/rest.openapi.json.
• MCP enables real-time bidirectional streaming over HTTP using JSON-RPC 2.0 and RFC 9421 signatures, ideal for live updates.
• A2A supports agent-centric discovery via /.well-known/agent-card.json, allowing autonomous AI agents to negotiate communication channels.
• Embedded delivers zero-latency, in-process integration for UI widgets by running JSON-RPC messages inside the host application process.

Frequently Asked Questions

Is UCP limited to HTTP-based transports?

No. While REST, MCP, and A2A utilize HTTP for network communication, the Embedded binding operates entirely in-process without network calls. The protocol is transport-agnostic by design, allowing the core messaging model to run across any underlying transport a business chooses to implement.

How does MCP differ from standard REST?

MCP uses JSON-RPC 2.0 over streamable HTTP—maintaining a single long-lived connection for real-time bidirectional messaging—whereas REST uses classic request/response cycles. Both bindings share the same RFC 9421 signature scheme for authentication, but MCP is optimized for streaming scenarios like inventory updates or chat-based commerce.

What file defines the OpenAPI schema for REST bindings?

The REST OpenAPI definition is located at source/services/shopping/rest.openapi.json in the repository. Similarly, the MCP interface is defined in source/services/shopping/mcp.openrpc.json, and the Embedded protocol is specified in source/services/shopping/embedded.openrpc.json.

When should businesses use the Embedded transport?

Use the Embedded transport when a merchant needs to embed UCP capabilities—such as a checkout widget—directly inside their own UI to eliminate network latency and external dependencies. It runs JSON-RPC messages in-process via a host-side client, as detailed in docs/specification/embedded-protocol.md.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}