MCP.so
Sign In

QuantumProxies — Residential, Mobile & Datacenter Proxy MCP Serv…VerifiedFeatured

@quantumproxies

Basic information

Category

Browser Automation

Last updated

License

MIT

Author

quantumproxies

Submitted by

QuantumProxies

About QuantumProxies — Residential, Mobile & Datacenter Proxy MCP Server

Give your AI agent its own proxies. QuantumProxies exposes residential, mobile, datacenter, ISP and IPv6 endpoints as MCP tools: list your plans, generate ready-to-use proxy strings with credentials, target by country, s

#residential-proxies#mobile-proxies#datacenter-proxies#proxy-api#geo-targeting#socks5#web-scraping#ai-agents

QuantumProxies — Residential, Mobile & Datacenter Proxy MCP Server config

Add this server to your MCP-compatible client using the configuration below.

{
  "mcpServers": {
    "quantumproxies": {
      "command": "npx",
      "args": [
        "-y",
        "quantumproxies-mcp"
      ],
      "env": {
        "QUANTUMPROXIES_API_KEY": "qp_live_your_key_here"
      }
    }
  }
}

QuantumProxies — Residential, Mobile & Datacenter Proxy MCP Server tools

28

Use this when the user wants the content of one web page. Fetches the page from a residential IP and returns it as clean Markdown (or HTML/text). It tries a plain HTTP request with a Chrome-compatible TLS profile first and uses a headless browser only when the page needs JavaScript or the plain request is refused. Optionally runs structured extraction (CSS selectors or a stored preset) or AI extraction (natural-language prompt). Markdown keeps the complete page by default (content_mode 'smart': everything except nav/footer/cookie banners, with GFM tables and absolute links); use format 'html' to inspect the raw no-JS page. Optional browser `actions` (click, type) can submit forms on the target site. Use it only for pages the user is permitted to access.

Use this when the user needs a site's raw HTTP response (a JSON API, a form POST, a page exactly as served) rather than scrape's Markdown. Sends the request (method, headers, body) from a residential IP with a browser-compatible TLS profile and returns status, headers, body (bodyBase64 for binary) and finalUrl. A GET or HEAD the site refuses is retried from another IP and, for GET, once in a headless browser; other methods get exactly one attempt. If the site still refuses, the response is marked `blocked` with the reason (`blockClass`, `vendor`) instead of being reported as a success; captchas are never solved. POST, PUT, PATCH and DELETE can change or delete data on the target site. Use it only for sites and data the user is permitted to access.

Look at a page ONCE with an LLM and get back CSS selectors that extract the fields you asked for. Pass the returned `parser` as the `extract` argument on every later scrape of that same layout and no AI runs again — it becomes a plain, deterministic extraction with no AI cost. Use this instead of ai_prompt whenever you will scrape more than a couple of pages of the same shape. Every selector is run against the page before being returned, so `report`/`coverage` tell you which fields are actually reliable.

Store a generated parser under a name so it can be reused by id. Scrape later with scrape's `preset_id` instead of repeating the selectors, and every run is scored per field — when the recent success rate decays (the site redesigned), the preset regenerates itself from `source_url` and bumps a version. Give it a source_url whenever you can: without one it can never self-heal.

List your stored parser presets with their version, health stats and changelog.

How well a stored parser is still working: success rate per field, mean coverage over the recent runs, and whether it now counts as decayed (i.e. the site probably changed).

Regenerate a preset's selectors now (the manual trigger for the automatic repair). Refetches the source page and adopts new selectors ONLY if they extract more than the current ones — a heal that finds nothing better leaves the preset untouched and is not billed.

Audit a URL's SEO in one call: fetches it twice — as a pure HTTP bot (no JS) and fully rendered — and returns both views (title, description, canonical, h1, word count) plus the diff (JS-only content, changed title/description, canonical missing without JS) and bot-facing meta (robots, Open Graph, JSON-LD types). Use this instead of scraping manually when checking how a page indexes.

