What Shopify changed
Shopify's developer changelog states that the cart tools on the Storefront MCP server are being deprecated in favour of UCP-conforming Cart MCP tools. Concretely, the changelog states that get_cart and update_cart on https://{shop}.myshopify.com/api/mcp are deprecated, and that Cart MCP exposes create_cart, get_cart, update_cart and cancel_cart at https://{shop-domain}/api/ucp/mcp. Per the changelog, Cart MCP implements the UCP cart capability dev.ucp.shopping.cart, version 2026-04-08.
The changelog states that the deprecated tools "will be maintained until August 31, 2026," but that all documentation will refer to the Cart MCP tools. That is the entire scope of the announcement: this is the interface an AI shopping agent uses to create, read, replace and cancel a cart on a Shopify store. It is the agent-facing commerce plumbing, not the discovery layer. The changelog makes no claims about product discovery, citations, or how any AI engine chooses which products to recommend.
One terminology note up front. The fetched Shopify sources use "UCP" and "UCP-conforming" without expanding the acronym anywhere. Our house style reads it as Universal Commerce Protocol; that expansion is our attribution, not Shopify's wording.
Before and after, side by side
Four things move at once: the endpoint, the tool list, the request envelope, and the update semantics. The changelog explicitly warns that this is not a drop-in swap and directs developers to "consult the updated request and response schemas for all cart tools and update your app to match."
| Dimension | Storefront MCP cart tools (deprecated) | UCP Cart MCP |
|---|---|---|
| Endpoint | https://{shop}.myshopify.com/api/mcp | https://{shop-domain}/api/ucp/mcp |
| Tools | get_cart, update_cart | create_cart, get_cart, update_cart, cancel_cart |
| Request metadata | Not described in the changelog | meta object carrying ucp-agent.profile on every request; meta["idempotency-key"] (UUID) on cancel_cart |
| Update behaviour | Not described in the changelog | PUT semantics — each request replaces the cart's full state |
| Named spec | None stated in the changelog | UCP cart capability dev.ucp.shopping.cart, version 2026-04-08 |
| Support | Maintained until August 31, 2026 | All documentation now refers to these tools |
The tool list is the quiet expansion. Per the changelog, Cart MCP describes create_cart as "Create a new cart with line items and optional buyer context" and cancel_cart as "Cancel a cart" — neither has a stated Storefront MCP counterpart in this changelog. Our read: the intent is a full cart lifecycle for agents rather than a read-and-modify pair, which is what you would build if you expected agents to hold, abandon and clean up draft carts at volume.
PUT semantics is the migration detail that breaks quietly
The changelog states that update_cart "uses PUT semantics: each request replaces the cart's full state, so send the complete line_items array on every update rather than patching individual fields."
Our read: this is the single most dangerous line in the announcement, because it fails without erroring. An integration that ports the tool name and endpoint but keeps sending a partial payload will not receive a validation error. It will successfully replace the cart with whatever subset it sent, silently dropping every line item it omitted. An agent that adds a second product to a cart with a patch-shaped payload ends up with a one-item cart and no signal that anything went wrong.
A partial payload against a PUT-semantics endpoint does not fail. It succeeds at deleting the rest of the cart.
The practical implication for anyone maintaining agent code: treat this as a rewrite of the update path, not a find-and-replace on the endpoint string. The failure surfaces as lost revenue in a cart, not as a red line in a log.
Why the UCP alignment matters more than the endpoint
The changelog reads as consolidation rather than a feature launch. Shopify is pointing its agent cart surface at a named, versioned capability — dev.ucp.shopping.cart, version 2026-04-08 — instead of a tool set defined only by Shopify. Our interpretation: that makes an agent's cart code more portable. Code written against a UCP cart capability should, in principle, work against any UCP-conforming merchant surface, not just Shopify's.
That is a meaningful shift in where the leverage sits. If the cart interface is a shared, versioned spec, the competitive question for a merchant stops being "can an agent talk to my store" and becomes "does an agent choose my product once it can." The plumbing commoditises; the product data and the agentic storefront surface around it do not.
The second signal is the ucp-agent.profile requirement. The changelog states every request must carry a meta object with it. Our read: that means agents identify themselves to the cart layer, which is a plausible precondition for per-agent policy on the merchant side — different behaviour, limits or trust levels for different agents. The sources say nothing about what Shopify does with that identity, so treat the inference as exactly that.
Shopify's developer documentation index now lists an "Agents" section described as "Build agentic shopping experiences powered by Shopify merchants, from product discovery to checkout," with a call to action reading "Build agents with UCP." That framing sits alongside this changelog, though the changelog itself covers cart tools only.
What this means for ecommerce brands
The direct audience is narrow. The changelog addresses developers "building with the Storefront MCP cart tools" — anyone whose app or agent calls get_cart or update_cart on the old endpoint. If that is you, this is a dated migration task.
If you are a merchant who is not building agents, the honest answer is that the sources do not tell you whether you have anything to do. The changelog does not state whether merchants need to take action on their own stores, and it does not say how many apps or merchants are affected. We are not going to reassure you that there is nothing to do, because the source does not support that claim either way.
What is actionable regardless of who wrote the code: your cart can be touched by third parties. If an app, marketplace integration, or partner agent creates or modifies carts on your store, the migration risk is theirs and the lost order is yours. Ask them directly whether they are moving to Cart MCP and when. That question costs one email and is the highest-value thing most brand-side teams can do this month.
This also sharpens a distinction worth holding onto: cart tooling and agent checkout are the transaction end of agentic commerce. Being reachable at that stage only matters if an agent got far enough to want your product. Discovery and product data remain a separate problem — see our broader take on what brands should do now about agentic checkout.
What the changelog does not say
The open questions here are substantial, and stating them plainly is more useful than filling gaps with confident guesses.
- Release status of Cart MCP. The changelog uses no GA, beta, preview or pilot label. Whether Cart MCP is generally available is not stated.
- Availability. Whether Cart MCP is live on all Shopify stores, or gated by plan, region or opt-in, is not stated.
- What happens after August 31, 2026. The changelog says only that the old tools "will be maintained until" that date. Maintained-until is not the same as removed-on. Hard removal, error responses, or continued-but-unsupported operation are all consistent with the wording.
- Scope of the deprecation. The changelog scopes it to cart tools, but does not say what else the Storefront MCP server exposes or whether the rest of it continues.
- Schema differences. Developers are told to consult the updated request and response schemas; the changelog does not summarise what changed in them.
- The
ucp-agent.profilevalue. Its format, source, and how an agent profile is registered or validated are not stated. - The endpoint placeholder. The old endpoint uses
{shop}, the new one{shop-domain}. Whether that means the custom storefront domain, the myshopify.com domain, or either is not defined in the changelog. - Governance of the spec. Who maintains
dev.ucp.shopping.cartand where it is published is not stated in the sources. - Migration support. No migration tooling, dual-run period, or deprecation-warning mechanism is mentioned.
Shopify's Cart MCP documentation is cited by the changelog for further detail. That page's contents were not part of the source material for this article, so treat it as the place to resolve several of the questions above rather than as something we have summarised.
What to do this week
For teams with code calling the deprecated tools, the changelog gives an unusually concrete task list. In order:
- Find every caller. Grep your codebase for
api/mcpand for the tool namesget_cartandupdate_cart. The endpoint string is the reliable marker. - Repoint requests to
https://{shop-domain}/api/ucp/mcp, per the changelog's migration instruction. - Add the
metaobject carryingucp-agent.profileto every request, and ameta["idempotency-key"]UUID oncancel_cartcalls. - Rewrite the update path for full replacement. Send the complete
line_itemsarray on everyupdate_cartcall. Do not port a patch-shaped payload. If your client builds partial diffs anywhere, that logic has to go. - Diff the schemas. The changelog says the request and response schemas were updated and does not enumerate the differences, so read them rather than assuming field-for-field parity.
- Decide whether to adopt
create_cartandcancel_cart. These have no stated Storefront MCP equivalents, so they are new capability rather than migration work — but a cart you can explicitly cancel is a cart you can stop leaking. - Calendar August 31, 2026 as the end of the stated maintenance window for the old tools, and treat the current documentation as describing Cart MCP only.
Brand-side teams with no agent code of their own: send the vendor question described above, and if you want a read on how legible your storefront is to agents in the first place, the Agentic Readiness Grader covers the UCP and ACP surface on a live store.
The strategic read
Two months from the announcement to the end of a stated maintenance window is a short runway by Shopify API-deprecation standards. Our interpretation of that pace: the agent cart surface is being treated as pre-stable infrastructure rather than a versioned public API with a long tail of dependent apps. Shopify appears willing to move it faster than it would move something the whole app ecosystem is built on, which itself tells you how early this layer is.
The more durable signal is the direction. Shopify is replacing a proprietary cart tool set with an implementation of an external, versioned capability, and its own documentation index now says "Build agents with UCP." Our read is that the cart handshake is heading toward being a solved, standard, uninteresting thing — which is exactly what you want if you sell products rather than infrastructure. When every conforming merchant exposes the same cart interface, no brand wins on having wired it up correctly. They only lose by having wired it up wrong.
That pushes the competitive question back up the funnel. If an agent can transact with anyone, the differentiator is whether the agent picked your product, which comes down to product data an agent can parse and trust. That is a catalog-level problem on Shopify, not an endpoint-level one. The migration described here is a deadline. The visibility question underneath it does not have one.
Frequently asked questions
What exactly is being deprecated?
Shopify's changelog states that the cart tools on the Storefront MCP server are deprecated in favour of UCP-conforming Cart MCP tools. Named specifically are get_cart and update_cart on https://{shop}.myshopify.com/api/mcp.
What is the new endpoint and which tools does it expose?
Per the changelog, Cart MCP exposes its tools at https://{shop-domain}/api/ucp/mcp and provides four tools: create_cart, get_cart, update_cart and cancel_cart. It implements the UCP cart capability dev.ucp.shopping.cart, version 2026-04-08.
Do the old tools stop working on August 31, 2026?
The changelog says only that the deprecated tools "will be maintained until August 31, 2026." It does not state whether they are removed, start returning errors, or continue running unsupported after that date. Treat it as the end of the stated maintenance window, not a confirmed shutoff.
Is this a drop-in swap of tool names?
No. The changelog identifies three changes requiring code edits: the endpoint moves, every request must include a meta object carrying ucp-agent.profile (plus a meta idempotency-key UUID on cancel_cart), and update_cart uses PUT semantics so each request replaces the cart's full state. The changelog also directs developers to consult the updated request and response schemas.
Do Shopify merchants who are not building agents need to do anything?
The sources do not say. The changelog addresses developers building with the Storefront MCP cart tools and does not state whether store owners have any direct action. Our suggestion is to ask any third-party app, marketplace or agent vendor that touches your cart whether they are migrating.
Does this change affect whether AI engines recommend my products?
The changelog covers cart tooling only. It makes no claims about product discovery, citations, or how any AI engine selects products. This is the agent-facing transaction surface, not the discovery surface.
Ask AI about this
Want a second read on how this affects your stack? Paste this into your AI assistant of choice: