mcpField
Q
QuanticData — Web Scraping MCP Server

QuanticData — Web Scraping MCP Server

VerifiedFeaturedRemote
quanticdata.ioSearch0Updated 4w ago

About QuanticData — Web Scraping MCP Server

QuanticData MCP Server gives AI agents tools for web scraping, search, site discovery, and data collection. It is suited to web research and structured extraction, and can run locally or connect as a hosted remote service through the QuanticData API.

Key features

  1. 01Scrape pages to Markdown, HTML, or text
  2. 02Search Google, Bing, and DuckDuckGo
  3. 03Discover site URLs and crawl asynchronously
  4. 04Use 74 ready-made collectors and create datasets
  5. 05Manage proxies and geographic settings

Use cases

  1. 01Find and organize web sources for AI workflows
  2. 02Crawl documentation sites and summarize pages
  3. 03Collect map, product, or company information
  4. 04Generate and configure proxies for requests

MCP support

Exposes tools for scraping, search, crawling, data collection, and proxy management to MCP clients. It connects through a local process or a hosted Streamable HTTP remote service.

Configuration

Remote servers need no local install. Pick your client, then copy the config or install in one click.

Endpointhttps://api.quanticdata.io/mcp
Copy install command
Claude CodeTerminal
Cursor.cursor/mcp.json
VS Code.vscode/mcp.json
Claude Desktopclaude_desktop_config.json
Windsurf~/.codeium/windsurf/mcp_config.json

Run commands in a terminal; paste JSON into the client’s MCP config and restart. Servers that need sign-in will prompt on first connect.

All endpoints
Streamable HTTPhttps://api.quanticdata.io/mcpAuth required
Packages
npmquanticdata-mcp0.11.4
mcpbquanticdata-0.11.4.mcpb

Tools

