Skip to main content
Glama
unblockingapi

@unblockingapi/mcp

Official

@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

unblock_fetch

Fetch any URL, bypassing anti-bot walls, CAPTCHAs and geo-blocks. Plain HTTP by default, render: true for a real browser. Pass template to get structured JSON instead of HTML.

1 credit per success

find_templates

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.

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-plugins

The 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_here

Full walkthrough: docs/claude-setup.md.

Claude Code — plain MCP server

claude mcp add unblockingapi \
  -e UNBLOCKINGAPI_KEY=your_api_key_here \
  -- npx -y @unblockingapi/mcp

Claude 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/mcp MCP server. My API key is sk_xxx. It runs over stdio via npx -y @unblockingapi/mcp and needs the env var UNBLOCKINGAPI_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 ChatGPT

Environment variables

Var

Required

Default

Purpose

UNBLOCKINGAPI_KEY

yes

Your API key. (The Claude Code plugin supplies it from its config prompt.)

UNBLOCKINGAPI_BASE_URL

no

https://api.unblockingapi.com

Override the API base URL.

UNBLOCKINGAPI_TIMEOUT_MS

no

150000

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) — then render: true if 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

url

string, required

http(s) only; media/binary files are rejected.

render

boolean

Run a real browser (executes JavaScript). Default false.

location

string

2-letter country code for the proxy (us, gb, de, …). Any ISO country.

wait_for

string

Render-only. stable (default), domcontentloaded, networkidle, or a CSS selector to wait for.

settle_ms

0–25000

Render-only. Ceiling on the settle wait (default 5000) — capture happens as soon as the DOM is quiet for 500 ms.

wait_rules

array

Render-only. [{if: "#consent", then: "#results"}] — first visible if wins and its then replaces wait_for.

detect_ms

0–25000

Render-only. How long to probe wait_rules (default 800).

max_age

0–300

Accept a cached copy this many seconds old. Hits return in ms and carry cached: true.

template

string

Parse with a published template (handle/name) and return JSON. Forces that template's fetch settings. Find one with find_templates.

max_chars

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

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesFull idealista.com listing URL, e.g. https://www.idealista.com/inmueble/111072490/

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesThe HTTP/HTTPS URL to fetch.
waitNoRender-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'.
renderNoRender with a headless browser (executes JavaScript). Required for SPAs and dynamic pages. Default false (fast plain-HTTP fetch).
locationNo2-letter country code to proxy through (e.g. 'us', 'gb', 'de').
remove_svgsNoStrip <svg> tags from the returned HTML.
block_assetsNoRender-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_scriptsNoStrip <script> tags from the returned HTML.
remove_stylesheetsNoStrip <style> tags from the returned HTML.

TDQS

A3.9/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 3 tool updatesv0.2.0
    • First observedgoogle_search
    • First observedidealista_property
    • First observedunblock_fetch

TDQS

A4.1/5.0

Scored across 3 tools

Disambiguation5/5

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.

Naming Consistency4/5

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.

Tool Count4/5

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.

Completeness4/5

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

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers