ClawEngine.ai

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

Live Extraction
POST
try:

Hit Extract to turn this page into clean, LLM-ready data.

robots.txt respected · public data only

Markdown · JSON · structured fields, from one API call. Crawling, rendering and extracting ...

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.

CRAWL RENDER JS EXTRACT MARKDOWN JSON

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
POST /v1/extract extraction result
200 · JSON
{
  "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 }
}
JS rendered · boilerplate stripped ✓ robots.txt respected

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.

python clawengine_mcp.py
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")
json Register it with your AI client
{
  "mcpServers": {
    "clawengine": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/TO/clawengine-mcp",
        "run",
        "clawengine_mcp.py"
      ],
      "env": {
        "CLAWENGINE_API_KEY": "your-key"
      }
    }
  }
}
python Collect the crawl outside the agent loop
# 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

Because the tool surface is a cost control, and a hosted server owns it. When the menu has fifteen entries and four price points, the model is making budget decisions on your behalf every turn. A file you wrote has the tools you chose, the limits you set and the arguments you allow. It is also about forty lines, which is less work than reading the billing docs you would otherwise need to understand.
The official ones. In Python the package is mcp, and the current server class is MCPServer from mcp.server, decorated tools and mcp.run with a transport argument. Plenty of tutorials still show the older FastMCP entry point, so check the import against the current docs before you copy code. The TypeScript equivalent is the modelcontextprotocol SDK package on npm.
Usually not without a cap. Crawling is the one scraping operation whose cost is unbounded by nature, so if you expose it, expose it with a limit argument that your code clamps rather than trusting the model to pass a sensible number. A good default is a low double-digit page ceiling for interactive use, with the big jobs run outside the agent loop entirely.
We do not defeat anti-bot systems, log into accounts, fill forms or drive a browser, and we do not scrape anything behind a paywall. If your target needs any of that, Bright Data and Playwright MCP are in the table above for a reason and you should use them. ClawEngine crawls public, permitted pages, reads robots.txt and honors crawl-delay.
The specification is versioned and it does move. The current revision is 2026-07-28, which standardizes on stdio and Streamable HTTP and drops the connection-scoped initialize session that earlier revisions used, with a documented compatibility path for older counterparts. Pin your SDK version, and expect to reread the transports page once or twice a year rather than never.
Yes. Every one of those clients reads the same mcpServers configuration shape, so a stdio server that works in one works in all of them with the path changed. That portability is the actual value of the protocol: you write the tool once and every AI client on your machine can call it.

Explore more

More ways to turn the web into data with ClawEngine

Stop 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.

See pricing

Crawl · render JS · extract markdown & JSON · robots.txt respected, public data only