WebMCP

WebMCP

Open-source JavaScript library that exposes any webpage to MCP agents with one script tag.

65/100MonitorFreeFree

WebMCP is the cheapest honest test of whether an agent can actually use your site: one script tag, a few `registerTool` and `registerResource` calls, and you're live against a real MCP client in an afternoon. The sampling modal is the part to show a nervous stakeholder — every LLM round-trip the page initiates gets human approval before the answer goes back. Don't mistake it for a production endpoint, though. Visitors bring their own client (documented via Claude Desktop), tool changes often need a restart, and the only auth is a pasted token. If you need commerce-grade authorization, look at building a hosted MCP server instead; if you want to know whether the idea is worth it, start here.

Verified 20h ago · liveness 65/100 · cite: rightaichoice.com/tools/webmcp

Best for
  • Web developers who want to expose site capabilities to AI agents without standing up a server
  • Docs, portfolio and content sites testing whether agents can read and act on their pages
  • Prototypers evaluating the Model Context Protocol against a real MCP client like Claude Desktop
  • Teams running an afternoon experiment before committing engineering time to agent support
Not ideal for
  • Teams needing production-grade authorization for payments, orders or regulated data
  • Non-developers without an MCP client installed and configured
  • Sites with strict script policies that won't add a third-party runtime to the page
Visit Website

IntermediateUnder an hour for a developer who already has an MCP client: paste the script tag, register a tool or resource, then have the visitor add the npx server to Claude Desktop's config and paste a token. Budget an extra restart of the client the first time tools don't appear, and more time if you want prompts and resources wired up as well as tools.WebAPI availableVerified 20h ago
Pricing
Free
FreeFree tier
Learning curve
Intermediate
Under an hour for a developer who already has an MCP client: paste the script tag, register a tool or resource, then have the visitor add the npx server to Claude Desktop's config and paste a token. Budget an extra restart of the client the first time tools don't appear, and more time if you want prompts and resources wired up as well as tools.
Runs on
Web
API available · 1 integrations
Who it's for
Docs-site maintainerFrontend prototyperHardware tinkerer
Live sentiment
Is WebMCP actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip WebMCP if you need authenticated, stateful commerce or regulated-data flows, or if a client restart any time your tool set changes is a dealbreaker.

The 30-second take
Price reality

WebMCP's pricing fits teams whose volume aligns with the published tiers. Compare against the alternatives listed below for stage-specific value.

In short

WebMCP — Open-source JavaScript library that exposes any webpage to MCP agents with one script tag. Best for Web developers who want to expose site capabilities to AI agents without standing up a server, Docs, portfolio and content sites testing whether agents can read and act on their pages, Prototypers evaluating the Model Context Protocol against a real MCP client like Claude Desktop. Free to use.

What people actually say about WebMCP — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

8 mentions across 5 sources (Hacker News, YouTube, Product Hunt, GitHub, Lemmy), 64 more we could not attribute · researched Sep 24, 2026.

74% positive26% critical

Weighted by the 72 posts each of 5 sources contributed.

Recurring strengths
  • +One script tag turns any page into an MCP server with no backend or transport code
  • +Community consensus calls it simpler and more useful than full MCP for web apps
  • +Works with any MCP client, including Claude Desktop, via a pasted token
  • +Supports the full MCP surface: tools, prompts, resources, and sampling
  • +Backed by both Google and Microsoft, and already shipped in Chrome early preview
Recurring frustrations
  • −Open GitHub issue reports auth tokens expire immediately after a single call
  • −Not battle-tested; docs themselves position it for demos rather than production traffic
  • −Docs recommend registering tools immediately, creating friction for dynamic single-page apps
  • −Community questions whether it beats Claude Code search or Playwright for browser automation
  • −Early access invites from Google have reportedly been slow to arrive
Patterns worth knowing
WebMCP is a simpler, more useful alternative to full MCP for web apps
Seen on Hacker News
Exposing semantic tools beats agents screenshotting and clicking through the UI
Seen on Hacker News, Lemmy
Backing from Google and Microsoft makes the standard credible despite early-stage chaos
Seen on Product Hunt, Hacker News
Learning curve
intermediateProductive in ~5 minutes
Hidden costs people mention
  • • No license cost, but the real cost is engineering time spent working around unresolved token expiry and missing Docker packaging
  • • Production hardening, custom auth, and audit layers are on you since the project is early-stage

