UCP Checker
Guides · Retail

Google's UCP MCP Transport (Beta): What It Sends and Skips

· 20 November 2026 · 10 min read

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.shopping Native 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:

  1. Publish "transport": "mcp" in your /.well-known/ucp profile, on UCP version 2026-04-08 or later. (The 2026-01-23 platform profile "negotiates only rest and embedded transports".)
  2. Implement a stateless tools/call endpoint that meets the guide's requirements.
  3. 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_checkout arrives with "checkout": {}. The UCP MCP spec doesn't define a checkout property 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 HTTP Idempotency-Key header 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 a https://ucp.goog/... URI, but "The UCP-Agent HTTP header is the only authoritative source of the platform profile URL."
  • Headers. Request-Id, Idempotency-Key, Payment-Environment (live or sandbox), UCP-Agent (for example profile="https://ucp.goog/profiles/2026-04-08/ucp.json"), a User-Agent of Google-Shopping-Merchant-Integration, Google/UCP* or Google-UCP-Prober/1.0, and X-Forwarded-For when 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/*, or prompts/*". It calls tools/call directly with the fixed names.
  • No sessions. No Mcp-Session-Id; "Every tools/call HTTP POST request is independent and stateless."
  • No SSE, streaming, stdio or batching. One JSON-RPC request, one JSON response.
  • No Accept header. The MCP Streamable HTTP spec expects Accept: application/json, text/event-stream on 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-key and authorization when present. The guide says "Signatures exclude the ucp-agent header." The UCP signatures spec lists ucp-agent as a covered component "Required if UCP-Agent header is present". Google's guide asks verifiers to read the label and components from Signature-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 initialize handshake before tools/call; the MCP spec's session model does. A server that answers both ways serves Google and clients that start with initialize.

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-08 and 2026-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/call without initialize, no session header required, a JSON reply when there's no Accept header, and the full object in structuredContent.
  • Mind the order of services. Google picks the first RPC entry, so the order of mcp and rest decides which one it uses.

What it means for agent builders

  • Stateless calls are a valid client shape. Google's client skips initialize and tools/list because 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, not content. 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

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

What does a UCP agent find at your store?
Check it once and it gets its own status page.
Check a store

Keep reading

16 Nov 2026 UCP Email Matching Explained: Linking an Existing Account When the Issuer Runs the Mailbox, Step by Step Guides · 10 min 11 Nov 2026 UCP Food Checkout Explained: An Agent Orders Dinner, Step by Step Guides · 14 min 10 Nov 2026 UCP Subscriptions Explained: Purchase Options from Catalog to Order, Step by Step Guides · 12 min