# What is WebMCP? A plain-English guide for 2026

> WebMCP is a draft web standard that lets a web page register named JavaScript functions AI agents can call directly, instead of clicking around the page.

Updated 2026-09-24 · https://convertwebmcp.com/guides/what-is-webmcp

WebMCP is a draft web standard that lets a web page register named JavaScript functions, called tools, that an AI agent running in the browser can discover and call directly. Instead of guessing which button to click, the agent calls a named function with structured inputs and gets a structured response back. Shopify enabled ten of these tools on every Liquid storefront on August 5, 2026; ChatGPT's desktop browser started calling WebMCP tools on August 25, 2026.

## How WebMCP works

The flow has three steps:

1. A web page registers tools using JavaScript (or HTML form attributes).
2. A WebMCP-capable browser exposes those registered tools to any AI agent it hosts.
3. The agent calls a tool by name, passing valid inputs; the page runs the function in the user's existing session and returns a result.

Tools run inside the browser tab, with the user's current cookies and login state. They disappear when the page is closed or navigated away from. There is no separate server to provision, no connection string to manage, and no credentials to configure on the agent side.

Before WebMCP, agents drove browsers by taking screenshots, analysing the DOM or accessibility tree, deciding what to click, sending the click, and repeating. Chrome's documentation calls this actuation. It is slow, expensive in model-inference terms, and breaks whenever a page redesign moves a button. WebMCP replaces that loop with a direct function call.

## The current API

The current API (spec dated September 17, 2026) lives on `document.modelContext` and is only available in secure contexts (HTTPS). The entry point changed from `navigator.modelContext` in the May 2026 draft revision. `navigator.modelContext` is deprecated and is being removed across Chrome 150–152. If you see code or a tutorial that uses `navigator.modelContext`, it will not work in current Chrome.

```js
async function registerStoreTools() {
  // Feature-detect: browsers without WebMCP simply skip this.
  if (!('modelContext' in document)) return;

  const controller = new AbortController();

  await document.modelContext.registerTool(
    {
      name: 'lookup_product',
      title: 'Look up a product',
      description:
        'Returns title, price and availability for a product by its URL handle.',
      inputSchema: {
        type: 'object',
        properties: {
          handle: {
            type: 'string',
            description: 'URL handle of the product, e.g. "blue-running-shoes"',
          },
        },
        required: ['handle'],
      },
      annotations: {
        readOnlyHint: true, // only reads; changes nothing
      },
      execute: async ({ handle }, { signal }) => {
        const res = await fetch(`/products/${handle}.js`, { signal });
        if (!res.ok) return `Product "${handle}" not found.`;
        const p = await res.json();
        return `${p.title}: $${(p.price / 100).toFixed(2)}. Available: ${p.available}.`;
      },
    },
    { signal: controller.signal },
  );

  // To unregister the tool later, call controller.abort().
}

registerStoreTools();
```

Key fields:

- `name`: 1–128 characters; ASCII alphanumerics, underscores, hyphens, and dots only.
- `description`: required; this is the text the agent reads to decide whether to call the tool. Write it carefully.
- `inputSchema`: a JSON Schema object defining accepted inputs.
- `annotations.readOnlyHint`: set to `true` for tools that only read data, so agents know the call changes nothing.
- `annotations.consequentialHint`: set to `true` for tools that charge money, delete records, or send messages. Agents are expected to ask the user to confirm before calling these.
- `execute`: receives `(input, { signal })` and must return a Promise. The `signal` is an AbortSignal the browser passes so the execution can be cancelled.

`registerTool` returns a rejected promise if the name is already registered, if either `name` or `description` is an empty string, or if the `inputSchema` is not valid JSON Schema.

### API history: what broke and when

The spec changed four times in the first eight months of 2026:

- **March 2026**: `provideContext` removed.
- **April 2026**: `unregisterTool(name)` removed. Tools are now unregistered by aborting the AbortSignal passed at registration.
- **May 2026**: entry point moved from `navigator.modelContext` to `document.modelContext`.
- **Late June 2026**: `ModelContextClient` and `requestUserInteraction` removed.

Code written before June 2026 may no longer work. Check for `document.modelContext` (correct) versus `navigator.modelContext` (deprecated) as a quick freshness test on any WebMCP example you find.

## Who supports it

### Browsers (September 2026)

Chrome is the reference implementation. The origin trial opened with Chrome 149 on June 9, 2026, and runs through Chrome 156 (expected around October 20, 2026). A Chromium intent-to-ship filed May 15, 2026, lists Chrome 157 as the target for stable shipping on desktop, Android, and WebView: expected around November 3, 2026, but not committed.

Edge's origin trial runs to November 17, 2026. Brave has support behind a flag in Nightly builds. Firefox has taken a neutral position with no implementation announced. WebKit (Safari) has raised concerns in eight categories; no formal support exists.