Viability Score

65/100
Monitor

How well maintained and how widely used is WebMCP? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
90
Traction
100
Site health
95
User sentiment
68
What the vendor publishes
0

Last calculated: October 2026

How we score →

Key Features

  • Add an MCP server to any website with a single webmcp.js script tag
  • No backend or transport code — the page itself is the server
  • registerTool defines callable actions with a JSON schema for arguments
  • Example weather tool returns data for a supplied location
  • registerPrompt ships reusable prompt templates with required arguments
  • Git commit message prompt template that accepts a diff as a required argument
  • Code Explanation and Text Summarization prompt templates included
  • registerResource exposes page content or DOM elements by URI
  • registerResourceTemplate supports dynamic URIs such as element://{elementId}
  • Sampling requests LLM completions through the client via a user-approval modal
  • Blue corner widget shows connection state and accepts a pasted MCP token
  • Customize widget color, position, size and padding via constructor options
  • Works with any MCP client; setup documented for Claude Desktop
  • Connection flow: generate a webmcp token in your client, paste it into the widget
  • Dynamic tool registration after page load (client restart often required)

About WebMCP

FreeIntermediateAPI availableWeb

WebMCP is an open-source JavaScript library that lets any website act as a Model Context Protocol server. You add `<script src="webmcp.js"></script>` to your page, and a small blue widget initializes in the bottom-right corner. A visitor configures an MCP client — the documented path is Claude Desktop's Settings > Developer > Edit Config, adding an npx-launched `@jason.today/webmcp` server — asks the client for a webmcp token, and pastes that token into the widget. From then on the client can call whatever capabilities you declared in the page. There is no backend and no transport layer to build. The developer API maps to the four core MCP primitives: `registerTool` defines callable actions with a JSON schema (the site's own example registers a weather tool returning "Sunny, 22°C" for a supplied location), `registerPrompt` ships reusable templates with required arguments (a git-commit generator taking a diff, plus Code Explanation and Text Summarization examples), `registerResource` and `registerResourceTemplate` expose page content or specific DOM elements by URI, including dynamic templates like `element://{elementId}`, and sampling requests an LLM completion through the client via a modal the human types into and approves. Setup stays thin: include the script, optionally pass constructor options for color, position, size and padding, then register your capabilities — ideally right after load, since most MCP clients only pick up tool changes on restart. It suits developers testing whether agent traffic is worth chasing before spending real engineering time. Sites federate rather than converging on one client, community work keeps arriving (a serverless reverse-geocoding endpoint with ESP32 and RP2040 clients, a Hide and Seek demo against a self-improving agent), and in August 2026 OpenAI ran a WebMCP Challenge inviting developers to build agent-facing site integrations.

Behind the Verdict

The interesting thing about WebMCP is where it puts the server. Instead of you standing up an endpoint, the page you already ship *is* the endpoint: `webmcp.js` initializes a widget, and the four MCP primitives are registered in ordinary browser JavaScript. `registerTool('weather', ..., { location: { type: "string" } }, fn)` is the whole ceremony for a callable action. `registerResource` with `page://current` hands the client `document.body.innerHTML` as context; `registerResourceTemplate` with `element://{elementId}` lets an agent ask for one DOM node by ID, which is a neat way to give an agent narrow, deliberate context rather than the whole page. Prompts are the underrated piece — `registerPrompt('git-commit', ...)` with a required `changes` argument means you can standardise how a client phrases common requests across your site. Sampling is the design choice I'd defend hardest. When the server wants a completion, WebMCP opens a modal and the human types the response; the documented example asks for DuckDB SQL. That is a genuine safety story for anyone worried about autonomous agents, and it is built into the library rather than bolted on. Where it gets thin: the visitor must arrive with a configured MCP client and generate a token inside it, and the docs themselves tell you to restart the client if tools don't appear — so registering tools immediately after script load is guidance, not a nicety. Registration is JavaScript-only and in-page, so sites with strict script policies are out, and there's no persistent state and no authentication beyond the pasted token, which puts payments, orders and regulated data firmly out of scope. Site-by-site federation also means no turnkey cross-site view of what agents did. Where it fits: docs sites, portfolios, personal blogs, and prototypes where a developer wants to see an agent read a page and call a real action without committing engineering time. The surrounding ecosystem backs that up — a serverless reverse-geocoding endpoint with ESP32 and RP2040 clients shows the library reaching beyond browsers into low-power hardware, the Hide and Seek demo shows an agent actually playing against a page, and OpenAI's August 2026 WebMCP Challenge gave the approach a public build push. Where it doesn't: anything you'd have to defend in an audit, and anything that needs tool changes to propagate live without a client restart.

