@unblockingapi/mcp
OfficialAn MCP server that gives agents a real browser behind rotating residential proxies to fetch, render, and parse web pages into structured JSON.
unblock_fetch: Fetch any HTTP/HTTPS URL, bypass anti-bot/CAPTCHA/geo-blocks; plain HTML by default,render: truefor JS-heavy pages, optionaltemplateto get JSON instead of HTML.find_templates: Search published parsing templates by URL, keyword, or category — free.google_search: Run Google searches and get structured organic results as JSON, with location targeting and pagination.idealista_property: Extract structured data from idealista.com property listings (price, size, rooms, etc.).Caching (
max_age), country-level proxy (location), render wait/selector rules, and HTML cleanup params (remove_scripts,remove_svgs, etc.).Failed requests are free; no cost for template lookup.
Allows running Google searches and retrieving structured organic results as JSON.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@@unblockingapi/mcpSearch Google for the latest MCP tools"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@unblockingapi/mcp
Official Model Context Protocol server and Claude Code plugin for UnblockingAPI. Gives AI agents (Claude, Cursor, VS Code, Zed, …) a real browser behind rotating residential proxies: fetch bot-protected and JavaScript-heavy pages, and parse any site a published template covers into structured JSON.
Tools
Tool | What it does | Cost |
| Fetch any URL, bypassing anti-bot walls, CAPTCHAs and geo-blocks. Plain HTTP by default, | 1 credit per success |
| Find a template that parses a site into JSON — by the URL you are about to fetch, by keyword, or by category. | free |
Failed requests are free. The server also ships instructions and a skill so the agent starts with a plain fetch, renders only when a page needs JavaScript, and checks for a template before parsing a known site by hand.
Templates
A template turns a page into named fields instead of markup. The catalogue is open-ended — search engines, marketplaces, property portals, company registries — and anyone can publish one from the editor. There is no special handling for any particular site: every template, official or community, is reached the same way.
find_templates(url: "https://www.allabolag.se/foretag/…") → kjellberg/allabolag
unblock_fetch(url: "…", template: "kjellberg/allabolag") → { company_title, turnover, … }If a parser fails because the site changed, you get raw HTML back with
parse_error: true rather than an error.
Related MCP server: Spider MCP Server
Setup
You need an UnblockingAPI key — sign up at https://unblockingapi.com (500 free credits, no card).
Detailed guides: Claude (Claude Code plugin, claude mcp add,
Claude Desktop) · Cursor · other clients below.
Claude Code — plugin (recommended)
The plugin bundles the MCP server, stores your key, and makes Claude use
unblock_fetch instead of its built-in web fetch.
In Claude Code, three lines:
/plugin marketplace add unblockingapi/mcp
/plugin install unblockingapi@unblockingapi-plugins
/plugin configure unblockingapi@unblockingapi-pluginsThe third line matters. Installing does not prompt for your key and succeeds
without one, so skipping it leaves every fetch failing. New to this? Run
/unblockingapi:setup instead and Claude walks you through it, then checks that
it works. From a terminal you can
do it in one shot instead, but --config only applies on a fresh install:
claude plugin install unblockingapi@unblockingapi-plugins --config api_key=your_api_key_hereFull walkthrough: docs/claude-setup.md.
Claude Code — plain MCP server
claude mcp add unblockingapi \
-e UNBLOCKINGAPI_KEY=your_api_key_here \
-- npx -y @unblockingapi/mcpClaude Desktop
Edit claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/,
Windows: %APPDATA%\Claude\), then restart Claude:
{
"mcpServers": {
"unblockingapi": {
"command": "npx",
"args": ["-y", "@unblockingapi/mcp"],
"env": { "UNBLOCKINGAPI_KEY": "your_api_key_here" }
}
}
}Cursor
Add the same block to ~/.cursor/mcp.json (every project) or a project's
.cursor/mcp.json. See docs/cursor-setup.md for the one-click
install link and a rule that makes the agent prefer unblock_fetch.
VS Code (Copilot agent mode)
code --add-mcp '{"name":"unblockingapi","command":"npx","args":["-y","@unblockingapi/mcp"],"env":{"UNBLOCKINGAPI_KEY":"your_api_key_here"}}'Install by prompt
Agentic clients that can edit their own config (Claude Code, Cursor's agent, Cline, …) will set it up if you ask:
Install the
@unblockingapi/mcpMCP server. My API key issk_xxx. It runs over stdio vianpx -y @unblockingapi/mcpand needs the env varUNBLOCKINGAPI_KEY.
ChatGPT and other remote-only clients
ChatGPT connectors need a public HTTPS MCP endpoint. Bridge the stdio server
with supergateway and a tunnel:
UNBLOCKINGAPI_KEY=your_api_key_here \
npx -y supergateway --stdio "npx -y @unblockingapi/mcp" --port 8000
# then e.g. cloudflared tunnel --url http://localhost:8000 → add https://…/sse in ChatGPTEnvironment variables
Var | Required | Default | Purpose |
| yes | — | Your API key. (The Claude Code plugin supplies it from its config prompt.) |
| no |
| Override the API base URL. |
| no |
| Per-request timeout. Rendered fetches can take up to 140 s. |
Usage
Once connected, ask your agent things like:
"Read https://example.com/pricing and summarise the plans." →
unblock_fetch(url)— thenrender: trueif the page turned out to need JavaScript"Pull the company profile at this allabolag.se URL as JSON." →
find_templates(url)→unblock_fetch(url, template: "kjellberg/allabolag")"Is there a template for this site?" →
find_templates(url)"What can this parse into JSON?" →
find_templates(category: "real-estate")
unblock_fetch parameters
Param | Type | Notes |
| string, required | http(s) only; media/binary files are rejected. |
| boolean | Run a real browser (executes JavaScript). Default |
| string | 2-letter country code for the proxy ( |
| string | Render-only. |
| 0–25000 | Render-only. Ceiling on the settle wait (default 5000) — capture happens as soon as the DOM is quiet for 500 ms. |
| array | Render-only. |
| 0–25000 | Render-only. How long to probe |
| 0–300 | Accept a cached copy this many seconds old. Hits return in ms and carry |
| string | Parse with a published template ( |
| integer | Cap on returned body (default 120000). Longer bodies are truncated with a note. |
Responses start with a JSON metadata block (job_id, status, http_response_code,
response_time_ms, render, location, cached, parse_error, truncated, …),
then ---, then the HTML or JSON body. API errors (bad key, out of credits,
unknown template, invalid params, concurrency limit) come back as clear tool errors.
Full API reference: https://unblockingapi.com/docs.
Development
npm install
npm run dev # tsx watch
npm run typecheck # tsc --noEmit
npm run build # compile to dist/
npm run smoke # drive the built server over stdio (add UNBLOCKINGAPI_KEY for live fetches)Repository layout: src/ (server + API client), .claude-plugin/ (Claude Code
plugin + marketplace manifests), hooks/, skills/ and commands/ (plugin
behaviour), docs/ (setup guides).
License
MIT
Available Tools
3 toolsgoogle_searchA
Run a Google search through UnblockingAPI and get structured organic results as JSON. Useful for SERP data, research, and competitive analysis without getting blocked.
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | The search query / keyword. | |
| uule | No | Optional Google UULE location-encoding string for precise geo-targeting. | |
| start | No | Result offset for pagination (0 = page 1, 10 = page 2, …). | |
| location | No | 2-letter country code for the search locale (default 'se'). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the behavioral disclosure burden. It does disclose that the tool returns organic results as JSON and that it works 'without getting blocked,' which adds useful context. However, it omits details such as authentication requirements, rate limits, failure modes, or whether non-organic results (ads) are included.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the primary action and output format. The second sentence adds relevant use-case context without unnecessary elaboration, so every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity search tool with a fully documented schema, the description covers the core purpose, output type, and primary use cases. The lack of an output schema means return-field details are not specified, but the phrase 'structured organic results as JSON' provides adequate context given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides complete descriptions for all four parameters (100% coverage), so the baseline is 3. The tool description does not add parameter-level guidance beyond what the schema already supplies, but this is acceptable given the rich schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific action ('Run a Google search') and resource ('through UnblockingAPI'), and clarifies the output as structured organic results in JSON. It also distinguishes itself from sibling tools by emphasizing unblocked access and the SERP use case.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear use cases ('SERP data, research, and competitive analysis') and highlights the benefit of avoiding blocks. It does not explicitly contrast with sibling tools or state when not to use it, but the context is sufficient for an agent to make a reasonable selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
idealista_propertyA
Extract structured data from an idealista.com property listing (Spain's largest real-estate portal) — price, size, rooms, bathrooms, floor, energy rating, features, photos, advertiser, and more, as JSON. Pass the full listing URL.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Full idealista.com listing URL, e.g. https://www.idealista.com/inmueble/111072490/ |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the burden. It discloses the output format (JSON) and the key input requirement, but it does not mention failure modes, rate limits, scraping behavior, or what happens with invalid/private listings. This is acceptable but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one dense sentence that front-loads the purpose and output, lists example fields, and ends with the invocation instruction. There is no filler or repetition beyond the small overlap with the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema, the description provides enough context by enumerating the extracted fields and stating the output is JSON. It doesn't cover error or edge cases, but the tool is simple and the key usage details are present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already fully describes the single `url` parameter with format, example, and 'Full idealista.com listing URL' context. The description's 'Pass the full listing URL' reinforces this but adds no new semantic detail beyond the schema, so it lands at the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Extract structured data' and clearly identifies the resource (idealista.com property listing) plus the output format (JSON). The enumerated fields (price, size, rooms, bathrooms, etc.) give concrete scope that distinguishes it from the sibling tools like google_search or unblock_fetch.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The instruction 'Pass the full listing URL' makes the primary usage context clear: use this when you already have a specific idealista listing URL and want structured data rather than search results or raw fetch output. It doesn't explicitly name alternatives or exclusions, but the context is straightforward.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
unblock_fetchA
Fetch a URL through UnblockingAPI, bypassing bot detection, CAPTCHAs, and geo-blocks with rotating residential proxies. Returns the page HTML. Set render=true for JavaScript-heavy sites (SPAs, dynamic content) to get the fully rendered DOM.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The HTTP/HTTPS URL to fetch. | |
| wait | No | Render-only. Comma-separated wait steps (max 5): an optional leading load event (domcontentloaded|load|networkidle), then CSS selectors to wait for, or 'networkidle:<ms>' / 'domstable:<ms>' quiet-poll strategies. e.g. 'domcontentloaded,h3'. | |
| render | No | Render with a headless browser (executes JavaScript). Required for SPAs and dynamic pages. Default false (fast plain-HTTP fetch). | |
| location | No | 2-letter country code to proxy through (e.g. 'us', 'gb', 'de'). | |
| remove_svgs | No | Strip <svg> tags from the returned HTML. | |
| block_assets | No | Render-only. When rendering, presentational assets (CSS, images, fonts, media) are skipped by DEFAULT for speed — JavaScript still executes, so SPAs and dynamic content still render fully. Set block_assets=false to also download CSS/images/fonts (e.g. when you need asset URLs or a visually complete render). Ignored when render=false. | |
| remove_scripts | No | Strip <script> tags from the returned HTML. | |
| remove_stylesheets | No | Strip <style> tags from the returned HTML. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the behavioral transparency burden. It discloses the proxy rotation, bypassing, and render behavior, which is valuable. However, it does not mention potential API key requirements, rate limits, latency, or that some target sites may still block the request. This is moderate transparency, not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, both valuable. The first states the core functionality and output; the second provides key guidance on when to use render mode. No wasted words or repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate but not thorough for a tool with 8 parameters and no output schema. It explains the high-level function and render toggle but omits operational context like API authentication, response size limits, or error behavior. The detailed schema compensates for parameter semantics, but the description leaves gaps for an agent on when this tool is worth invoking versus alternatives (like direct HTTP fetching).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of parameters with detailed descriptions, so the baseline is 3. The description adds a minor usage hint about render=true for SPAs/dynamic content, which aligns with the schema but doesn't add new semantics beyond it. The schema already explains wait, block_assets defaults, and other quirks.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the primary action ('Fetch a URL'), the resource (through UnblockingAPI), and the specific value added (bypassing bot detection, CAPTCHAs, geo-blocks with rotating proxies). It also distinguishes itself from sibling tools like google_search and idealista_property, which are domain-specific rather than generic fetching.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: fetching URLs that need bypassing or geo-relocation. It also gives a clear conditional for the render parameter ('for JavaScript-heavy sites'). However, it does not explicitly address when not to use it or mention alternative tools, but context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.2.0- First observed
google_search - First observed
idealista_property - First observed
unblock_fetch
TDQS
Scored across 3 tools
Each tool targets a distinct purpose: unblock_fetch fetches raw HTML, google_search returns structured search results, and idealista_property extracts specific real-estate listing data. There is no overlap or ambiguity between them.
All tool names follow a consistent snake_case pattern and are descriptive, but the pattern isn't strictly verb_noun: unblock_fetch is verb_verb, google_search is noun_verb, and idealista_property is noun_noun. Minor deviation from a uniform convention.
With 3 tools, the set is small but well-scoped for the server's purpose of unblocking web data access. Each tool earns its place, though the count feels slightly thin for broader scraping scenarios.
Generic fetch covers arbitrary URLs, structured search covers SERP data, and a specialized extractor covers a major site. Missing features like custom structured extraction from other sites are workarounds via unblock_fetch, so the surface is reasonably complete for its niche.
Maintenance
Related MCP Connectors
Web search, browser automation, scraping, crawling and CAPTCHA solving for AI agents.
Direct access to 60+ scraping and search tools. Extract structured data from Google (Search, Maps, Trends), Amazon, Airbnb, Social Media, and any web page directly into your AI agent.
Reliable web access for AI agents: smart HTTP, rotating proxies, and full-browser rendering.
Fetch any web page's HTML, AI-parsed JSON, or Google results via the ScrapeUnblocker anti-bot API
Related MCP Servers
- AlicenseDqualityDmaintenanceEnables AI assistants to reliably fetch web content as markdown and search the web by bypassing bot detection and rendering JavaScript. Provides tools to unblock URLs and search the web with results converted to markdown format.215 npmMIT
- AlicenseAqualityFmaintenanceEnables AI agents to crawl, scrape, search, and automate browsers with anti-bot bypass, providing fast web access via 22 tools.2242 npm3MIT
- AlicenseNot gradedqualityDmaintenanceProvides AI agents with reliable web fetching capabilities, handling retries, caching, and anti-bot bypass automatically.MIT
- AlicenseAqualityAmaintenanceEnables fetching any web page's HTML by bypassing anti-bot protection, and also provides AI-parsed structured data and Google search results.455 npm1MIT