# Web Scraping MCP Server for AI Agents

> One web scraping MCP server exposing search, scrape, crawl, map, batch and SEO tools to Claude, Cursor and any AI agent. Pay per success, $1 free monthly.

[Home](https://quanticdata.io/)/*MCP Server*

# The web scraping MCP server for AI agents

A web scraping MCP server exposes web-data tools to an AI agent over the Model Context Protocol, so the model fetches live pages itself. QuanticData is one MCP server for all of them: search, scrape, crawl, map, batch and seo_audit, routed through residential proxies and billed only on success.

[Get my free API key](https://quanticdata.io/signup/) [Install in one command](/mcp-server/#install)

$1 free every month · No card required · Pay per success

mcp · agent session

```
# the agent picks each tool on its own
tool call · search
  { "query": "best vector db 2026", "engine": "google" }
→ organic[10] · related_questions[4] · ai_overview
tool call · scrape
  { "url": "https://acme.dev/pricing", "format": "markdown" }
→ "# Acme — from $49/mo · usage $0.0002"
tool call · crawl
  { "url": "https://docs.acme.dev", "depth": 2 }
→ job started · 48 pages · poll crawl_status
```

8 tools, one server *search* *scrape* *map* *crawl* *crawl_status* *batch* *batch_status* *seo_audit*

**8 MCP tools**search · scrape · map · crawl · batch · seo_audit

**Every AI client**Claude · Cursor · Windsurf · VS Code · Cline

**Proxies underneath**every call exits a residential IP

**Pay per success**blocks, timeouts & retries are free

On this page [What is an MCP server?](/mcp-server/#what-is-mcp-server) [MCP tools](/mcp-server/#tools) [AI clients](/mcp-server/#clients) [Install](/mcp-server/#install) [Pricing](/mcp-server/#plans) [Comparison](/mcp-server/#compare) [FAQ](/mcp-server/#faq)

## What is an MCP server?

**An MCP server is a program that exposes tools and data to an AI client over the Model Context Protocol — an open standard for connecting models to the outside world.** The server declares each tool with a typed schema; the model reads those schemas and decides when to call one. Connect a server once and the agent gains its capabilities, with no per-framework glue code.

A **web scraping MCP server** puts the open web behind those tools. Instead of guessing about a page it has never seen, the agent calls a tool, gets clean content back, and reasons over it in the same turn. QuanticData's server does that for search, single pages and whole sites — over a residential proxy network, so bot walls stay the server's problem, not the model's.

prompt → tool call → clean content → answer typed schemas the model reads · one API key · residential exits on every call · usage cost in every response

AI Overview

## What is a web scraping MCP server?

**A web scraping MCP server is a Model Context Protocol server that hands an AI agent tools to fetch, search and read live web pages autonomously.** QuanticData exposes eight of them from one server, so a model can run a search, scrape a page, or crawl a whole site mid-conversation — and get back token-efficient Markdown or structured JSON.

- **One server, every tool:** search, scrape, map, crawl, batch and seo_audit — not just single-page fetching.

- **Proxies built in:** every call routes through residential, mobile, datacenter or IPv6 exits with anti-bot handling.

- **LLM-shaped output:** clean Markdown, SerpApi-compatible SERP JSON, and a usage block on every response.

- **Pay per success:** failed calls and internal retries are never billed; $1 of free usage every month, no card.

Jump to [The tools](/mcp-server/#tools)[Install](/mcp-server/#install)[Pricing](/mcp-server/#plans)

## Every web-data tool, one MCP server

Competitors expose scraping alone. QuanticData gives your agent the whole surface — search, scrape, crawl, map, batch and audit — behind eight tools with the real names and parameters from the package. Every one runs over the proxy network beneath it.

### `search`

Google, Bing and DuckDuckGo across 17 verticals — web, images, news, shopping, maps, scholar, jobs, flights, hotels, lens and more. SerpApi-compatible JSON. Key params: `query`, `engine`, `search_type`, `country`, `num`.

### `scrape`

One page to clean Markdown, HTML or text with a real Chrome TLS fingerprint. Run CSS or plain-language extraction inline. Key params: `url`, `format`, `content_mode` (smart/article/full), `engine`, `extract`, `ai_prompt`.

### `map`

Discover a site's URLs fast from robots sitemaps and homepage links — no full crawl. Up to 5,000 URLs plus a site-wide total. Key params: `url`, `limit`, `search` (substring filter), `group_by`.

### `crawl`

Start an async breadth-first crawl from a seed URL, each page converted to Markdown. Depth up to 10, include/exclude globs. Key params: `url`, `limit`, `depth`, `content_mode`, `include`, `exclude`. Returns a job id.

### `crawl_status`

Poll a crawl job for progress and the pages gathered so far, so long crawls never blow the context window. Key param: `jobId`. Unused pages on a finished job are refunded automatically.

### `batch`

Scrape up to 1,000 URLs asynchronously with shared options. Set `mode: "summary"` for metadata-only audits. Key params: `urls`, `format`, `content_mode`, `engine`, `country`. Returns a job id.

### `batch_status`

Poll a batch job incrementally — pass the previous `nextCursor` as `since` to receive only new items. Key params: `jobId`, `since`, `include_content`. Content is omitted by default to stay light.

### `seo_audit`

Fetch a URL twice — as a no-JS bot and fully rendered — and return both views plus the diff and bot-facing meta (robots, Open Graph, JSON-LD). Key params: `url`, `country`, `no_render`.

### MCP for proxies, too — every call exits a residential IP

Each tool call routes through QuanticData's own residential, mobile, datacenter and IPv6 networks, with browser escalation when a target fights back. Add `country` to any call to pin the exit. Want raw transport instead of finished data? The same networks are sold as [plain proxies](https://quanticdata.io/residential-proxies/) under one account.

[See the proxy networks](https://quanticdata.io/#l-connection)

## Works in every AI client and framework

Any MCP-capable client connects natively — **Claude Desktop, Claude Code, Cursor, Windsurf, VS Code and Cline** pick up all eight tools the moment you add the config. Point ChatGPT's connectors at the same server, or wrap the tools in an agent framework: LangChain, LlamaIndex, CrewAI and the OpenAI Agents SDK take a few lines each.

Prefer no code? **n8n and Zapier** call the same REST endpoints from an HTTP node — one JSON envelope throughout, so what you prototype in Claude behaves identically in production. Need just one capability? The [SERP API](https://quanticdata.io/serp-api/) and the [web scraping API](https://quanticdata.io/web-scraping-api/) stand alone, and the [web data API for AI](https://quanticdata.io/web-data-api-for-ai/) covers the full agent surface.

AI clients *Claude Desktop* *Claude Code* *Cursor* *Windsurf* *VS Code* *Cline* *ChatGPT*

Agent frameworks *LangChain* *LlamaIndex* *CrewAI* *OpenAI Agents SDK* *n8n* *Zapier*

Setup

## Add the MCP server in one command

The server is a small local package launched with `npx` — it talks to the hosted API with your key, so there are no internal secrets and nothing to deploy. Set `QUANTUMPROXIES_API_KEY` and restart the client.

```
claude mcp add quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qp_live_your_key_here \
  -- npx -y quantumproxies-mcp

# eight tools appear: search, scrape, map, crawl,
# crawl_status, batch, batch_status, seo_audit
```

```
// claude_desktop_config.json
{
  "mcpServers": {
    "quantumproxies": {
      "command": "npx",
      "args": ["-y", "quantumproxies-mcp"],
      "env": {
        "QUANTUMPROXIES_API_KEY": "qp_live_your_key_here"
      }
    }
  }
}
```

```
// .cursor/mcp.json  (or VS Code / Windsurf mcp.json)
{
  "mcpServers": {
    "quantumproxies": {
      "command": "npx",
      "args": ["-y", "quantumproxies-mcp"],
      "env": {
        "QUANTUMPROXIES_API_KEY": "qp_live_your_key_here"
      }
    }
  }
}
```

Not using MCP? Every tool is also a plain REST endpoint with the same JSON envelope — see the [web data API for AI](https://quanticdata.io/web-data-api-for-ai/) for the REST shape.

Pricing

## Pay-per-success, priced for agents

Agents probe, retry and dead-end by design — so failed tool calls are never billed, and every response tells the agent what it just spent. The server itself is free and open.

**$0.0002**per page scraped*$0.001 with JS rendering*

**$0.0005**per SERP search*$0.002 with JS rendering*

**$0.0003**per crawled page*async, auto-refund on unused*

**$0.0002**per batch URL*up to 1,000 URLs per job*

### Pay as you go

$0/mo

- $1 free credit / month

- 60 requests / min

- List unit prices

### Starter

$19/mo

- $10 free credit / month

- 300 requests / min

- 10% off unit prices

Most popular

### Growth

$79/mo

- $50 free credit / month

- 600 requests / min

- 20% off unit prices

### Scale

$299/mo

- $250 free credit / month

- 1,200 requests / min

- 30% off unit prices

Free & open server packageUsage cost in every responseFailed calls never billedAsync jobs auto-refund failuresOne key for tools and proxies

## QuanticData MCP vs a typical scraping MCP

|  | QuanticData MCP | Typical scraping MCP |
| --- | --- | --- |
| Tools exposed | 8 — search, scrape, map, crawl, batch, seo_audit | 1–3 — single-page fetch |
| Search / SERP | native search tool, 3 engines & 17 verticals | none |
| Whole-site jobs | async crawl, map & batch (up to 1,000 URLs) | one page at a time |
| Proxy network | 4 in-house networks, country targeting | opaque or none |
| Billing | pay per success, failed calls free | credits per call |
| Output | one JSON envelope, SerpApi-compatible SERP | per-tool formats |
| Free tier | $1 every month, renews forever | one-time trial credits |

## FAQ

The short answers on pricing, formats and setup.

[Something else? Ask us →](mailto:hello@quanticdata.io)

### What is an MCP server?

An MCP server is a program that exposes tools and data to an AI client over the Model Context Protocol, an open standard. It declares each tool with a typed schema; the model decides when to call it. Connect one server and the agent gains those capabilities with no glue code.

### What is a web scraping MCP server?

A web scraping MCP server gives an AI agent tools to fetch and read live web pages on its own. QuanticData exposes eight: search, scrape, map, crawl, crawl_status, batch, batch_status and seo_audit, so the model can search, read a page, or crawl a whole site mid-conversation.

### How do I add the MCP server to Claude or Cursor?

Add one mcpServers block with the npx command and your QUANTUMPROXIES_API_KEY: paste it into claude_desktop_config.json for Claude Desktop, or .cursor/mcp.json for Cursor. In Claude Code run a single claude mcp add command. Restart the client and the eight tools appear.

### Which AI clients and frameworks are supported?

Any MCP-capable client connects natively: Claude Desktop, Claude Code, Cursor, Windsurf, VS Code and Cline. Frameworks like LangChain, LlamaIndex, CrewAI and the OpenAI Agents SDK wrap the tools in a few lines, and n8n or Zapier call the same REST endpoints from an HTTP node.

### What tools does the MCP server expose?

Eight, from the real package: search (Google, Bing, DuckDuckGo across 17 verticals), scrape (a page to Markdown, HTML or text), map (fast URL discovery), crawl and crawl_status (async site crawls), batch and batch_status (up to 1,000 URLs), and seo_audit (no-JS versus rendered).

### Is the MCP server free?

The server package is free and open, and every account gets $1 of usage each month with no card, enough for thousands of scrapes or searches. Beyond that you pay per successful call from $0.0002 per page. Blocked pages, captchas and retries are never billed.

### MCP server vs API — what is the difference?

They are two front doors to the same platform. The REST API is called by your backend code; the MCP server lets the AI agent call the same tools itself, with typed schemas the model reads. Prototype through MCP, ship through REST, or use both — one key covers everything.

### Can I self-host the MCP server, or is it hosted?

The MCP server runs locally as a small package you launch with npx, talking to the hosted QuanticData API with your key — no internal secrets and nothing to deploy. The heavy work (browsers, proxy rotation, retries, parsing) happens on our infrastructure, so your machine only carries the transport.

### How is the MCP server billed?

Pay per success: each tool call is charged only when it returns a usable result, and every response carries a usage block with its cost. List prices are $0.0002 per scraped page, $0.0005 per search and $0.0003 per crawled page. Async crawl and batch jobs auto-refund unused pages.

## Give your agent the whole web

$1 free every month, no card. Add the MCP server and let it search, scrape and crawl.

[Get my free API key](https://quanticdata.io/signup/)

Also on the platform: [Web Data API for AI](https://quanticdata.io/web-data-api-for-ai/) [Web Scraping API](https://quanticdata.io/web-scraping-api/) [SERP API](https://quanticdata.io/serp-api/) [Residential Proxies](https://quanticdata.io/residential-proxies/) [For AI agents](https://quanticdata.io/#ai)

---

Source: https://quanticdata.io/mcp-server/ · Site index for AI: https://quanticdata.io/llms.txt