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

> Discover the four transport bindings supported by Universal Commerce Protocol UCP REST MCP A2A and Embedded Understand how platforms communicate with UCP services.

- Repository: [Universal Commerce Protocol (UCP)/ucp](https://github.com/Universal-Commerce-Protocol/ucp)
- Tags: api-reference
- Published: 2026-04-26

---

**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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main//.well-known/agent-card.json) endpoint (specified in [`docs/specification/checkout-a2a.md`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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:

```json
{
  "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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/source/services/shopping/rest.openapi.json).

```python
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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/source/services/shopping/mcp.openrpc.json) defines the available JSON-RPC methods.

```python
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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/docs/specification/checkout-a2a.md).

```python
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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/source/services/shopping/embedded.openrpc.json).

```javascript
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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main//.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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/source/services/shopping/rest.openapi.json) in the repository. Similarly, the MCP interface is defined in [`source/services/shopping/mcp.openrpc.json`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/source/services/shopping/mcp.openrpc.json), and the Embedded protocol is specified in [`source/services/shopping/embedded.openrpc.json`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/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`](https://github.com/Universal-Commerce-Protocol/ucp/blob/main/docs/specification/embedded-protocol.md).