By capability · Web scraping MCP server
Web scraping MCP server: wire a web scraper MCP tool into Claude, Cursor and Codex
The short answer
A web scraping MCP server exposes crawl and extract tools over the Model Context Protocol so an AI client such as Claude Desktop, Claude Code, Cursor or Codex can fetch a page itself instead of you writing the fetch code. Four are worth knowing in September 2026: Firecrawl, Bright Data Web MCP, Apify and Microsoft Playwright MCP. ClawEngine does not publish an official MCP server, and we would rather tell you that than pretend otherwise. What we hand you instead is a crawl API and roughly forty lines of Python that turn it into a server you own, which matters more than it sounds: once the model decides how many tool calls to make, the meter is no longer under your control, and the servers with the richest tool menus are the ones that bill hardest. Plans start at $39 a month for about 50,000 pages, at the same per-page rate whether the output is markdown or schema-typed JSON.
Clean markdown & JSON · JavaScript rendered · robots.txt respected
Last updated September 2026
Hit Extract to turn this page into clean, LLM-ready data.
robots.txt respected · public data only
The Model Context Protocol is a wire format, not a product. A server is a small process that advertises a list of tools, receives JSON-RPC calls from a client, and returns text. That is the whole idea, and it is why standing one up over an HTTP API you already pay for takes an afternoon rather than a sprint.
What changes when you move scraping behind MCP is who decides how much work happens. In a script, you choose the URLs and you know the bill before you run it. In an agent loop, the model chooses: it may map a site, scrape nine pages, decide the answer is thin, and scrape forty more. Every one of those is a metered call. The vendors that ship the biggest tool menus have quietly made this the interesting question, because their most capable tools are also the ones an agent reaches for by default and the ones that cost several times a plain fetch.
So this page does two things. It compares what the four real scraping MCP servers actually give you and charge, with the figures read off each vendor's own documentation in September 2026 rather than off a roundup. Then it shows the forty lines that put a crawl tool in front of your agent using the ClawEngine API, with a hard page cap in the tool signature so the model cannot spend more than you decided it could.
Any URL in LLM-ready data out
robots.txt respected public data only
Why it works
Why a thin server you own beats a rich one you rent
The ceiling lives in your code
A hosted server hands the model a menu and a credit balance. A server you wrote hands it one tool with a hard page limit baked into the signature, so an agent that decides to crawl the whole domain simply cannot.
One rate, markdown or JSON
ClawEngine charges per page, not per output format. Asking for schema-typed JSON instead of markdown does not multiply the line item, which is where per-credit pricing quietly gets expensive on typed extraction.
Tools you can actually read
Two tools with clear names and tight docstrings beat fifteen with overlapping purposes. The model picks better, the token cost of the tool list stays small, and you can reason about what a run will cost.
What it handles
Any URL in, clean structured data out
Point ClawEngine at a public page and it crawls, renders the JavaScript and extracts clean markdown or typed JSON in one call. Define a schema for structured fields, and respect robots.txt and Terms of Service by default.
- Crawl and extract behind two clean MCP tools
- Hard page ceilings enforced in your own code
- Clean markdown, so tool output stays token-cheap
- Schema-typed JSON at the same page rate
- JavaScript rendered before extraction
- stdio locally, Streamable HTTP when you host it
{
"url": "https://example.com/products/atlas",
"title": "Atlas Field Notebook",
"markdown": "# Atlas Field Notebook\n\nDurable...",
"data": {
"name": "Atlas Field Notebook",
"price": 24.00,
"currency": "USD",
"rating": 4.7
},
"links": [ "/products", "/cart" ],
"metadata": { "rendered": true }
}
Head to head
Every real web scraping MCP server, and what a page costs on each
Read from each vendor documentation in September 2026. Rates are list price, converted to a common cost per 1,000 pages where the vendor publishes enough to do it honestly.
Swipe to compare all columns →
| What you are comparing | Firecrawl MCP | Bright Data Web MCP | Apify MCP | Playwright MCP | ClawEngine (roll your own) |
|---|---|---|---|---|---|
| What it really is | Hosted server over the Firecrawl crawl API | Hosted server over the Bright Data unblocking and dataset network | Hosted server over the Apify Actor marketplace | Open-source browser driver, Apache 2.0 | Forty lines you write over a crawl API |
| How you connect | Remote URL at mcp.firecrawl.dev/v2/mcp, or self-hosted | Remote endpoint, or local with PRO_MODE for the full menu | mcp.apify.com over OAuth, or npx actors-mcp-server locally | npx @playwright/mcp@latest | Your own process, stdio or Streamable HTTP |
| Tools exposed | About fifteen: scrape, crawl, map, search, parse, interact, agent, monitor, research | Two in the free Rapid mode, 69 in Pro mode | Actor search and call, docs search, storage, RAG Web Browser | Dozens of browser actions: click, type, tabs, network, storage, PDF | Exactly the ones you define, and no more |
| Free tier | 1,000 credits a month | 5,000 requests a month, no card | Apify free account credit | Free forever, you supply the machine | No free plan, live console is free to try |
| Entry paid price | Hobby $16 for 5,000 credits | $1.50 per 1,000 requests pay as you go | Apify plan pricing, per Actor on top | None | Hobby $39 for about 50,000 pages |
| Plain page fetched | 1 credit, about $0.83 per 1,000 on Standard | About $1.50 per 1,000, or $1.30 on the $499 Scale plan | Depends on the Actor you call | Your own compute and proxies | About $0.78 per 1,000, falling to $0.27 on Scale |
| Page typed to a schema | 5 credits, about $4.15 per 1,000 on Standard | Structured data tools available in Pro mode | Depends on the Actor you call | Not a feature, you parse it yourself | Same page rate, schema extraction from Startup up |
| Recursive site crawl | Yes, crawl plus crawl-status tools | Yes, through the wider platform | Yes, through crawler Actors | No crawl concept at all | Yes, one crawl call with a page limit |
| Clicks, forms, logged-in flows | Yes, interact at 2 to 7 credits a browser minute | Yes, stealth browsers at $8 per GB, $6 on Scale | Yes, through browser Actors | Yes, this is the whole point of it | No, we do not do browser automation or logins |
| Anti-bot defeat | Partial | Strongest in this table, it is the core business | Varies by Actor | None, you are driving a real browser | None, we do not defeat anti-bot systems |
| Who decides the spend | The model, across fifteen differently priced tools | The model, across up to 69 tools | The model, across the Actor Store | You, it is your hardware | You, the ceiling lives in your tool signature |
| Best for | Teams who want the deepest menu and will watch the bill | Agents that must reach defended or social sources | Teams already on Apify Actors | Agents that act on pages rather than read them | Predictable cost per page on large, ordinary crawls |
Firecrawl figures are from its billing documentation and pricing page, Bright Data from its MCP pricing page, Apify from its platform MCP integration docs, and Playwright MCP from the microsoft/playwright-mcp README. Firecrawl per-1,000 rates are derived from the $83 Standard plan at 100,000 credits on annual billing. Apify is deliberately left unpriced per page because the cost depends entirely on which Actor the agent calls, and quoting a single number would be inventing one.
Why ClawEngine
One API that crawls, renders and extracts
Not a raw HTML dump, not a headless browser fleet to run, and not a brittle parser to maintain. One call crawls a public page, renders its JavaScript and returns clean markdown or typed JSON, built for RAG pipelines and AI agents.
LLM-ready output
Clean markdown or typed JSON with the boilerplate stripped, so the data drops straight into a vector store, a prompt or an agent without a cleanup step.
JavaScript rendered
Each page loads in a real browser environment before extraction, so single-page apps and client-rendered content come back complete, not as an empty shell.
Compliance-first
ClawEngine works on public, permitted data only. It respects robots.txt and site Terms of Service and honors crawl-delay, so responsible scraping is the default.
Code examples
A working web scraping MCP server in about forty lines
Two tools, both capped. The extract tool reads one page; the crawl tool walks a site but clamps the page limit in code so the model cannot raise it. Point Claude Desktop, Claude Code, Cursor or Codex at the file and the tools appear in the menu.
import os
import httpx2
from mcp.server import MCPServer
mcp = MCPServer("clawengine")
BASE = "https://api.clawengine.ai/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['CLAWENGINE_API_KEY']}"}
MAX_PAGES = 25 # the ceiling the model cannot argue with
@mcp.tool()
async def extract_page(url: str) -> str:
"""Fetch one public web page and return it as clean markdown.
Args:
url: The full https URL of a single page.
"""
async with httpx2.AsyncClient(timeout=60) as client:
r = await client.post(
f"{BASE}/extract",
headers=HEADERS,
json={"url": url, "format": "markdown"},
)
r.raise_for_status()
return r.json()["markdown"]
@mcp.tool()
async def crawl_site(url: str, limit: int = 10) -> str:
"""Crawl a site section and return each page as markdown.
Args:
url: The starting page.
limit: How many pages to fetch. Clamped to 25.
"""
async with httpx2.AsyncClient(timeout=300) as client:
r = await client.post(
f"{BASE}/crawl",
headers=HEADERS,
json={"url": url, "limit": min(limit, MAX_PAGES), "format": "markdown"},
)
r.raise_for_status()
return r.json()["id"]
if __name__ == "__main__":
mcp.run(transport="stdio")
{
"mcpServers": {
"clawengine": {
"command": "uv",
"args": [
"--directory",
"/ABSOLUTE/PATH/TO/clawengine-mcp",
"run",
"clawengine_mcp.py"
],
"env": {
"CLAWENGINE_API_KEY": "your-key"
}
}
}
}
# Big jobs do not belong in a tool call. Start the crawl from your own
# code, poll it to completion, and hand the agent a finished corpus.
import os, time, requests
headers = {"Authorization": f"Bearer {os.environ['CLAWENGINE_API_KEY']}"}
job = requests.post("https://api.clawengine.ai/v1/crawl", headers=headers, json={
"url": "https://example.com/docs",
"limit": 500,
"format": "markdown",
}).json()
while True:
status = requests.get(
f"https://api.clawengine.ai/v1/crawl/{job['id']}", headers=headers
).json()
if status["status"] == "completed":
break
time.sleep(5)
pages = status["pages"]
print(f"{len(pages)} pages, one metered fetch each, zero tool calls burned")
People also ask
Web scraping MCP server: the questions buyers ask
What is a web scraping MCP server?
It is a small server that advertises scraping tools over the Model Context Protocol so an AI client can call them during a conversation. The client sends a JSON-RPC request naming a tool and its arguments, the server fetches the page and returns text, and the model reads the result as context. The protocol handles the plumbing; the fetching is still an ordinary HTTP API call underneath.
What is the best MCP server for web scraping?
It depends on which job you are buying. Firecrawl has the deepest tool menu and the cleanest hosted setup. Bright Data has by far the most generous free tier at 5,000 requests a month. Playwright MCP is free and the right answer when you need clicks and form fills rather than reading. If you want a stable cost per page across a large crawl and full control of the tool surface, run your own thin server over a crawl API.
How do I add a web scraping MCP server to Claude Desktop?
Edit the mcpServers block in your Claude Desktop configuration file, give the server a name, and set command and args to whatever launches it. For a local Python server that is usually uv with a directory and a script name; for a hosted one it is an npx package or a remote URL with a bearer token. Restart Claude Desktop and the tools appear in the tool menu.
Does ClawEngine have an MCP server?
Not an official one, and we will not imply otherwise. The ClawEngine API is three endpoints, and the code sample further down this page wraps two of them in a working MCP server in about forty lines using the official Python SDK. You own that file, so you decide which tools exist, what the page ceiling is, and what the model is allowed to see, which is the part most hosted servers take away from you.
How much does an MCP scrape cost per page?
Read the credit table, not the plan price. On Firecrawl a plain page is 1 credit, so about $0.83 per 1,000 pages on the $83 Standard plan, but adding the JSON format for typed extraction costs 4 more credits and takes the same page to roughly $4.15 per 1,000. Bright Data Web MCP is $1.50 per 1,000 requests pay as you go. ClawEngine is $0.78 per 1,000 on Hobby, $0.40 on Startup and about $0.27 on Scale, and typed output does not change the number.
What transports does MCP support?
Two standard bindings as of the 2026-07-28 specification: stdio, which is newline-delimited JSON-RPC over the standard streams of a subprocess the client launches, and Streamable HTTP, where each message is an HTTP POST to a single endpoint and replies come back as JSON or a request-scoped SSE stream. Standalone SSE is no longer listed as a standard transport. Local servers use stdio; hosted ones use Streamable HTTP.
Is MCP always the right way to give an agent web access?
No, and the Playwright MCP maintainers say so in their own README: for high-throughput coding agents they recommend the Playwright CLI with skills instead, because MCP tool output such as verbose accessibility trees burns tokens. The same logic applies to scraping. If your agent needs 500 pages, do not let it request them one tool call at a time; run the crawl outside the loop and hand it the finished corpus.
Can an MCP server scrape a whole website?
Some can and some deliberately cannot. Firecrawl exposes crawl and crawl-status tools, so an agent can start a recursive job and poll it. Playwright MCP has no crawl concept at all, only browser actions on the page in front of it. Before you pick a server, check whether recursive crawling is in the tool list, because retrofitting it by having a model click through links is slow, expensive and unreliable.
Good questions
Questions about Web scraping MCP server
Explore more
More ways to turn the web into data with ClawEngine
JavaScript rendering API
Crawl and render JavaScript websites through one API, fully built pages back.
Learn moreAI web crawler and AI website crawler
Turn any public page into clean, LLM-ready markdown or JSON in one call.
Learn moreLLM web scraper
Scrape any public site straight into LLM-ready content, with no cleaning stage.
Learn moreStop wrangling raw HTML. Get LLM-ready data.
Point ClawEngine at a public page and one call crawls, renders the JavaScript and extracts clean markdown or typed JSON, ready for your RAG pipeline or AI agent. Public, permitted data only.
Crawl · render JS · extract markdown & JSON · robots.txt respected, public data only