Overview

ScrAPI MCP Server integrates the ScrAPI web-scraping service into the Model Context Protocol (MCP) ecosystem. It exposes two simple tools for retrieving page content — either as raw HTML or as Markdown — while handling common scraping obstacles such as captchas, anti-bot defenses, and geolocation-based restrictions. The server is useful when you need reliable access to pages that standard HTTP clients cannot fetch directly.

The server can run locally (Docker or npx) or be accessed via ScrAPI cloud endpoints. It supports optional browser automation steps (browser commands) so you can interact with a page before extraction — for example, accepting cookie banners, clicking “load more” buttons, filling a search input, or waiting for dynamic content to render.

Features

Two scraping outputs: HTML (structure) and Markdown (text-first)
Human-like browser interactions (random mouse movements, variable typing speed)
Browser commands: click, input, select, scroll, wait, waitFor, run JavaScript
Optional API key support for higher concurrency and quota
Cloud endpoints (SSE and streaming HTTP) and a Docker / NPX distribution
MIT-licensed, open-source repository: https://github.com/DevEnterpriseSoftware/scrapi-mcp

Installation / Configuration

Run via Docker (recommended for production/local isolation):

Build:

docker build -t deventerprisesoftware/scrapi-mcp -f Dockerfile .

Run:

docker run -i --rm -e SCRAPI_API_KEY=your_api_key_here deventerprisesoftware/scrapi-mcp

Run via NPX (quick start):

npx -y @deventerprisesoftware/scrapi-mcp

Configure for Claude Desktop (example snippets for claude_desktop_config.json):

Docker entry:

{
  "mcpServers": {
    "ScrAPI": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "SCRAPI_API_KEY",
        "deventerprisesoftware/scrapi-mcp"
      ],
      "env": {
        "SCRAPI_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}

NPX entry:

{
  "mcpServers": {
    "ScrAPI": {
      "command": "npx",
      "args": [
        "-y",
        "@deventerprisesoftware/scrapi-mcp"
      ],
      "env": {
        "SCRAPI_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}

Notes:

An API key from https://scrapi.tech is optional. Without one you are constrained to limited concurrent calls and a small daily free quota.
Cloud endpoints (read-only) are:
- SSE: https://api.scrapi.tech/mcp/sse
- Streamable HTTP: https://api.scrapi.tech/mcp

Available Tools

Two main tools are exposed by the MCP server:

scrape_url_html
- Purpose: Retrieve the target page rendered HTML (good when you need DOM structure or to run custom parsing).
- Inputs:
  - url (string, required)
  - browserCommands (string, optional) — a JSON array expressed as a string
- Returns: HTML string of the final rendered page
scrape_url_markdown
- Purpose: Retrieve the main textual content of the page as Markdown (good when text extraction is primary).
- Inputs:
  - url (string, required)
  - browserCommands (string, optional) — a JSON array expressed as a string
- Returns: Markdown string of the page content

Example tool invocation payload (conceptual JSON for an MCP client):

{
  "tool": "scrape_url_html",
  "inputs": {
    "url": "https://example.com",
    "browserCommands": "[{\"click\": \"#accept\"}, {\"waitfor\": \"#main\"}]"
  }
}

Browser Commands

Browser commands let the headless browser perform interactions before extraction. They are provided as a JSON array string. The automation uses human-like behavior by default.

Available commands:

Command	Example JSON	Description
Click	{“click”:“#buttonId”}	Click element by CSS selector
Input	{“input”:{“input[name=‘email’]”:“[email protected]”}}	Fill input fields
Select	{“select”:{“select[name=‘country’]”:“USA”}}	Select dropdown by value/text
Scroll	{“scroll”:1000}	Scroll by pixels (negative to scroll up)
Wait	{“wait”:2000}	Wait milliseconds (max 15000)
WaitFor	{“waitfor”:“#elementId”}	Wait for element to appear in DOM
JavaScript	{“javascript”:“return document.title”}	Execute JS in page context (return value optional)

Example browserCommands array:

[
  {"click": "#accept-cookies"},
  {"wait": 1500},
  {"input": {"input[name='q']": "web scraping"}},
  {"click": "button[type='submit']"},
  {"waitfor": "#results"},
  {"scroll": 500}
]

Important:

Provide the browserCommands value as a stringified JSON array when passing to the tool.
Wait time maximum is 15000ms per wait command.

Use Cases

Bypass geolocation locks: fetch content as if the request originated from a specific region (ScrAPI supports location routing).
Bypass simple captchas and anti-bot flows by automating consent clicks, form submissions, and timed waits before extraction.
Extract article content and convert to Markdown for downstream NLP, summarization, or indexing workflows.
Load dynamic pages (single-page apps) that require clicking and scrolling to populate content before scraping.
Collect search results across pages by automating pagination buttons and waiting for results to render.

Concrete example:

Objective: Extract search results text from a site that shows a cookie dialog, requires a query, and then loads results.
- browserCommands: click cookie accept, fill search field, submit, wait for results, scroll to load more.
- Tool: scrape_url_markdown to get cleaned textual content ready for processing.

Troubleshooting & Tips

If results are empty, add a longer wait or a waitfor for a specific selector that indicates content is present.
Use CSS selectors from your browser devtools or helper extensions (e.g., selector tools) to target elements.
Monitor rate limits if you run without an API key; obtain a key from ScrAPI for higher concurrency and throughput.
For programmatic testing, use MCP Inspector or a compatible MCP client to exercise the server and inspect logs.

License and source:

MIT License. Source code and issues: https

ScrAPI MCP Server for Captcha and Geolocation Bypass