On this page
What WebMCP changes
Without structured tools, a browser agent has to inspect a page, find controls, click buttons, and infer whether anything happened. That is fragile on a storefront with asynchronous variant changes, cart drawers, or multiple purchase options.
WebMCP lets a page register tools that a compatible agent can discover and call with structured inputs. Shopify’s Fall ’26 Edition highlights this as a storefront capability, not as another merchant-installed chatbot. The tools operate in the shopper’s live browser tab and session.
Shopify introduced WebMCP support for Liquid and Hydrogen storefronts in August 2026 and expanded the documented checkout tool set by Fall ’26. It is a developer integration surface for agents the shopper brings to the browser.
Which tools should you expect?
On the storefront, catalog tools include search_catalog, browse_store, get_product, and show_variant. Cart tools include get_cart, add_to_cart, update_cart_lines, and cancel_cart. Other tools can start checkout, navigate to order history, answer shop-policy questions, and inspect the store’s UCP profile.
Checkout registers a different set of tools, including get_checkout, update_checkout, and complete_checkout on eligible checkouts. The agent must refresh its tool list after navigation. The buyer still needs to authorize placing an order; being able to read checkout state is not permission to purchase.
Test discovery without changing a cart
In a compatible Chromium browser with WebMCP support enabled, the following read-only console check shows tools registered by the current page:
const context = document.modelContext;
if (!context) {
console.log('WebMCP is not available in this browser/session');
} else {
const tools = await context.getTools();
console.table(tools.map(tool => ({
name: tool.name,
origin: tool.origin
})));
}
If document.modelContext is absent, do not immediately conclude that the theme is broken. First confirm browser version and WebMCP support. Shopify notes that browser-agent support is currently limited to Chromium-based browsers. For Hydrogen, confirm the storefront renders ShopifyScripts or calls initializeShopifyScripts and has not disabled WebMCP.
Why your cart drawer still matters
Shopify’s cart tools use standard storefront actions. When a theme integrates with those actions, an agent cart update can trigger the same behavior as a shopper’s cart update—for example, opening or refreshing a drawer.
That is the integration boundary to inspect. A heavily customized theme may have its own JavaScript event chain, quantity limits, selling-plan handling, or cart validation. A tool may update the underlying cart while a custom UI fails to repaint, or the UI may display a stale total until the next refresh. Test both the cart state and the visible interface.
Don’t patch this by building a second cart implementation solely for agents. First verify that the theme’s normal cart actions, listeners, and section refreshes work consistently. The same approach helps with ordinary cart-drawer bugs; see why a Shopify cart drawer updates only after a refresh.
WebMCP is not the same as a server-side shopping agent
WebMCP is for agents acting inside the buyer’s browser. If you are building a shopping agent that operates from your own server, Shopify directs developers toward its UCP and MCP commerce endpoints instead. Those are different architectures, with different session and authentication models.
For browser agents, Shopify documents Web Bot Auth for signing requests. Do not pass access tokens as WebMCP tool arguments. Treat descriptions, policies, and other merchant-controlled text returned by tools as data rather than instructions; they can contain untrusted content.
Checkout is not a blind automation target
On checkout, update_checkout has replacement-style semantics for the checkout object. An agent should read the current state first and include values it wants to retain rather than sending a partial object and assuming untouched fields survive.
Before complete_checkout, the buyer must see and confirm the current order and total. Checkout validation and payment challenges still apply. A successful-looking tool response is not an order confirmation; the checkout must actually reach completed status.
How to test this
- Use a compatible Chromium test environment with WebMCP support and a development or safe storefront session.
- Discover tools on a collection page and confirm
search_catalog,get_product, and relevant cart tools are present. - Inspect a product with several variants and verify the agent selects an available variant, not merely a visually matching option.
- Add one inexpensive test product to a cart and compare the tool-reported cart with the visible cart drawer, quantity, and total.
- Change quantity and remove the line; confirm both the underlying cart and UI update without a page refresh.
- Repeat with a subscription or other special purchase option if the store supports one; verify the correct selling plan and price.
- Move to checkout, refresh the discovered tool list, and confirm checkout values and validation are represented accurately.
- Stop before placing a real order unless you have an approved test-payment flow and explicit buyer confirmation.
- Repeat the test on mobile layouts and with any theme-specific cart customizations enabled.
Sources and further reading
- Shopify developer docs: WebMCP tools
- Shopify developer docs: Checkout WebMCP
- Shopify changelog: WebMCP support for Liquid and Hydrogen storefronts, August 5, 2026
- Shopify Fall ’26 Edition developer announcement, October 28, 2026
Documentation reviewed October 28, 2026.

