• A language runtime with an MCP client library. Official MCP SDKs exist for Python, TypeScript and several other languages. Any language works — MCP is JSON-RPC, ~100 lines to roll your own.
• An HTTP client (curl, requests, fetch, whatever). You'll use it to fetch the store's profile before MCP takes over.
• A platform profile URL. UCP requires every request to name your platform's profile (a JSON document you host, same shape as a store's /.well-known/ucp). The store fetches it to agree a protocol version and capabilities with you. See Platform Profile in the spec.
• A test store from the UCP directory. We list 6 ready-to-use targets below — all verified, all with deep capability declarations, across platforms.
• Optional: any LLM with tool calling if you want the agent to pick which tools to call. You can also hard-code the flow for deterministic testing.

houseofparfum.nl

6 capabilities · Woocommerce

devucp.netsgroup.com

6 capabilities · Custom

singon.com.np

6 capabilities · Odoo

jrqxx1a5.finqustore.dev

6 capabilities · Custom

shop.konmari.com

5 capabilities · Shopify

jenniferslattery.com

5 capabilities · Shopify

Tip: Start with a store whose profile declares dev.ucp.shopping.catalog.search and an mcp transport — catalog reads are the easiest first call. Open a store's status page to see exactly what it declares, or browse the full directory to pick your own target.

# curl
curl https://store.example/.well-known/ucp | jq .ucp.services

# Python
import httpx
STORE = "https://store.example"  # any store from the directory
profile = httpx.get(f"{STORE}/.well-known/ucp").json()
print(profile["ucp"]["version"])
print("capabilities:", list(profile["ucp"].get("capabilities", {}).keys()))

// TypeScript
const STORE = "https://store.example"; // any store from the directory
const profile = await (await fetch(`${STORE}/.well-known/ucp`)).json();
console.log(profile.ucp.version);
console.log("capabilities:", Object.keys(profile.ucp.capabilities ?? {}));

You want two things from the profile: the services map (to find the MCP endpoint URL) and the capabilities map (to know what you can call, keyed by names like dev.ucp.shopping.catalog.search). See the full field reference on the /.well-known/ucp developer guide.

# Python — find the MCP endpoint from a parsed profile
def find_mcp_endpoint(profile):
    for entry in profile["ucp"].get("services", {}).get("dev.ucp.shopping", []):
        if entry.get("transport") == "mcp":
            return entry["endpoint"]
    raise ValueError("No MCP transport declared for dev.ucp.shopping")

endpoint = find_mcp_endpoint(profile)
print(f"MCP endpoint: {endpoint}")

Heads up: use the endpoint the profile declares — the spec says the endpoint MUST come from the store's profile, not from a guessed path. If a store declares no mcp transport, check its REST entry or pick another store.

# Python — minimal MCP client, no SDK
import httpx

def mcp_call(endpoint, method, params=None):
    res = httpx.post(endpoint, json={
        "jsonrpc": "2.0",
        "id": 1,
        "method": method,
        "params": params or {},
    }, headers={
        "Content-Type": "application/json",
        "Accept": "application/json, text/event-stream",
    })
    return res.json()

mcp_call(endpoint, "initialize", {
    "protocolVersion": "2025-06-18",
    "capabilities": {},
    "clientInfo": {"name": "my-agent", "version": "0.1"},
})
tools = mcp_call(endpoint, "tools/list")["result"]["tools"]
for tool in tools:
    print(f"- {tool['name']}: {tool['description'][:80]}")

The UCP tool names are fixed by the spec: search_catalog, lookup_catalog and get_product for catalog; create_cart, get_cart, update_cart, cancel_cart for cart; create_checkout, get_checkout, update_checkout, complete_checkout, cancel_checkout for checkout; and get_order. A store exposes the ones for the capabilities it declares. If tools/list returns an empty array or an error, the store declares MCP but hasn't wired it up — validate the store to confirm.

# Python — search the catalog
PLATFORM_PROFILE = "https://agent.example/.well-known/ucp"  # your platform profile

result = mcp_call(endpoint, "tools/call", {
    "name": "search_catalog",
    "arguments": {
        "meta": {
            "ucp-agent": {"profile": PLATFORM_PROFILE},
        },
        "catalog": {
            "query": "running shoes",
            "context": {
                "address_country": "US",
                "currency": "USD",
                "language": "en",
            },
            "pagination": {"limit": 10},
        },
    },
})

# UCP payloads come back in result.structuredContent
for p in result["result"]["structuredContent"].get("products", []):
    print(p["id"], p["title"], p.get("price_range", {}).get("min"))

If you get real product results back — titles, prices (in minor units, e.g. 12000 = $120.00), variant IDs — you have a working UCP shopping agent. Everything past this point (create_cart, create_checkout, complete_checkout) is the same tool-call pattern with the same meta block. Full request and response shapes are in the spec's Catalog MCP binding.