### AI agents calling WebMCP tools (September 2026)

- **ChatGPT desktop browser**: "Site tools" available since August 25, 2026. Requires GPT-5.6 Sol or Terra models. GPT-5.6 Luna has WebMCP disabled. Not available on Enterprise or Edu plans. Only reads tools registered with JavaScript on the top-level page: tools inside iframes are not exposed.
- **Browser Use**: added support September 6, 2026.
- **Stagehand**: exposes `page.listWebMCPTools()` and `page.invokeWebMCPTool()`.
- **agent-browser**: support since version 0.36.0.
- **Gemini in Chrome**: announced at Google I/O on May 19, 2026; had not shipped as of September 2026.

## What it means for a Shopify store owner

Shopify added WebMCP to every Liquid storefront on August 5, 2026. Ten tools are registered automatically on every page:

`search_catalog`, `browse_store`, `get_product`, `show_variant`, `get_cart`, `update_cart`, `cancel_cart`, `proceed_to_checkout`, `manage_orders`, `search_shop_policies_and_faqs`

These cover the most common browsing and purchase tasks. A ChatGPT user can ask the assistant to find a product, add it to their cart, and start checkout: without clicking anything themselves.

What the defaults do not cover:

- **Live order status**: `manage_orders` links to the order history page; it does not return order data to the agent as structured text. If a customer asks "where is my order?", the agent redirects them to the page rather than answering.
- **Wishlists and comparison tools**: not included by default.
- **Detail that lives only in product descriptions**: agents work mostly from structured catalog fields. One vendor's sample of 400,000+ Shopify products found that 51% of what shoppers ask about sits somewhere in readable text, and only 6% of that is filterable (a vendor claim).
- **Store-specific policies or custom flows**: the `search_shop_policies_and_faqs` tool searches policy content, but complex return or exchange workflows may need custom tools.

The standard lets a page register more tools alongside Shopify's defaults, for example from theme code. Shopify doesn't document this yet, so test any extra tool on your own theme before relying on it.

## Limitations and risks

**Spec is still changing.** Chrome 157 is the first expected stable release, targeted for November 2026 but not committed. Any code you write should use feature detection (`if (!('modelContext' in document)) return;`) so it degrades gracefully in browsers that do not support the API.

**Browser coverage is limited.** WebMCP tools only work in browsers and agents that implement the spec. Safari has not committed to support, and neither has Firefox. Most of your visitors' agents cannot call your tools if they are not in a WebMCP-capable browser.

**Agent reach is small today.** As of September 2026, the webmcp.com directory listed 1,121 verified hand-built WebMCP deployments. ChatGPT's desktop browser support is real, but agent-assisted purchases are not a measurable share of e-commerce revenue in available data. Implement WebMCP as a progressive enhancement, not as a primary traffic strategy.

**Security concerns exist.** Any agent the browser hosts can call the tools you register, and third-party scripts on the same page run with the same access as your own code. Set `readOnlyHint` and `consequentialHint` accurately, return only data the signed-in shopper is allowed to see, and treat tool inputs as untrusted, the same as any other user input. Chrome's guidance also names malicious tool descriptions and contaminated tool results as prompt-injection risks for agents.

## How to test in Chrome

1. Open `chrome://flags/#enable-webmcp-testing` and set the flag to Enabled. Relaunch Chrome.
2. Install Chrome's "Model Context Tool Inspector" extension to inspect which tools are registered on the current page.

For testing in other browsers, the `@mcp-b/global` polyfill emulates the API (51,913 npm downloads per week as of September 2026).

## Sources

- [WebMCP: W3C Web Machine Learning Community Group Spec](https://webmachinelearning.github.io/webmcp/) (2026-09-17)
- [WebMCP: the Why?, the What? and the How?: Tech-Tech](https://tech-tech.life/2026/09/05/webmcp-the-why-the-what-and-the-how/) (2026-09-05)
- [WebMCP: AI in Chrome: Chrome for Developers](https://developer.chrome.com/docs/ai/webmcp) (2026-08-07)
- [ChatGPT Adds WebMCP Support For Interactive Websites: Search Engine Journal](https://www.searchenginejournal.com/chatgpt-adds-webmcp-support/587237/) (2026-08-27)
- [WebMCP is here: PayPal is helping every merchant become agent-ready: PayPal Developer Blog](https://developer.paypal.com/community/blog/WebMCP_PayPal_Agent_Ready/) (2026-09-16)
- [Shopify turned on WebMCP for every store: Atomz (vendor analysis)](https://atomz.beehiiv.com/p/shopify-turned-on-webmcp-for-every-store) (2026-09-16)
- [Chromium Intent to Ship: WebMCP: blink-dev](https://groups.google.com/a/chromium.org/g/blink-dev/c/gmYffo5WOE8) (2026-05-15)