28
ParameterTypeRequiredDescription
urlstringNoThe page URL to scrape (optional only when you pass `html` to convert)
formatenumNoOutput format (default markdown)markdown | html | text
formatsarrayNoAdditional formats to return together in payload.formats, e.g. ['markdown','text']
include_linksbooleanNoReturn all de-duplicated absolute page links in payload.links
content_modeenumNosmart (default): whole page minus nav/footer/cookie chrome. article: Readability main article only (news/blogs). full: entire body as-is.smart | article | full
engineenumNoauto (default): plain HTTP first, headless browser when the page needs JavaScript or the HTTP request is refused. tls: plain HTTP only, never a browser — what a crawler without JavaScript sees, right for SEO checks. render: always use the browser.auto | tls | fetch | render
renderbooleanNoForce the headless browser (JS execution)
modeenumNosummary: return only metadata (title, description, canonical, contentLength, status, engine, bytes) with no page content — use this when auditing pages instead of reading themsummary
countrystringNoISO country code for the proxy exit, e.g. 'us'
ai_promptstringNoNatural-language instruction — the LLM turns the page into structured JSON
ai_schemaobjectNoJSON Schema for deterministic AI extraction; returned under payload.ai.data
extractobjectNoStructured-extraction schema: { field: "css selector" | { selector, attr, all, fns } }. `fns` is a transform pipeline run on the value — e.g. { "price": { "selector": ".price", "fns": ["amount_from_string"] } } returns a number, not text. Functions: amount_from_string, amount_range_from_string, convert_to_float/int/str, trim, lower, upper, {regex_search|regex_find_all: "pat"}, {replace:{from,to}}, {join:","}, {select_nth:0}, length, unique, max, min, average, product.
app_stateanyNoMine the page's own hydration state (Next.js __NEXT_DATA__, Nuxt, embedded JSON islands) into payload.metadata.appState. This is where SPAs keep the real data — prices behind a picker, stock, download counts, listings — even when the DOM shows only a shell, so it often answers the question without a browser render. true/'auto': pruned to the informative parts (recommended). 'raw': the complete blobs, up to 512KB.
parserobjectNoYour own parsing rules, as CSS selector lists — use these when you know the page and don't want to rely on heuristics. include: keep ONLY these subtrees (targeted extraction, e.g. ['article.post']). exclude: delete site-specific chrome we kept. keep: protect a section (sidebar, dialog, form) that smart mode would strip.
parser.includearrayNo
parser.excludearrayNo
parser.keeparrayNo
reveal_hiddenbooleanNoRender tier only: before capturing, open <details>/accordions and click through every tab, appending each revealed panel to the page. Use it for tabbed code samples or spec accordions where a plain render captures only the visible variant.
xhrbooleanNoRecord the page's XHR/fetch traffic (URL, method, status, response body) into payload.xhr. Forces a browser render. An SPA's own JSON API is usually far cleaner than its DOM — use this to DISCOVER the API, then fetch_resource to return it directly.
fetch_resourcestringNoRegex matched against the page's network requests: the first matching response's BODY becomes the result instead of the page HTML (e.g. '/api/products' to get an SPA's JSON directly). Forces a render. Fails with 504 if nothing matches.
preset_idstringNoRun a stored parser preset (see save_parser_preset) instead of passing `extract` selectors. Results land in payload.data exactly the same way, and the run is scored so the preset can detect decay and self-heal.
actionsarrayNoOrdered browser interactions before capture (forces a render). Each is one object: {"click":"#sel"}, {"clickText":"Accept"} (click by visible text — dismiss a consent wall without knowing its CSS), {"type":{"selector":"#q","text":"shoes"}}, {"scroll":"bottom"}, {"wait":1000}, {"waitForSelector":".results"}. Add "optional":true to skip a miss, or "timeoutMs":N to bound one action.
frontmatterbooleanNoPrepend YAML front-matter (title, url, canonical, description, author, date) so the markdown is self-contained for RAG/Obsidian pipelines
links_modeenumNoLink rendering. inline (default): [text](url). footnote: URLs moved to a numbered reference list at the end. strip: keep only the link text — cuts 30-48% of the tokens on link-dense pages when you only need the prose.inline | footnote | strip
tocbooleanNoPrepend a table of contents built from the page headings
max_tokensintegerNoCap the markdown at ~this many tokens, cutting at a section boundary (never inside a table or code block) and noting how much was omitted
querystringNoWhat you are looking for on the page. Keeps only the relevant sections (BM25 scoring over blocks, headings preserved) — the way to read one fact off a huge page without spending its whole token budget.
highlightsintegerNoWith `query`: also return the N most relevant passages in payload.highlights
chunkobjectNoSegment the output into payload.chunks[] for RAG/vector-DB ingestion — each chunk carries its heading path and token count. Fences and tables are never split.
chunk.byenumNoheading | sentence | tokens
chunk.sizeintegerNo
chunk.overlapintegerNo
images_modeenumNoinline (default) keeps ![alt](url); 'alt' keeps only alt text; 'strip' removes imagesinline | alt | strip
summary_sectionsbooleanNoAppend 'Links on this page' / 'Images on this page' sections — handy when deciding the next hop
htmlstringNoConvert HTML you already have instead of fetching: no proxy bandwidth is used, and the full parser pipeline still applies. Pass `url` too if you want relative links absolutized.
content_modesarrayNoReturn several content scopes from ONE fetch under payload.contents (e.g. compare smart vs full)
cookiesobjectNoCookies to send with the request as name→value (e.g. a consent or locale cookie). Only send cookies the user provided for this site.

Details

From the project README

QuanticData MCP Server

Connect QuanticData to Claude, Cursor, and any MCP client. Gives an AI agent live web access — scrape, search, map, and crawl — through residential proxies with real-browser TLS fingerprints, so pages that block ordinary bots come back clean. It also hands the agent raw proxy endpoints of every type (residential, mobile, datacenter, ISP, IPv6) from your active plans, ready to plug into any HTTP client.

It calls the public QuanticData Scraper API with your own qd_live_ key, so there are no internal secrets and you run it locally.

Tools

ToolWhat it does
scrapeScrape one URL → Markdown/HTML/text, including PDF/Office documents. Supports multi-format output, absolute link collection, JSON-LD metadata, structured CSS extraction, AI prompt/JSON-schema extraction, and mode: summary.
unlockWeb Unlocker: replay any HTTP request (method, headers, body) through a residential exit with a real browser TLS fingerprint, retry on a fresh IP, escalate a blocked GET to a real browser. Returns the raw response (status, headers, body); a still-blocked page comes back flagged (blocked, blockClass, vendor), never as a silent 200. Interactive captchas are not solved (blockClass: "captcha").
seo_auditFetch a URL as a no-JS bot and fully rendered, return both SEO views + the diff (JS-only content, changed title/description, missing canonical) and bot-facing meta (robots, OG, JSON-LD).
ai_visibilityCan ChatGPT, Claude, Perplexity, Google AI Overview and Bing Copilot read and cite a page? On-page audit (24 AI crawlers in robots.txt, Content-Signal, a fetch as GPTBot, noindex/nosnippet/noai, text without JS, JSON-LD entities, answer-shaped copy, dates with age, author, sources) scored per pillar with blockers, evidence and fixes — plus an optional citation panel that asks the engines and reports cited / mentioned / rank, share of voice and who wins the questions you are absent from.
searchStructured Google/Bing/DuckDuckGo results. Set render: true for Google AI Overview, PAA, Knowledge Graph and other JS enrichments.
search_and_readSERP → fetch top pages → numbered citation-ready sources and one token-bounded context string ready for an AI prompt.
search_bulk / search_bulk_statusAsync multi-page pagination with merged organic results and page-one AI/zero-click enrichments.
mapFast URL discovery (sitemaps + homepage links), no full crawl. Compact by default: up to limit URLs (100) plus site-wide total and per-section summary; group_by: path for the path tree.
crawl / crawl_statusAsync BFS site crawl → Markdown per page; poll for progress.
batch / batch_statusScrape many URLs asynchronously; mode: summary for metadata-only items. Incremental polling via since cursor; page content only with include_content.
create_dataset / dataset_statusPrompt-driven structured dataset collection with budget and row limits.
list_collectors / run_collector / collector_run_statusReady-made Collectors: run a versioned scraper with a semantic input (keyword + location, place id, product id, domain…) instead of URLs — Google Maps places, place reviews, Google Jobs/News/Shopping, product offers, hotels, local business leads, site contacts, company profile. Priced per delivered row; async runs poll by run_id, rows exportable as CSV.
list_proxiesList your proxy services of every type — Residential Basic/Premium/Private, Mobile, Mobile V2, Datacenter, ISP, IPv6 — with bandwidth left, expiry and the orderId used to generate.
generate_proxiesReady-to-use proxy strings (credentials included) from any active plan: geo targeting (country/state/city/ISP/ASN), rotating or sticky sessions, HTTP or SOCKS5, several output formats.
proxy_locationsValid geo-targeting values per plan type: countries, states, cities, ASNs, or the full location tree with ISP codes.
whitelist_ipManage IP-auth whitelisting (add/list/remove) for plans that support it, including the Mobile V2 IP-auth proxy list.
reportSend feedback to the team from inside the agent: a bug (wrong/empty result, error, blocked page), a missing feature or collector, a question. Works without an API key.

Quick start

No install needed — npx fetches quanticdata-mcp on demand (Node.js 18+).

Claude Code (one command):

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

Claude Desktop / Cursor / any MCP client (claude_desktop_config.json, .cursor/mcp.json, or .mcp.json):

{
  "mcpServers": {
    "quanticdata": {
      "command": "npx",
      "args": ["-y", "quanticdata-mcp"],
      "env": { "QUANTICDATA_API_KEY": "qd_live_your_key_here" }
    }
  }
}

Hosted endpoint (remote MCP)

The same server also runs as a hosted Streamable HTTP endpoint, for clients that prefer a URL over a local package:

https://api.quanticdata.io/mcp
Connect with OAuth (no key to copy)

The endpoint supports the MCP authorization spec (OAuth 2.1). In a client that supports it, add the URL above as a remote server and nothing else:

  1. The client opens the QuanticData.io sign-in page.
  2. You sign in (or create a free account) and click Allow access.
  3. The client is connected. A key named MCP · <client> appears on the dashboard API keys page; delete it to disconnect the client.

Under the hood: authorization server metadata at https://app.quanticdata.io/.well-known/oauth-authorization-server, protected resource metadata at https://api.quanticdata.io/.well-known/oauth-protected-resource/mcp, dynamic client registration (RFC 7591) and Client ID Metadata Documents, PKCE (S256) required, 1-hour access tokens with rotating refresh tokens, tokens bound to this endpoint (RFC 8707). Usage is billed to your balance like any key.

Or send your API key

Clients that take a bearer token can skip OAuth: the key travels per request in the Authorization header (or X-Api-Key), nothing is stored server-side.

curl -X POST https://api.quanticdata.io/mcp \
  -H "Authorization: Bearer qd_live_your_key_here" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

A request with neither a token nor a key gets 401 with a WWW-Authenticate header pointing at the metadata above: that is what makes OAuth-capable clients start the sign-in.

Self-hosting the endpoint is a second binary in this same package. With QUANTICDATA_API_KEY set it serves that one account to callers that send no credential:

QUANTICDATA_API_KEY=qd_live_… PORT=9310 npx -y quanticdata-mcp-remote

Run from source (development)

npm install
npm run build

Then point the client at the local build instead of npx:

{
  "mcpServers": {
    "quanticdata": {
      "command": "node",
      "args": ["/absolute/path/to/scraper-mcp/dist/index.js"],
      "env": {
        "QUANTICDATA_API_KEY": "qd_live_your_key_here"
      }
    }
  }
}

Env

VarDefaultNotes
QUANTICDATA_API_KEY—Required. Your qd_live_ key.
QUANTICDATA_API_BASEhttps://api.quanticdata.io/v1Override for staging/self-host.
QUANTICDATA_TOOLSall 28Load only some tools: names (search,scrape) or a preset (lite, web, research, collectors, proxies). See below.

Self-hosted remote endpoint only (quanticdata-mcp-remote), optional:

VarDefaultNotes
MCP_OAUTH_RESOURCEhttps://api.quanticdata.io/mcpThis endpoint as an OAuth resource.
MCP_OAUTH_ISSUERhttps://app.quanticdata.ioAuthorization server advertised in the resource metadata.
MCP_OAUTH_INTROSPECT_URLhttp://127.0.0.1:3090/api/v1/internal/oauth/introspectWhere OAuth access tokens are checked.
MCP_INTERNAL_TOKEN—Secret for the introspection call. Unset = only API keys are accepted.

Local models (Ollama, LM Studio, Qwen, Open WebUI)

The 28 tool definitions are about 14,000 tokens. A local model on Ollama's default 4K context cannot hold them, and a 32K context loses almost half its room before the first page. Load fewer tools:

PresetToolsDefinition tokens
litesearch_and_read~360
websearch, search_and_read, scrape~4,200
researchweb + map, batch, batch_status~5,100
collectorslist_collectors, run_collector, collector_run_status~830
proxieslist_proxies, generate_proxies, proxy_locations, whitelist_ip~1,800

Over stdio set QUANTICDATA_TOOLS=web. On the hosted endpoint add ?tools=web to the URL and send your API key as a Bearer header: https://api.quanticdata.io/mcp?tools=web. Names can be combined: ?tools=lite,collectors.

Example prompts

  • "Scrape the pricing page at example.com and give me the plans and prices."
  • "Search Google Shopping for 'nintendo switch oled' in the US and list the cheapest 5."
  • "Map docs.example.com, then crawl only the /guides/ pages and summarize them."
  • "List my proxy plans and generate 5 sticky US residential proxies as socks5 URLs."
  • "Get me a rotating mobile proxy in Germany and whitelist my server IP 203.0.113.7."

Privacy Policy

Full policy: https://quanticdata.io/privacy

What this server sends. It runs on your machine and talks only to the public QuanticData API at https://api.quanticdata.io/v1, authenticated with your own qd_live_ key. Each call carries the arguments you (or your agent) passed — the target URL or query, and any extraction prompt. Nothing else on your machine is read or transmitted: the server has no filesystem, shell or clipboard access.

What we collect. Account data you give us (name, email, billing details) and a request log kept for billing, abuse prevention and support: target URL or query, timestamp, response status, bytes transferred and the API key used. We do not retain scraped page content beyond what is needed to return your result.

Data you collect through the service. You decide what public web data to collect and you are the controller of that data — we process it on your behalf only to fulfil your request. You are responsible for using the service lawfully, for respecting the terms of the sites you access, and for any personal data you collect through it.

Sharing. We do not sell personal data. We share it only with the processors that run the service — payment providers, email delivery, hosting, CDN and analytics — under contracts that bind them to protect it, and with the upstream proxy networks that route your traffic (connection metadata only, never your account details). We may disclose data where required by law.

Retention. Account data for as long as the account exists; request logs on a rolling window for billing and abuse investigation. You can request deletion at any time.

Your key. Claude Desktop stores it in the OS keychain and passes it to this server as an environment variable. It is never written to the bundle and never sent anywhere except the QuanticData API. Revoke or rotate it at https://app.quanticdata.io/api-keys.

Contact. [email protected]

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.