Use this when the user asks whether AI assistants (ChatGPT, Claude, Perplexity, Google AI Overview, Bing Copilot) can find, read and cite a page; use seo_audit for classic Google indexing questions. On-page pass (always): the live robots.txt resolved for 24 AI crawlers per RFC 9309 with the deciding line, Content-Signal, one request sent with the GPTBot user-agent to check whether the site answers AI crawlers differently (skip it with no_bot_fetch), noindex/nosnippet/noai/data-nosnippet, text present without JavaScript, JSON-LD types and resolvable Organization/Person entities, heading outline, question-shaped headings, answer-first paragraph, lists/tables, numeric facts and quotes, chunk-sized sections, dateModified with age, author, outbound sources. Also readability grade, paragraph length, definitional openers, named-entity density, keyword stuffing, first-hand content, images/video, paywall and retired robots tokens. Retrievability: where Google ranks the page for its own H1 question and whether it is indexed (2 SERPs); a page that is not indexed is reported as a blocker. Google AI Overview and Bing Copilot report brand mentions only, because their no-JS results expose no sources. Returns a 0-100 score per pillar (retrievability, access, readability, structure, answerability, trust, plus offsite when requested), blockers that cap the score, every check with evidence and fix, and topFixes. Citation panel (when `queries` is set): asks each engine the questions and reports cited / mentioned / rank per (query × engine), share of voice across all cited domains, and the domains cited where the page is absent.

Run structured Google, Bing or DuckDuckGo searches through a residential proxy. Bing supports web, shopping, images, news, videos, places/maps and autocomplete over HTTP, including Copilot AI answers and citations when Bing returns them. Google web search also parses rich blocks directly from its HTTP response.

Search the live web, fetch the top organic pages as clean Markdown, and return citation-ready numbered sources plus one token-bounded `context` string ready for an AI prompt. Use this when the goal is answering/researching, and use `search` when raw SERP structure or a specialized vertical is needed.

Discover a site's URLs fast (robots.txt sitemaps + /sitemap.xml + homepage links) without a full crawl. Returns up to `limit` URLs (default 100) plus the site-wide `total` and a per-section `summary` (e.g. '/blog': 1988) so you see the site's shape without the full list. Narrow with `search` (substring filter — the primary way to find specific pages) or set group_by 'path' for the path tree with counts instead of URLs.

Start an asynchronous BFS crawl of a site from a seed URL, converting each page to Markdown. Returns a job id — poll with crawl_status.

Poll a crawl job for progress and the pages crawled so far. Polls are incremental: pass the previous response's `nextCursor` as `since` to receive only the pages crawled since your last poll. Pages omit their content by default — set include_content true only when you actually need the text (a large crawl's full content can be hundreds of KB).

Scrape many URLs asynchronously with shared options. Returns a job id — poll with batch_status. For SEO/status audits over many pages set mode 'summary': items carry metadata only (title, description, canonical, contentLength) instead of full page content.

Poll a batch job for progress and per-URL results. Polls are incremental: pass the previous response's `nextCursor` as `since` to receive only the items completed after your last poll. Items omit page content by default — set include_content true only when you actually need the text.

Paginate ONE search query asynchronously and merge deduplicated organic results. Page-one AI Overview/PAA/Knowledge Graph/answer enrichments are retained; set render:true to request those Google JS blocks. Billed per page actually fetched, with unavailable pages refunded.

Poll a bulk search job for progress and merged organic results. Polls are incremental: pass the previous response's `nextCursor` as `since` to receive only the organic results gathered after your last poll.

Build a structured dataset from a plain-language prompt. Quantic AI plans the search queries, searches Google/Bing/DuckDuckGo, maps the sites it finds and scrapes them into validated rows (CSV/JSON). Returns a job id — poll with dataset_status. Billed per delivered, validated record (email/phone fields cost extra, only when found); the run never exceeds limits.max_cost_usd, and the unspent budget is refunded.