Researching WebMCP? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas WebMCP actually fits — and what changes day-one when you adopt it.

Docs-site maintainer

You add webmcp.js, register a `page-content` resource (`page://current`) and an `element://{elementId}` template so an agent can pull just the section it needs instead of the whole DOM.

Outcome: A Claude Desktop user generates a token, pastes it into the blue widget, and the agent answers questions from real page content in the same session.

Frontend prototyper

You register a `weather` tool with a `location` string schema and a `git-commit` prompt that requires a `changes` diff, right after the script loads.

Outcome: The client sees both capabilities after a restart, and you've validated whether agent traffic to your page is worth further engineering the same afternoon.

Hardware tinkerer

You point an ESP32 or RP2040 client at a serverless reverse-geocoding endpoint published for WebMCP rather than driving a browser from the outside.

Outcome: A low-power device participates in the same tool-calling pattern the browser library uses, without you building a bespoke transport.

Use Cases

Limitations

  • Every visitor needs a compatible MCP client configured manually — the documented path is adding an npx-launched `@jason.today/webmcp` server to Claude Desktop's config.
  • Tool changes may need a client restart before they appear, so the docs recommend registering everything immediately after the script loads.
  • The library is JavaScript-only and runs in the page, which rules out sites with strict script policies.
  • There is no persistent state and no authentication beyond a token the visitor pastes into the widget, so payments, orders and regulated data are out of scope.
  • Each site federates on its own, so there is no turnkey cross-site analytics view.

as of 2026-10-18

Verification history

We have re-verified WebMCP 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. — re-checked, vendor evidence unchanged
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it

Showing the 6 most recent of 9 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly
—
—

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published WebMCP tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Open Source (MIT)

$0

Ideal for

Developers and small site owners who want to test agent access to their pages before committing engineering time

What this tier adds

Free entry point: the full library under the MIT license, covering registerTool, registerPrompt, registerResource and registerResourceTemplate with no backend to run

Where the pricing makes sense

The company stage and team size where WebMCP's pricing actually pencils out — and where peers do it cheaper.

WebMCP's pricing fits teams whose volume aligns with the published tiers. Compare against the alternatives listed below for stage-specific value.

Setup time & first value

How long it actually takes to get something useful out of WebMCP — broken out by persona, not the marketing-page minute.

Under an hour for a developer who already has an MCP client: paste the script tag, register a tool or resource, then have the visitor add the npx server to Claude Desktop's config and paste a token. Budget an extra restart of the client the first time tools don't appear, and more time if you want prompts and resources wired up as well as tools.

Switching to or from WebMCP

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • →From a handwritten/hosted MCP server: re-express your tools as `registerTool` calls with JSON schemas, and your context endpoints as `registerResource`/`registerResourceTemplate` URIs, then drop the backend.
  • →From no agent support at all: add the script tag, register one tool after load, and test with a token from Claude Desktop before investing further.
Migrating out
  • ↗To a hosted MCP server: move each registered tool's handler server-side and replace the pasted-token flow with real authentication when you need payments or regulated data.
  • ↗To a browser-driving setup (Playwright/Puppeteer): use declared tools as the reference for what the agent should be able to do once you own the browser from the outside.

Integrations

Claude Desktop

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “WebMCP”, and we withheld 6: 6 could not be judged, because “WebMCP” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about WebMCP.

Official links

Featured Head-to-Head Comparisons

Popular in MCP Servers & Agent Tooling

Smithery

Smithery

Smithery is an MCP server marketplace and connection layer that handles OAuth, credentials, and session state for your AI agent.

FreemiumTry
Arcade AI

Arcade AI

Arcade AI is the MCP authorization runtime that enforces per-user permissions and logs every action your AI agents take.

FreemiumTry
Chrome DevTools MCP

Chrome DevTools MCP

Open-source MCP server that gives coding agents live Chrome DevTools for debugging, traces, and browser automation.

FreeTry

Frequently Asked Questions

Used WebMCP? Help shape our editorial sentiment research.