Google now takes UCP checkout over MCP as well as REST. Its UCP developer guide has a new page, Model Context Protocol (MCP) transport (Beta), listed in the November 2026 latest updates: an early-access route for merchants to run UCP Native Checkout and Cart through a single MCP tools/call endpoint instead of REST resources. The page was last updated on 3 November 2026.
REST stays Google's recommended default. MCP is per account, after integration testing, and Google uses a deliberately narrow, stateless slice of MCP: no initialize, no sessions, no streaming. Here is what Google sends, what it skips, how to set up the official MCP SDKs for it, and how it lines up with the UCP spec.
What is Google's MCP transport for UCP?
Google's MCP transport for UCP is an early-access (Beta) way to serve UCP Native Checkout and Cart to Google as JSON-RPC 2.0 tools/call requests over HTTP POST, one independent request per call. In Google's words: "Use the REST transport as the default option for UCP Native Checkout and Cart." MCP is for merchants whose "backend already exposes UCP capabilities through a stateless JSON-RPC 2.0 tools/call endpoint".
Three points from the guide shape everything else:
- Self-serve validation is REST only. "Merchant Center self-serve checkout validation supports only REST." MCP endpoints are tested by Google during onboarding.
- Publishing it doesn't switch it on. Adding
"transport": "mcp"to your profile "does not activate MCP in production on its own. Google enables MCP transport selection for your partner account after integration testing." - Checkout and cart only. The guide covers
dev.ucp.shoppingNative Checkout and Cart. "Other Google agentic integrations that connect to a stateful MCP gateway are documented separately."
How to request access
The guide lists three steps:
- Publish
"transport": "mcp"in your/.well-known/ucpprofile, on UCP version2026-04-08or later. (The2026-01-23platform profile "negotiates onlyrestandembeddedtransports".) - Implement a stateless
tools/callendpoint that meets the guide's requirements. - Submit the UCP integration interest form or contact your Google representative.
The profile entry goes under ucp.services["dev.ucp.shopping"]. Order matters: Google reads that array in order and "selects the first RPC transport entry (mcp or rest)", skipping embedded. To have Google use MCP, put the mcp entry before rest:
{
"ucp": {
"version": "2026-04-08",
"services": {
"dev.ucp.shopping": [
{
"version": "2026-04-08",
"spec": "https://ucp.dev/2026-04-08/specification/overview",
"transport": "mcp",
"endpoint": "https://merchant.example.com/ucp/mcp",
"schema": "https://ucp.dev/2026-04-08/services/shopping/mcp.openrpc.json"
},
{
"version": "2026-04-08",
"spec": "https://ucp.dev/2026-04-08/specification/overview",
"transport": "rest",
"endpoint": "https://merchant.example.com/ucp/v1",
"schema": "https://ucp.dev/2026-04-08/services/shopping/rest.openapi.json"
}
]
}
}
}
The endpoint URL must use https://, carry no userinfo, query string, fragment, backslash or dot segments, and sit on the same business domain (eTLD+1) as your profile or your registered Merchant Center domain.
What Google sends
Every call is an HTTP POST with Content-Type: application/json to the one MCP endpoint in your profile. The body is a JSON-RPC 2.0 tools/call envelope with a UUID v4 id, and params.name is one of nine fixed UCP tool names:
| Tool | REST equivalent |
|---|---|
create_checkout |
POST /checkout-sessions |
get_checkout |
GET /checkout-sessions/{id} |
update_checkout |
PUT /checkout-sessions/{id} |
complete_checkout |
POST /checkout-sessions/{id}/complete |
cancel_checkout |
POST /checkout-sessions/{id}/cancel |
create_cart |
POST /carts |
get_cart |
GET /carts/{id} |
update_cart |
PUT /carts/{id} |
cancel_cart |
POST /carts/{id}/cancel |
Cart tools apply "when Cart and MCP are enabled for your account".
params.arguments splits the target from the payload: meta always, a top-level id on calls about an existing resource, and the checkout or cart object on create and update. From version 2026-04-08, the inner checkout object on an update doesn't repeat the id. Google's create_checkout example:
{
"jsonrpc": "2.0",
"id": "b3b8c9d0-1234-4ef5-89ab-cdef01234567",
"method": "tools/call",
"params": {
"name": "create_checkout",
"arguments": {
"meta": {
"ucp-agent": { "profile": "https://www.google.com" },
"idempotency-key": "550e8400-e29b-41d4-a716-446655440000"
},
"checkout": {
"line_items": [ { "item": { "id": "sku_123" }, "quantity": 1 } ],
"context": { "currency": "USD" }
}
}
}
}
A few details are easy to miss:
cancel_checkoutarrives with"checkout": {}. The UCP MCP spec doesn't define acheckoutproperty for that tool, so Google tells strict validators to accept the call "with or without"checkout": {}".- Two idempotency keys.
meta["idempotency-key"]is sent on state-changing calls only. The HTTPIdempotency-Keyheader is sent on every POST, reads included, and is generated "independently". Treat them as separate values. - Don't take keys from
meta.meta["ucp-agent"]["profile"]is"https://www.google.com"or ahttps://ucp.goog/...URI, but "TheUCP-AgentHTTP header is the only authoritative source of the platform profile URL." - Headers.
Request-Id,Idempotency-Key,Payment-Environment(liveorsandbox),UCP-Agent(for exampleprofile="https://ucp.goog/profiles/2026-04-08/ucp.json"), a User-Agent ofGoogle-Shopping-Merchant-Integration,Google/UCP*orGoogle-UCP-Prober/1.0, andX-Forwarded-Forwhen IP forwarding is on.
What Google doesn't do
From the guide's "Current limitations":
- No lifecycle or discovery calls. Google "does not call
initialize,notifications/initialized,tools/list,resources/*, orprompts/*". It callstools/calldirectly with the fixed names. - No sessions. No
Mcp-Session-Id; "Everytools/callHTTPPOSTrequest is independent and stateless." - No SSE, streaming, stdio or batching. One JSON-RPC request, one JSON response.
- No
Acceptheader. The MCP Streamable HTTP spec expectsAccept: application/json, text/event-streamon POSTs; Google sends none.
Getting the official MCP SDKs to accept it
The guide says the official SDKs reject a POST with no Accept header with "HTTP 406 Not Acceptable (or 400 Bad Request)", and neither has a setting to allow it. The fix in both is to add the header in middleware or at the gateway when it's missing.
TypeScript (@modelcontextprotocol/sdk): create a new McpServer and a new StreamableHTTPServerTransport for each POST (a shared server throws "Already connected to a transport" when requests overlap), with sessionIdGenerator: undefined so tools/call works without initialize, and enableJsonResponse: true for a plain JSON body. Set both req.headers.accept and req.rawHeaders before handleRequest.
Python (mcp): on FastMCP set stateless_http=True and json_response=True, and list your public domain in transport_security allowed_hosts. By default FastMCP allows only localhost and answers public hosts with HTTP 421 Misdirected Request. Add an ASGI middleware that sets the Accept header when it's absent.
Replies and errors
Put the full UCP Checkout or Cart object in result.structuredContent, the same schema as the REST response. "Google parses only result.structuredContent. Google ignores result.content text blocks and result.isError." A missing or null structuredContent on a non-error response fails the call.
| Situation | What to return |
|---|---|
Recoverable checkout problem (address_undeliverable, quantity_adjusted) |
HTTP 200, ucp.status: "success", top-level status incomplete or requires_escalation, and messages |
Session can't be created (out_of_stock, item_unavailable) |
HTTP 200, ucp.status: "error", messages (and optional continue_url), no top-level id or status |
| Protocol or tool failure | A JSON-RPC error object |
| Transport failure | Non-200 (401, 403, 429, 500, 503) fails the call; on a 401 for OAuth, Google refreshes the token and retries once |
How it lines up with the UCP spec
The tool names, the meta / id / payload split and the structuredContent reply are UCP's own MCP binding; Google's guide follows the checkout MCP spec for them. Three points are worth checking against your own implementation:
- Streaming. UCP's MCP conformance list says an implementation MUST "Support HTTP transport with streaming." Google uses only plain JSON replies. A store that serves other platforms as well as Google keeps streaming support and adds the stateless JSON path; the two don't conflict.
- Signed components. Google signs MCP calls the same way as REST: label
sig-ucp,tag="ucp-rest-request", covering@method,@path,@authority,content-type,content-digest,idempotency-keyandauthorizationwhen present. The guide says "Signatures exclude theucp-agentheader." The UCP signatures spec listsucp-agentas a covered component "Required ifUCP-Agentheader is present". Google's guide asks verifiers to read the label and components fromSignature-Input"dynamically", not from a fixed list. Check what your verifier requires before you go live. - Statelessness. UCP's MCP spec doesn't require an
initializehandshake beforetools/call; the MCP spec's session model does. A server that answers both ways serves Google and clients that start withinitialize.
Who declares MCP today
Of the stores we check with a valid UCP profile, about 97% declare an MCP service and about 27% declare REST (a profile can declare several), per our adoption stats on 20 November 2026. Declaring MCP isn't the same as meeting Google's profile: Google needs 2026-04-08 or later, the stateless behaviour above, its own testing and per-account enablement.
Also new in Google's November updates
- Native checkout latency: best practices per phase for Create, Update and Complete calls.
- Order lifecycle webhooks: guides on webhook latency and retries, with HTTP 200 acknowledgement schemas and retry rules for 5xx and 4xx codes, for versions
2026-04-08and2026-01-23.
What it means for stores
- If your backend is REST, stay on REST. Google calls it the recommended default, and it's the only transport Merchant Center can validate self-serve.
- If you already serve UCP over MCP, check four things before asking for access:
tools/callwithoutinitialize, no session header required, a JSON reply when there's noAcceptheader, and the full object instructuredContent. - Mind the order of
services. Google picks the first RPC entry, so the order ofmcpandrestdecides which one it uses.
What it means for agent builders
- Stateless calls are a valid client shape. Google's client skips
initializeandtools/listbecause UCP fixes the tool names. Other platforms may do the same, so a server that requires a session will turn some clients away. - Read
structuredContent, notcontent. That's where UCP puts the object, and where Google reads it. - Signing is the same as REST. The RFC 9421 signature covers the JSON-RPC body through
Content-Digest.
What we'll watch
- Whether MCP leaves early access, and whether Merchant Center's self-serve validation adds MCP.
- Whether Google's stateless slice shows up in the UCP spec's MCP binding, and how the signed-components point settles.
- Whether other platforms adopt the same stateless shape for UCP over MCP.
FAQ
Does Google support UCP over MCP? Yes, in early access (Beta), for Native Checkout and Cart. REST is the recommended default, and Google enables MCP per account after integration testing.
Does Google call initialize or tools/list?
No. Google calls tools/call directly with the fixed UCP tool names, with no session header, no streaming and no batching.
Can I validate my MCP endpoint in Merchant Center? No. Merchant Center's self-serve checkout validation tests REST only. Google runs its own integration checklist on MCP endpoints during early access.
Which UCP version do I need for MCP with Google?
2026-04-08 or later. The 2026-01-23 platform profile negotiates only rest and embedded.
Why does my MCP server return 406 to Google?
Google sends no Accept header, and the official MCP SDKs reject that with 406 or 400. Add Accept: application/json, text/event-stream in middleware or at your gateway when it's missing.
If I declare both MCP and REST, which does Google use?
The first RPC entry under dev.ucp.shopping in your profile, once MCP is enabled for your account. Put mcp first to have Google use it.
Does Google read result.content or isError?
No. It parses only result.structuredContent, and a missing structuredContent on a non-error reply fails the call.
About UCP Checker
UCP Checker is the independent validation and observability layer for the Universal Commerce Protocol. We crawl, validate and grade every public UCP manifest we can find, run the merchant directory, the UCP Score, live adoption stats, the vertical guides and the authority-bound vendor map, and track the spec as it evolves so you don't have to — measured from two vantages (what a business declares, and what actually happens when an agent transacts), the same way for everyone, without picking winners.
Sources
- Model Context Protocol (MCP) transport (Beta), Google Universal Commerce Protocol (UCP) Guide, Google for Developers; last updated 3 November 2026.
- Latest updates, Google UCP Guide; November 2026 entries.
- Checkout capability: MCP binding, UCP specification.
- Message signatures, UCP specification.
- Transports, Model Context Protocol specification, revision 2025-03-26.
- UCP adoption stats, UCP Checker; read 20 November 2026.
Related coverage: Google's UCP integration hub in Merchant Center · MCP vs UCP vs AP2: what's the difference? · UCP over A2A, step by step · Shopify Storefront MCP after 31 August
