WebMCP for merchants: storefront tools and checkout

WebMCP lets a page expose tools to a compatible browser agent. Shopify supports storefront tools and a separate Checkout WebMCP flow, so the permissions and capabilities available on the current page matter.

Reviewed October 1, 2026 · 6 min read

On this page6 sections
  1. How browser tools work
  2. Shopify storefront tools
  3. Storefront WebMCP and Checkout WebMCP are distinct
  4. Tools still depend on the data behind them
  5. Treat the specification as evolving
  6. A practical verification checklist

Browser agents can operate a site's controls, but that is not the only interface a page can offer. Alongside accessible forms, a page can expose named tools with explicit inputs and results.

WebMCP provides that browser-based interface. A supporting agent can discover a tool such as checking stock or updating a cart instead of inferring the operation from buttons and layout. The tool still depends on correct data, permissions and business logic.

How browser tools work#

The current WebMCP draft exposes a model context API on the document. A page registers tools, and a compatible agent discovers and calls them. Browser implementations and draft versions can differ, so check both before copying code.

MethodWhat it does
registerTool(tool, options)Registers a tool for an agent to invoke
getTools(options)Retrieves the tools currently registered
executeTool(tool, inputObject, options)Executes a registered tool

A tool declaration supplies a name, description and execution callback, with an input schema where needed. This read-only illustration assumes a supporting implementation and an existing stock endpoint; it is not a complete production integration:

if (document.modelContext) {
  document.modelContext.registerTool({
    name: 'check_availability',
    description: 'Read current stock for a product size; does not reserve it',
    inputSchema: {
      type: 'object',
      properties: {
        sku: { type: 'string' },
        size: { type: 'string' },
      },
      required: ['sku', 'size'],
      additionalProperties: false,
    },
    execute: async ({ sku, size }) => {
      const query = new URLSearchParams({ sku, size })
      const response = await fetch(`/api/stock?${query}`)
      if (!response.ok) throw new Error('Stock lookup failed')
      return response.json()
    },
  })
}

Check the draft and the browser version

The current draft uses document.modelContext. Older explainers and earlier implementations may use different APIs. Feature-detect support and test registration and invocation; an unsupported property can throw an error, not merely fail silently.

The idea resembles an MCP server, but the execution context differs. WebMCP tools live in the page and browser session. A remote MCP server has a separate connection and authentication model. Similar tool descriptions do not make them interchangeable.

Shopify storefront tools#

Shopify's WebMCP reference documents tools on Liquid storefronts and the Hydrogen developer preview. The available tools support browsing and cart operations. Verify the current tool list in a supported browser and account for page transitions.

ToolWhat an agent can do with it
search_catalogSearch products, collections, articles and pages, with prices and availability
browse_storeList collections, or the products inside one
get_productFull detail including variants, pricing and stock status
show_variantNavigate the shopper to a product with a variant selected
get_cartRead the cart contents with line items and variant detail
update_cartAdd items, change quantities, remove items
cancel_cartEmpty the cart
proceed_to_checkoutTake the shopper to checkout after verifying the cart
manage_ordersSend the shopper to order history for status and tracking
search_shop_policies_and_faqsAnswer questions about policies and services

Browser and agent support is evolving. Test the exact versions you intend to support, and keep the ordinary website usable when tools are unavailable. A negative result can come from the browser, client, page or access policy.

Storefront WebMCP and Checkout WebMCP are distinct#

The storefront's proceed_to_checkout action navigates to checkout. Shopify now also documents Checkout WebMCP, which can expose tools on eligible checkout pages. Earlier guidance that browser tools could never place an order is no longer accurate.

AspectStorefront WebMCPCheckout WebMCP
ContextThe storefront browser pageThe eligible checkout browser page
PurposeDiscover products and manage the cartRead or update checkout and complete a confirmed order
Tool discoveryRead the tools available on that pageRefresh after navigation and state changes
Purchase boundaryproceed_to_checkout reaches checkoutcomplete_checkout requires buyer confirmation
AccessSupported browser and agent behaviorDocumented eligibility, identity and checkout requirements

Shopify's checkout guide requires buyer confirmation before complete_checkout. It also documents Web Bot Auth for identifying agents and checking eligibility. Do not treat a tool's presence as permission to spend or assume it is available on every checkout.

Read the final state before reporting success

A browser tool can navigate or change checkout state. Verify the returned result and final order reference before saying a purchase completed. If the customer must handle authentication or a payment challenge, preserve a clear handoff.

Check public information before testing actions

A Nexez scan reviews public business and offer information. It does not exercise browser checkout tools; test those separately with a supported client and an appropriate test purchase flow.

Scan your site free

Tools still depend on the data behind them#

A named cart operation can reduce interface ambiguity, but it can still fail, time out or return an unavailable variant. Test those outcomes as well as the successful path.

The tools return the catalog, stock and policy information your systems provide. Review the source data and the returned values, including variant identifiers, price units and availability status.

Keep product data, delivery terms and return policies consistent across the page and the tool response. Recheck transactional details before commitment rather than assuming discovery data remains current.

Treat the specification as evolving#

WebMCP is currently a Draft Community Group Report, not a W3C Recommendation. Record the browser and API version you test and review compatibility when upgrading.

Identity, authorization and tool execution are separate concerns. A verified agent request can establish a caller identity without proving that a customer approved a particular purchase.

A practical verification checklist#

  1. Confirm which tools the current page registers in a supported browser.
  2. Check exact inputs, result formats and error behavior against the current platform documentation.
  3. Refresh discovery after navigation and other tool-list changes.
  4. Compare product and cart results with the underlying catalog and stock records.
  5. Test customer handoffs, approval and the final order result in an appropriate test environment.
  6. Keep a usable form and checkout path for clients that do not support the tools.

Use WebMCP where it makes a real browser task clearer and more reliable. Its value is a tested interaction with your business systems, not simply adding another protocol label to a readiness checklist.

Maintain the offers behind your interfaces

See how Nexez publishes structured business listings and supported actions. Keep the offer information accurate whether customers reach it through a page, feed or connected tool.

See how it works

Frequently asked questions

What is WebMCP?

WebMCP is an evolving browser API for exposing page tools to compatible agents. Tools have names, descriptions and execution behavior, with schemas for inputs where needed. Support depends on the current browser, client and specification version.

Do I have to enable WebMCP on my Shopify store?

Shopify documents storefront tools on Liquid stores and the Hydrogen developer preview. Check the actual page in a supported browser rather than assuming every client can use them. Checkout tools have their own eligibility and workflow requirements.

Can an AI agent place an order on my Shopify store without me knowing?

Shopify's Checkout WebMCP can place an order on eligible checkouts after the buyer confirms it. Storefront tools alone lead to checkout rather than proving completion. Agent identity and access requirements are separate from the customer's authorization to purchase.

Is it navigator.modelContext or document.modelContext?

The current draft uses document.modelContext. Earlier material or implementations may differ, so consult the draft and browser documentation together. Feature-detect support and test calls; do not assume an unsupported API will fail harmlessly.

Which browsers support this?

Check current implementation support for the exact browser and agent you plan to use. Chromium-based implementations are a relevant starting point, but version differences can affect method arguments and behavior. Preserve a usable website fallback.

Does WebMCP replace an MCP server?

No. WebMCP exposes tools in the browser page and session; a remote MCP server uses a separate connection. They can support related tasks but have different execution, discovery and permission boundaries.

If agents can call tools, does structured data still matter?

Yes, accurate visible information and appropriate structured data remain useful for discovery and customer understanding. Tools provide an action or data interface; they do not correct stale catalog values. Test consistency across each published output.

Keep reading