WebMCP Explained: Letting AI Agents Use Your Website, After Shopify's Checkout Launch
On 28 September Shopify put WebMCP tools into checkout, so an AI agent in the buyer's browser can fill in and place an order once the buyer confirms. Here is what WebMCP is, how it differs from MCP, how to turn it on in Chrome, how a page registers a tool, and what a business should do with it now.
WebMCP is a proposed browser API that lets a web page tell an AI agent what it can do there: a set of tools, each with a name, a description, an input schema and a JavaScript function. Instead of an agent guessing which button to click from a screenshot, the page says "here is searchProducts, here is addToCart, here is what they need". The idea moved from proposal to production on 28 September 2026, when Shopify added WebMCP tools to checkout. The spec is still a Community Group draft (latest version 2 November 2026), and only Chromium browsers support it, through origin trials. Below: what WebMCP is, how it differs from MCP, what Shopify shipped, how to turn it on, how a page registers a tool, and what a business should do now.
What is WebMCP?
WebMCP lets a website publish its own actions as tools for an AI agent running in the browser. The agent reads the tool list, picks a tool, and the page runs it with the user's session. No screenshots, no guessing at the DOM.
There are two ways to define a tool:
- The imperative API: JavaScript, with
document.modelContext.registerTool(). This is the part the spec defines. - The declarative API: attributes on an ordinary HTML
<form>. It is still an explainer, not part of the spec, but Chrome's trial includes it.
The spec is a Draft Community Group Report of the W3C Web Machine Learning Community Group, edited by two Microsoft and two Google engineers. It is not a W3C Standard and not on the standards track yet.
WebMCP vs MCP: what is the difference?
Both describe tools the same way: a name, a natural-language description for the model, and a JSON schema for the inputs. Everything else differs:
| MCP | WebMCP | |
|---|---|---|
| Where tools run | On a server | In the page, as JavaScript |
| Transport | JSON-RPC over HTTP or stdio | Inside the browser |
| Identity | OAuth or API keys | The user's existing browser session |
| Who is there | Can run with no person present | Designed for a person who is present |
| Who can offer tools | Servers the client chose to connect | Any site the user visits |
| Clients today | Claude, ChatGPT, Copilot, Cursor and many more | Chromium browsers in origin trials, browser agents |
Put simply: MCP is how an assistant reaches your system from outside. WebMCP is how your website helps an agent that is already in the user's browser. A business with customers who use AI assistants may eventually want both. More on the server side in what MCP is.
WebMCP and Shopify: what shipped in checkout
Shopify's developer changelog of 28 September 2026 lists four tools on eligible checkouts (coverage in Search Engine Journal):
get_checkoutreads the open checkout, its messages, and the order after purchase;update_checkoutchanges contact details, shipping or pickup, discount codes, payment and extra fields;complete_checkoutplaces the order, after the buyer confirms;navigate_to_storefrontreturns the tab to the store.
The safeguards are the interesting part, and a good template for anyone else:
- Agents cannot change the items in the order, and the tools don't accept new card details. An agent can only select a saved Shop Pay card or an approval already on file.
- The tools run inside checkout and use the same state as the checkout page, so checkout validates every update itself.
- Payment challenges such as 3D Secure return control to the buyer.
- Shopify tells agent developers to show the buyer the order and total and get permission before
complete_checkout. A signature or a ready-to-complete status doesn't count as consent.
Merchants don't configure anything. Standard checkouts get the tools only when the buyer pays with Shop Pay, and B2B, embedded and mobile SDK checkouts are excluded. Agent support is Chromium-only for now.
Which browsers support WebMCP?
As of 5 November 2026:
| Browser | Status |
|---|---|
| Chrome | Behind a flag since Chrome 146. Origin trial from Chrome 149, scheduled to end with Chrome 156. In late September 2026 Google asked to extend it to Chrome 162 (Chrome Status). |
| Edge | Its own origin trial from Edge 150, listed until 30 March 2027. A Chrome token does not work in Edge. |
| Firefox, Safari | No public signal. |
| Others | The WebMCP repo's status page lists experimental support in Brave's Leo assistant and support in ChatGPT Desktop. |
Chrome's status is still "Proposed": it has not shipped to all users. Google said in its trial extension request that it is changing the API based on trial feedback, so expect more changes before it ships.
How to enable WebMCP in Chrome
- For local testing: open
chrome://flags/#enable-webmcp-testing, set it to Enabled, and relaunch Chrome (Chrome docs). - To test with an agent: install Google's Model Context Tool Inspector extension. It lists the tools on the page and lets you call them with a natural-language prompt (it needs a Gemini API key).
- For real visitors: register your origin for the WebMCP origin trial and send the token in a
<meta http-equiv="origin-trial">tag or anOrigin-TrialHTTP header. Edge needs a separate token from its own trial page.
Both APIs are gated by the tools Permissions Policy, which defaults to self: a cross-origin iframe can register tools only with allow="tools".
WebMCP tutorial: register your first tool
The API is still moving, so treat this as the shape, not copy-paste code. In the current spec, a page registers a tool on document.modelContext:
const controller = new AbortController();
if ("modelContext" in document) {
await document.modelContext.registerTool({
name: "searchProducts",
description: "Search the catalog by keyword and maximum price.",
inputSchema: {
type: "object",
properties: {
query: { type: "string" },
maxPrice: { type: "number" }
},
required: ["query"]
},
annotations: { readOnlyHint: true },
async execute(input, { signal }) {
const results = await searchAPI(input.query, input.maxPrice, { signal });
return { products: results };
}
}, { signal: controller.signal });
}
// Later, to remove the tool:
controller.abort();
Three things changed since the first previews, and most tutorials online still show the old version:
navigator.modelContextbecamedocument.modelContext. Early Chrome builds usednavigator. Feature-detectdocumentfirst.provideContext(),clearContext()andunregisterTool()are gone. You remove a tool by aborting the signal you registered it with.- Annotations now include
consequentialHintanduntrustedContentHintbesidesreadOnlyHint. Mark what a tool does, but don't count on the agent to enforce it.
The declarative version turns an existing form into a tool, using attributes from the declarative API explainer:
<form toolname="search-cars" tooldescription="Search cars by make and model" action="/search">
<input type="text" name="make" toolparamdescription="The vehicle's make, e.g. BMW or Ford" required>
<button type="submit">Search</button>
</form>
Without toolautosubmit, the agent fills in the form and the user presses the button. That is the safer default for anything that writes.
Is WebMCP secure?
WebMCP inherits the browser's protections: it needs HTTPS, tools are visible only to their own origin by default, and a site can switch it off entirely with Permissions-Policy: tools=(). The spec's own security section is frank about what remains:
- Prompt injection is not solved. Malicious text can sit in a tool's description, in what a tool returns, or in content the agent reads. The spec says agents "cannot rely solely on site-asserted tool descriptions or annotations for security".
- A tool can lie about what it does. The spec's example is a tool described as finalizing a cart that actually buys.
- Tools with many inputs can pull personal data out of the agent, such as location or purchase history, which the site can log.
So build each tool as if it were a public API endpoint, because in practice it is one:
- Validate everything on the server. The browser tool is a convenience. The server decides what is allowed.
- Ask before anything that costs money or changes data, and show the user exactly what will happen.
- Keep tools narrow.
addToCart(productId, quantity)is a tool.runQuery(sql)is an incident. - Mark read-only tools as read-only, and treat everything else as a write.
These are the same rules we apply to server-side MCP tools. Why, and the attacks behind them.
What a business should do now
- On Shopify: nothing to switch on. Check how your checkout settings decide when agents can complete orders, and watch for reporting on agent-placed orders.
- With your own web app or portal: pick the two or three actions customers repeat most, and prototype them as WebMCP tools behind the origin trial. Measure whether agent-driven sessions convert. Don't depend on it yet: the trial has an end date and the API is still changing.
- For B2B software: WebMCP helps a user who is on your page. For assistants that work in your system without a browser, like Claude or ChatGPT doing a task for a user, you need an MCP server. That is the larger opportunity today, and it works in every major assistant now, not only in a browser trial.
What it costs to get agents using your product
We build MCP servers for business software, and the same tool design (narrow, typed, read and write separated, the user's own permissions) carries straight over to WebMCP. Our prices are fixed and public:
| Price | What you get | |
|---|---|---|
| Starter | $1,900 | One workflow connected to your assistant on your own data, with read and draft tools, in about two weeks. Credited against a production build. |
| Scoping | $2,300 to $4,700 | Which actions to expose, with what permissions and confirmations, and a plan for MCP and WebMCP. |
| Production MCP server | from $17,500 | A first workflow in production on your systems. |
| Running it | from about $470/month | Hosting, monitoring and updates. |
Related: how to build an MCP server, ChatGPT apps for business, AI agent security, and the Personal Agent Protocol, the sign-in standard for customers' agents.