# WebMCP Validator for AI Agent Tools (`rainminer/webmcp-validator`) Actor

Check whether any public URL is ready for AI agents that speak WebMCP. Open the page, capture registered tools, declarative HTML forms, Cloudflare WebMCP packs, and MCP catalogs, then get a 0–100 readiness score with pass, warn, and fail checks. No login. Export JSON, CSV, or Excel.

- **URL**: https://apify.com/rainminer/webmcp-validator.md
- **Developed by:** [rainminer](https://apify.com/rainminer) (community)
- **Categories:** AI, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.48 / 1,000 webmcp validation reports

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

<p align="center">
  <img src="logo.png" alt="MCP logo" width="96" />
</p>

## WebMCP Validator

![WebMCP Validator](./banner.png)

**WebMCP Validator** opens any public URL and reports whether the page is ready for AI agents that speak [WebMCP](https://github.com/webmachinelearning/webmcp). It records tools registered on `document.modelContext`, declarative `toolname` forms, Cloudflare WebMCP packs, and MCP HTTP catalogs, then returns a readiness score with pass / warn / fail checks.

Try it on the public Chrome Labs demo: [WebMCP explainer](https://googlechromelabs.github.io/webmcp-tools/demos/explainer/).

Need a flat catalog instead of a scorecard? Use **[WebMCP Scraper](https://apify.com/rainminer/webmcp-scraper)** for one row per tool, resource, or prompt.

***

### What does WebMCP Validator do?

WebMCP (Web Model Context Protocol) lets a website declare **agent tools** in the page — names, descriptions, and JSON schemas — so an in-browser agent can call `bookSlot` instead of guessing at buttons. Chrome is shipping the API as `document.modelContext`. Cloudflare can inject a same-origin WebMCP pack that registers those tools for you.

This Actor:

1. Opens each start URL in a headless browser
2. Captures `registerTool` calls as the page boots
3. Reads declarative HTML form tools (`toolname`, `tooldescription`)
4. Detects Cloudflare WebMCP packs and advertised MCP catalog URLs
5. Optionally lists tools, resources, and prompts from the site’s MCP HTTP endpoint
6. Scores agent-readiness and lists concrete issues

Run it on Apify to **schedule** audits, **monitor** regressions, and export reports via **API**.

***

### Why validate WebMCP?

Agent traffic is growing, but most sites still only offer a human UI. Use this Actor when you need to know, at scale, whether a URL actually exposes a machine-usable tool surface:

- **Ship-check** a WebMCP implementation before you announce agent support
- **CI / monitoring** for pages that must keep tools registered
- **Competitive audits** of who already exposes agent tools
- **Cloudflare pack QA** after turning on WebMCP in the dashboard
- **Schema review** so tool names and JSON schemas match the spec
- **Migration** from deprecated `navigator.modelContext` to `document.modelContext`
- **Directory ops** that only list sites with a passing readiness score
- **Security review** of which tools a public page advertises
- **MCP catalog health** for advertised MCP HTTP endpoints
- **Agency reporting** for clients adopting agent-ready websites
- **Product research** on WebMCP adoption across a URL list
- **Incident response** when an agent integration suddenly sees zero tools

***

### How to validate WebMCP on a website

1. Open the Actor in [Apify Console](https://console.apify.com/)
2. Paste one or more **page URLs** (homepages or specific app screens)
3. Keep **Probe MCP HTTP catalog** on unless you only want in-page tools
4. Increase **Extra wait time** for slow single-page apps
5. Click **Start** and open the dataset **Overview**

You can also call the Actor from the Apify API, webhooks, or a schedule. Pair it with [WebMCP Scraper](https://apify.com/rainminer/webmcp-scraper) when a failing score should dump the full tool catalog for debugging.

#### Input example

```json
{
  "startUrls": [
    { "url": "https://googlechromelabs.github.io/webmcp-tools/demos/explainer/" }
  ],
  "maxItems": 5,
  "waitUntil": "networkidle",
  "waitForMillis": 4000,
  "probeMcpHttp": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

***

### Output

Each start URL produces one dataset row: readiness (`ready`, `partial`, or `not_detected`), a 0–100 score, tool / resource / prompt counts, and the full check list.

```json
{
  "url": "https://googlechromelabs.github.io/webmcp-tools/demos/explainer/",
  "finalUrl": "https://googlechromelabs.github.io/webmcp-tools/demos/explainer/",
  "pageTitle": "WebMCP — Give agents tools, not DOM",
  "isWebMcpEnabled": true,
  "readiness": "ready",
  "score": 100,
  "summary": "WebMCP looks ready (3 tool source(s) found, score 100).",
  "toolCount": 3,
  "resourceCount": 0,
  "promptCount": 0,
  "cloudflareBridge": false,
  "mcpHttpOk": false,
  "usesDocumentApi": true,
  "usesDeprecatedNavigatorApi": false,
  "checks": [
    {
      "id": "tools-registered",
      "title": "Tools registered",
      "status": "pass",
      "message": "Captured 3 tool(s) via registerTool."
    }
  ],
  "issues": [],
  "warnings": []
}
```

Download the dataset as JSON, CSV, or Excel. The **Overview** tab highlights the score, tool counts, and page image when Open Graph provides one.

***

### How much does it cost?

This Actor uses **pay-per-event** pricing. Platform compute is included in the event price — you are not billed extra Playwright usage.

| Event | FREE plan |
| --- | --- |
| Actor start | $0.00005 |
| Validation report (one per start URL) | **$9.99 / 1,000** ($0.00999 each) |

Paid Apify Store plans get volume discounts (GOLD from **$7.48 / 1,000**). No proxy is required by default. A 20-URL audit is about **$0.20** in event fees on FREE. Check the **Pricing** tab for current rates.

***

### FAQ

#### What is WebMCP?

WebMCP is a W3C Web Machine Learning Community Group API. Pages register tools with `document.modelContext.registerTool()`, each with a name, description, JSON Schema, and an execute handler. Agents discover those tools instead of scraping the DOM. See the [explainer](https://github.com/webmachinelearning/webmcp) and [Cloudflare’s WebMCP preview](https://blog.cloudflare.com/webmcp/).

#### Does the target site need the latest Chrome?

No. The Actor captures tool registration even when the crawler browser has no native WebMCP surface, so you can audit sites that already call `document.modelContext`.

#### Will it log in?

No. Only public pages. Cookie banners and bot challenges are fine; account login is not supported.

#### Does it execute tools?

No. It only **detects and scores** registered tools. It does not call execute handlers or MCP `tools/call`.

#### Related Actors

| Actor | Job |
| --- | --- |
| **[WebMCP Scraper](https://apify.com/rainminer/webmcp-scraper)** | One dataset row per tool, resource, or prompt |
| **[WebMCP Validator](https://apify.com/rainminer/webmcp-validator)** | Per-URL readiness score and spec checks (this Actor) |

Open an issue on the Actor page if a public demo URL stops scoring. Feature requests for extra checks are welcome.

***

### Image Credit

Logo and banner use the official [Model Context Protocol](https://modelcontextprotocol.io) mark from the [MCP docs logo](https://github.com/modelcontextprotocol/docs/tree/main/logo).

# Actor input Schema

## `startUrls` (type: `array`):

Page URLs to open and validate for WebMCP tools, declarative forms, Cloudflare packs, and MCP catalogs.

## `maxItems` (type: `integer`):

Maximum validation reports to store for each start URL. Use 1 unless you retry the same URL.

## `waitUntil` (type: `string`):

Navigation lifecycle event to wait for before the extra wait time starts.

## `waitForMillis` (type: `integer`):

Additional time to wait after navigation so late registerTool calls and Cloudflare packs can finish.

## `probeMcpHttp` (type: `boolean`):

When enabled, also initialize any advertised MCP HTTP endpoint and list tools, resources, and prompts.

## `proxyConfiguration` (type: `object`):

Optional proxy. Leave Apify Proxy off unless the target site blocks datacenter IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://googlechromelabs.github.io/webmcp-tools/demos/explainer/"
    }
  ],
  "maxItems": 5,
  "waitUntil": "networkidle",
  "waitForMillis": 4000,
  "probeMcpHttp": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://googlechromelabs.github.io/webmcp-tools/demos/explainer/"
        }
    ],
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("rainminer/webmcp-validator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://googlechromelabs.github.io/webmcp-tools/demos/explainer/" }],
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("rainminer/webmcp-validator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://googlechromelabs.github.io/webmcp-tools/demos/explainer/"
    }
  ],
  "maxItems": 5
}' |
apify call rainminer/webmcp-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rainminer/webmcp-validator"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/fkLXRqQTOJBcCqT63/builds/5YsfaVQo712PqPmJ4/openapi.json