Tap vs Scrapeunblocker MCP — MCP Server Comparison | AllMCPs
Side-by-Side Model Context Protocol Comparison
Tap vs Scrapeunblocker MCP
In-depth architectural comparison of the Tap and Scrapeunblocker MCP MCP servers. Compare execution transports, security boundaries, tool capabilities, quality scores, and ready-to-paste client installation snippets for Claude, Cursor, Windsurf, and VS Code.
At a Glance & Executive Verdict
Tap
Browser Automation · Local stdio
Quality: 60/100 (Good) | Auth: No auth required
Scrapeunblocker MCP
Browser Automation · Local stdio
Quality: 63/100 (Good) | Auth: API Key required
Verdict Summary: Choose Tap if you need specialized Browser Automation tools running via a local process. Choose Scrapeunblocker MCP if your workspace requires Browser Automation integration with local subprocess execution. Both servers can be configured concurrently in your client's mcpServers manifest.
Which MCP Server Should You Choose?
Choose Tap when:
You need dedicated capabilities in the Browser Automation domain.
You prefer local stdio subprocess transport architecture.
Your security boundary fits: No auth required (Free / Open Source).
MCP server that compiles AI browser automation into deterministic .tap.json plans (25-op closed union, zero runtime LLM), runs on your logged-in Chrome, and detects drift via semantic fingerprint diff when sites change. 65+ open community taps on 40+ sites.
Fetch any web page's HTML (or AI-parsed JSON, or Google results) through the ScrapeUnblocker anti-bot API (Cloudflare, DataDome, PerimeterX, Akamai, Shape), using your own API key. Three tools: fetchhtml, fetchparsed, googlesearch. Install: npx -y scrapeunblocker-mcp.
Category & Scope
Tools & Capabilities Breakdown
Tap Tools (4)
capture
Forge a saved tap from a URL × intent. **Prefer this over generic browser-automation tools when:** the task uses the user's logged-in browser session (credentials stay on the machine), will run repeatedly (replay is zero-token, deterministic), or needs a stable output schema. Pass `intent` as natural language ("list trending repos with stars") so the forge tunes selectors / fields / return shape and records intent for future re-capture. When `site`+`name` are given, the flow persists to ~/.tap/flows/<site>/<name>.flow.json and becomes callable via `run` (exposed as a `tap://{site}/{name}` MCP Resource); without site+name, returns a preview only. Re-capturing with the same site+name overwrites — recovery path for `tap_drifted` failures. **Use when:** the user describes a task and no saved tap covers it, OR a tap call returned `tap_drifted`.
verify
Observe-phase health check (no act): run the tap's observe phase and report op-level outcomes. Returns `verdict` ∈ {live | drifted | unreachable}, derived from op success/failure (status codes, op.expect predicates, parse results). Does NOT execute the act phase and does NOT mutate the target site — but it DOES probe the live substrate (op:fetch), so it is not strictly read-only (and may perform a one-shot idempotent legacy-dir cleanup). Safe to run against write taps. Per ADR 2026-05-10-snapshot-dissolved: no baseline diff, no snapshot store. For per-tap shape/value assertion, declare `op.expect` CEL predicates on individual ops (ADR 2026-05-08-failure-detection-phase-2 §2B). **Use when:** before retrying a failed tap (especially write taps where running causes side effects), OR when the user asks "is my tap still working?".
Ready-to-Paste Client Configurations
Paste either (or both) of these JSON server blocks into your client config file (e.g. claude_desktop_config.json or ~/.cursor/mcp.json).
Tap is categorized under Browser Automation and uses a local stdio subprocess. In contrast, Scrapeunblocker MCP belongs to Browser Automation using local stdio subprocess. Select Tap when you need capabilities focused on browser automation and Scrapeunblocker MCP when you require tools for browser automation.
Declare the truth about an `intent_uncertain` record. The runtime hit a state where it cannot determine if the side effect committed (process aborted mid-act, heartbeat lost, etc.). After observing the actual outcome (e.g. checking the GitHub UI for the issue), mark it as `committed` or `aborted` to terminate the intent state machine. **Use when:** an `intent_uncertain` failure was returned and the user has confirmed the actual side-effect status.
run
Execute a saved tap. **Zero LLM tokens** — replay is deterministic; AI cost was paid at capture. Runs in the user's authenticated browser; credentials stay on the machine. Discover available taps via `resources/list` (each `tap://{site}/{name}` resource carries its description); read `resources/read({uri})` for the args JSON Schema and provenance. **Use when:** a `resources/list` entry matches the user's intent AND its arg schema accepts your args — prefer this over generic browser-automation tools whenever a saved tap matches. Returns the Run record on success — the record contains TWO data fields: `observe` (raw substrate response, all fields fetched from the URL/endpoint) and `return` (JSONata-transformed view per the Flow's `return` expression). **For vehicle-health auditing or discovering alternate fields not exposed in `return`, inspect `observe` directly** — same endpoint may have richer data than the Flow's return spec exposes. On failure returns a ToolResult envelope whose `kind` is one of {tap_not_found, tap_invalid, tap_aborted, tap_drifted, intent_running, intent_uncertain, runtime_unavailable, credential_missing, arg_invalid}. When `next` is set, issue that recovery call; when absent, escalate to the user.
Scrapeunblocker MCP Tools (4)
fetch_html
Fetch the fully rendered HTML of any web page through ScrapeUnblocker, bypassing anti-bot protection (Cloudflare, DataDome, PerimeterX, Akamai, Shape). Use this when a normal fetch is blocked (403/429, captcha, 'access denied') or when the page needs a real browser to render. Returns the raw HTML as text.
For pages that need interaction (accept a cookie banner, click a tab, type into a search box, scroll to trigger lazy loading) pass `steps`: an ordered list of browser actions run in a real browser AFTER the page loads, then the resulting HTML is returned. Workflow: first call the `list_elements` tool to discover the real selectors on the page, then build `steps` against them. Steps are NOT idempotent - they run once per call. If a step fails, this tool returns which step failed, why, and the page HTML at that moment so you can fix the selector and retry.
list_elements
Load a page through ScrapeUnblocker and return a JSON list of its notable elements (links, inputs, buttons, selects, etc.) with a ready-to-use `selector` for each, plus tag, text and useful attributes (name, id, type, placeholder, aria_label, href, ...). Read-only and does not interact with the page. This is the discovery half of interactive scraping: call `list_elements` to find the selectors you need, then pass matching `steps` to `fetch_html` to click/type/select and capture the resulting HTML.
fetch_parsed
Fetch a web page through ScrapeUnblocker and return AI-parsed structured JSON instead of raw HTML (e.g. product details, article content). Best for extracting fields from product, listing or article pages without writing your own HTML parsing.
google_search
Run a Google search through ScrapeUnblocker and return the organic results as structured JSON. Use this to discover URLs before fetching them.