Poll a dataset job for progress, the collection trace (steps) and the rows so far. Polls are incremental: pass the previous response's `nextCursor` as `since` to receive only rows delivered after your last poll. Set mode 'summary' to omit rows and get only progress + steps (light poll). When status is completed, the response includes signed CSV/JSON download URLs.

List the account's proxy services of every type — Residential Basic/Premium/Private, Mobile, Mobile V2, Datacenter (static or traffic-based), ISP, IPv6 — with plan type, bandwidth left, expiry, whitelisted IPs and the orderId to pass to generate_proxies. Passwords are not listed here: generate_proxies returns ready-to-use credentials. Call this first to see which proxy plans are available.

Generate ready-to-use proxy endpoint strings (credentials included) from one of the account's active proxy services — any type: residential, mobile, datacenter, ISP, IPv6. Supports geo targeting (country/state/city, ISP or ASN where the plan allows it), rotating or sticky sessions, HTTP or SOCKS5, and several output formats. Use list_proxies first to get the orderId, and proxy_locations for valid targeting codes. The returned strings plug straight into any HTTP client, e.g. curl -x.

Discover valid geo-targeting values for a proxy plan type before calling generate_proxies: countries, states, cities, ASNs, or the full location tree (countries → regions → cities → ISPs). Use level 'tree' for Residential Premium / Mobile V2 slugs and ISP codes, or for the static datacenter gateway list; note the tree can be large.

Manage IP-auth whitelisting on a proxy service (Residential Basic, Datacenter, ISP, IPv6, Mobile): add or remove an IP, or list the current entries. A whitelisted machine uses the proxies without username/password — required for the Mobile V2 IP-auth proxy list. Residential Premium/Private use user:pass auth and don't need this.

Use this to find a ready-made Collector for a task before calling run_collector. Collectors are paid, versioned scrapers you run with a semantic input (keyword + location, place id, product id, domain…) instead of URLs, grouped in categories such as local businesses and maps, e-commerce, jobs, news, travel, finance, developer registries, research, classifieds, public records and domain/DNS data. Returns a compact catalog (slug, name, category, tagline, price per delivered result, required input fields, health), optionally filtered by `category`; pass `slug` to get one collector's full input/output schema and example input. Billing is pay-per-success: only delivered rows are charged.

Run a Collector by slug with a semantic input (see list_collectors for each collector's inputSchema and example). Short runs return the rows inline; long runs return 202 with a run_id + statusUrl — poll with collector_run_status. Results are billed per delivered row (never for failures). Set `async` true to force background execution.

Fetch a Collector run by run_id: status (queued|running|done|failed), result count, cost, partial flag and the result rows. Use after run_collector returned 202/async. Pass format 'csv' to get the rows as CSV text.

Send feedback to the QuantumProxies team: a bug (a result that is wrong or empty after a retry, a broken parser, a blocked page that should work), a missing tool, site, option or collector, or a question about behaviour or pricing. Use it when the user asks to report something. When a tool here clearly failed at its job, or the user needs something no tool here covers, offer to send a report and call it only if the user agrees. Do NOT call it for a missing, rejected or unset API key, for the no-key trial or the balance being used up, for a network timeout, or for your own wrong input: those are fixed by the user, not by the team, and the tool that failed already said how. One report per issue, never one per retry. The report (the fields below, plus the account it comes from when the call is authenticated) is stored and forwarded to the QuantumProxies support team; it cannot be recalled. Works without an API key.

Overview

What is QuantumProxies?

QuantumProxies is a proxy network exposed as an MCP server. Instead of copying endpoints out of a dashboard, your agent asks for the proxies it needs and gets back ready-to-use strings with credentials already in them.

It covers every proxy type on the account — Residential Basic, Premium and Private, Mobile, Mobile V2, Datacenter (static or traffic-based), ISP and IPv6 — and the same server also scrapes, searches and crawls the web through that residential pool.

Proxy tools

  • list_proxies — every proxy service on the account with plan type, bandwidth left, expiry, whitelisted IPs and the orderId used to generate.
  • generate_proxies — ready-to-use endpoint strings from any active plan: geo targeting by country, state and city (ISP or ASN where the plan allows), rotating or sticky sessions with a chosen session time, HTTP or SOCKS5, several output formats. The result drops straight into curl -x, a scraper, or a browser profile.
  • proxy_locations — valid targeting values before you generate: countries, states, cities, ASNs, or the full tree of countries → regions → cities → ISPs with the slugs and ISP codes Residential Premium and Mobile V2 expect.
  • whitelist_ip — IP authentication on plans that support it (Residential Basic, Datacenter, ISP, IPv6, Mobile): add, remove or list entries so a machine connects with no username or password. Required for the Mobile V2 IP-auth list.

Web access tools

The scraping side runs on the same residential pool with real-browser TLS fingerprints, so pages that block ordinary bots come back clean.

  • scrape — any URL to clean Markdown, HTML or text, including PDF and Office documents; optional CSS or AI extraction.
  • search, search_and_read, search_bulk — structured Google, Bing and DuckDuckGo results; search_and_read returns numbered citation-ready sources plus one token-bounded context string.
  • map, crawl, batch — fast URL discovery, background site crawls, and asynchronous multi-URL scraping.
  • list_collectors, run_collector — 74 ready-made collectors that take a semantic input (keyword and city, product id, company domain) and return typed rows.
  • generate_parser, save_parser_preset, heal_parser_preset — turn one AI pass into reusable CSS selectors that self-repair when the site changes.
  • seo_audit — a URL fetched as a no-JS bot and fully rendered, with the diff between the two.

25 tools in total.

Example prompts

  • "List my proxy plans and generate 5 sticky US residential proxies as SOCKS5 URLs."
  • "Get me a rotating mobile proxy in Germany, then whitelist my server IP 203.0.113.7."
  • "What cities can I target on the Residential Premium plan in Spain?"
  • "Generate 20 datacenter proxies in France as host:port:user:pass and save them to a file."
  • "Scrape the pricing page at example.com and give me the plans and prices."

Use cases

  • Give a coding agent a proxy pool it can rotate through on its own, without a dashboard round-trip.
  • Geo-check a page, an ad or a price from a specific country, state or ISP.
  • Feed proxies into an existing scraper, browser automation or account-management stack from inside the agent loop.
  • Research and monitoring that needs the live web rather than a stale index.

Frequently asked questions

1

Which proxy types are included?

Residential Basic, Premium and Private, Mobile, Mobile V2, Datacenter (static or traffic-based), ISP and IPv6. `list_proxies` shows which ones are active on the account and how much bandwidth each has left.

2

Do I need a proxy plan to use the scraping tools?

No. `scrape`, `search`, `map` and `crawl` run on QuantumProxies' own residential pool and need only the API key. The proxy tools generate endpoints from the plans on your account.

3

Rotating or sticky sessions?

Both. `generate_proxies` takes a rotation mode and a session time, so you can get a fresh IP per request or hold one for the length of a login flow.

4

Does it work without username and password?

Yes, on plans that support IP authentication. `whitelist_ip` adds your machine's IP and the proxies then connect with no credentials. Residential Premium and Private always use user:pass.

5

Is there a hosted endpoint?

Yes. `https://api.quantumproxies.io/mcp` speaks Streamable HTTP and serves the same 25 tools with no install. The key travels per request in the `Authorization` header, so nothing is stored server-side.

6

Which clients are supported?

Any stdio MCP client — Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, Zed, Cline — and any agent framework with an MCP adapter.

Comments

More Browser Automation MCP servers