ZenRows MCP

by ZenRows

184 downloads

Not rated

GitHub

About

ZenRows MCP lets AI agents scrape any webpage and return clean markdown, HTML, or structured JSON. Bypasses anti-bot protection, renders JavaScript (React/Vue/Angular), and supports premium residential proxies. Works out of the box — no local install required.

Details

Author: ZenRows
Downloads: 184
Categories: Web Scraping, Automation, Other

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name ZenRows MCP

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

From the repository

No local installation is required; the server works out of the box. It can be invoked by any MCP client to scrape web pages and return the desired output format.

`scrape`

Scrape any webpage and return its content using Zenrows (Fetch). Use for full-page content (markdown/HTML/PDF/screenshot). For structured JSON fields (products, articles, listings), prefer the extract tool when it fits — it returns parsed fields instead of a full page body. When to enable options: - js_render: page uses React/Vue/Angular, loads content dynamically, or content appears missing on the first attempt - premium_proxy: site returns 403/blocked errors even with js_render enabled - wait_for: specific content loads after initial render (requires js_render) Examples: Basic: { url: "https://example.com" } Dynamic: { url: "https://spa.com", js_render: true } Protected:{ url: "https://protected.com", js_render: true, premium_proxy: true }

`extract`

Extract structured data from a webpage via Zenrows. Prefer this over scrape when you need JSON fields (products, articles, listings) rather than a full page body. Modes: - auto (default): extract=auto — site-tailored Extract (open beta; currently free, billing may apply later; may fall back to autoparse if the domain is not enabled) - autoparse: general-purpose structured JSON on any domain - css: css_extractor with an explicit selector map Stealth: js_render, premium_proxy, proxy_country, or mode_auto (Adaptive Stealth Mode). For full-page markdown/HTML/screenshots, use scrape instead.

`batch_create`

Submit a cloud Batch job that fans out many URLs asynchronously (Zenrows Batch API beta). NOT the same as browser_batch — this hits https://async.api.zenrows.com/v1 with X-API-Key. Use for large URL lists; prefer scrape/extract for one-off pages. Returns job_id + latest_run.status/stats. Poll with batch_status / batch_wait, then batch_results. If you get BATCH_ACCESS_DENIED, the account lacks Batch beta access.

`batch_status`

Get status and stats for a Zenrows Batch job (latest_run.status + latest_run.stats).

`batch_results`

List result rows for a Batch job (cursor-paginated server-side; returns the full list). Each row may include task_id, external_id, status, and a short-lived result_url for the body. Download result_url soon — presigned links expire.

`batch_cancel`

Stop an in-flight Batch job run (POST /jobs/:id/stop).

`batch_wait`

Poll batch_status until the job reaches a terminal state (completed, stopped, or deleted).

`browser_navigate`

Open a Zenrows Browser Sessions session and navigate to a URL. This is the entry point for all browser automation. It creates a new session backed by Zenrows' anti-bot infrastructure and navigates to the given URL in one step. Returns a session_id that must be passed to every subsequent browser_* tool call. Always call browser_close when done to close the session and free resources. When to use options: - proxy_country: geo-restricted content (ISO 3166-1 alpha-2, e.g. "US", "DE") - proxy_region: world region for geo-targeted proxy (eu, na, ap, sa, af, me)

`browser_close`

Close a browser session and free all associated resources. Always call this when done to release the browser slot.

`browser_go_back`

Navigate back to the previous page in the browser history.

`browser_go_forward`

Navigate forward to the next page in the browser history.

`browser_reload`

Reload the current page.

`browser_click`

Click an element on the page using a CSS selector. Use browser_get_accessibility_tree first to find the right selector.

`browser_hover`

Move the mouse cursor over an element to trigger hover effects.

`browser_type`

Type text into an input element. Appends to existing content unless clear_first is set.

`browser_fill`

Clear an input field and set its value. Preferred over browser_type when replacing the full value.

`browser_select_option`

Select an option from a <select> dropdown element.

`browser_check`

Check a checkbox or radio button.

`browser_uncheck`

Uncheck a checkbox.

`browser_focus`

Move focus to an element, triggering focus-dependent UI changes.

`browser_press_key`

Press a keyboard key. Examples: "Enter", "Tab", "Escape", "ArrowDown", "Control+a".

`browser_scroll`

Scroll the page in a given direction.

`browser_drag`

Drag an element from its current position to a target element.

`browser_get_accessibility_tree`

Get the ARIA accessibility tree of the current page as readable text. Call this first after browser_navigate to understand the page structure before interacting with elements. More token-efficient than a screenshot for finding selectors and understanding layout. The tree shows all interactive elements (buttons, inputs, links) with their roles, labels, and states — everything needed to drive browser interactions.

`browser_get_url`

Get the current URL of the browser session.

`browser_get_title`

Get the title of the current page.

`browser_get_text`

Get the visible text content of an element or the entire page body.

`browser_get_attribute`

Get the value of a specific attribute on an element.

`browser_get_html`

Get the HTML source of an element or the full page.

`browser_query_selector_all`

Find all elements matching a CSS selector and return their text, HTML, and attributes.

`browser_screenshot`

Take a screenshot of the current page or a specific element. Use for visual verification or when the accessibility tree is not sufficient.

`browser_generate_pdf`

Render the current page as a PDF document.

`browser_wait_for_selector`

Wait until an element matching the CSS selector is stable in the DOM. Set visible=true to also require the element to be visible (not hidden).

`browser_wait_for_navigation`

Wait for the page to navigate to a new URL. IMPORTANT: call this BEFORE the action that triggers navigation (e.g. before browser_click on a submit button), not after — the navigation event may already have fired and this will hang until timeout. If the page stays on the same URL (AJAX/SPA), skip this tool entirely. Optional timeout_ms (default 30000ms).

`browser_wait`

Wait for a fixed duration. Use sparingly — prefer browser_wait_for_selector when possible.

`browser_evaluate`

Execute JavaScript in the browser context and return the result.

`browser_get_cookies`

Get all cookies for the current page.

`browser_set_cookies`

Set one or more cookies in the browser session.

`browser_clear_cookies`

Clear all cookies for the current browser session.

`browser_local_storage`

Read, write, or clear localStorage in the current page context.

`browser_new_tab`

Open a new browser tab. Returns a tab_id to use with browser_switch_tab.

`browser_switch_tab`

Switch focus to a different browser tab.

`browser_batch`

Execute a sequence of browser actions in a single call against an existing session. Use this when you already know the full sequence of steps — it reduces round trips and is faster than calling each tool individually. Actions run sequentially and stop at the first failure unless stop_on_error is false. Each step result is returned in the results array at the same index. Note: screenshots in batch results are returned as base64 strings inside the JSON. For proper image rendering, use browser_screenshot directly.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "zenrows mcp": {
            "zenrows": {
                "command": "npx",
                "args": [
                    "-y",
                    "@zenrows/mcp"
                ],
                "env": {
                    "ZENROWS_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

McpServers

{
    "zenrows": {
        "command": "npx",
        "args": [
            "-y",
            "@zenrows/mcp"
        ],
        "env": {
            "ZENROWS_API_KEY": "<YOUR_API_KEY>"
        }
    }
}

The Zenrows MCP (Model Context Protocol) server is the standard way AI systems use Zenrows' web data infrastructure. A single connection gives your AI assistant, agent, or application reliable, real-time access to the live web, including the protected web.

📚Full documentation:docs.zenrows.com/mcp/overview

- Reach sites that normally block bots.Get reliable access to protected sites at scale, without building anti-bot handling yourself.
- Managed web data infrastructure.Proxy rotation, headless browser orchestration, anti-bot handling, and session management run on Zenrows' infrastructure.
- Plug into any AI you already use.Works with any MCP client, including AI assistants, agent frameworks, AI SDKs, IDE plugins, and custom applications.
- Plain English, no scraping code.Describe the task naturally and the AI picks the right tool. No selectors, no proxy management, no anti-bot tuning.

Zenrows MCP supports two transport options. Both expose the same set of tools and capabilities. Pick the one that fits your client.

Use the hosted Zenrows MCP server when your AI application calls an LLM API directly. The server runs on Zenrows' infrastructure, so there is nothing to install, configure, or update.

Authentication:OAuth or API key as Bearer token. Pass your Zenrows API key in theAuthorizationheader on every request (or complete OAuth in clients that support it).

Authorization: Bearer YOUR_ZENROWS_API_KEY

Most MCP clients accept this through anauthorizationshorthand field on the tool config and forward it as the Bearer token automatically. Some clients use a free-formheadersfield instead. Either approach works.

Remote MCP doesnotauto-create accounts. Use OAuth “Create Free account” in the client, or pass an existing API key.

import os from openai import OpenAI ZENROWS_API_KEY = os.environ["ZENROWS_API_KEY"] client = OpenAI(api_key=os.environ["OPENAI_API_KEY"]) response = client.responses.create( model="gpt-5", tools=[ { "type": "mcp", "server_label": "zenrows", "server_description": "Web scraping MCP server for accessing live web content.", "server_url": "https://mcp.zenrows.com/mcp", "authorization": ZENROWS_API_KEY, "require_approval": "never", } ], input="Visit https://news.ycombinator.com/ and summarize the three most recent posts.", ) print(response.output_text)

For the full walkthrough with framework-specific examples, see theRemote MCP server docs.

Use the local stdio configuration when your MCP client runs the server as a local subprocess instead of calling a remote URL. This is the standard setup for desktop AI tools and IDE plugins, including Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, Zed, and JetBrains IDEs.
- ZENROWS_API_KEYenvironment variable, or
- Key previously stored in~/.zenrows/secrets.json, or
- Auto-signup(default): if neither is set, stdio provisions a Free plan account viaPOST /api/agent/signup, persists the key + claim metadata under~/.zenrows/(secrets.json+account.json, mode0600), and prints a claim URL on stderr. Opt out withZENROWS_AUTO_SIGNUP=false.

Requirements:Node.jsinstalled (fornpxto work).

{ "mcpServers": { "zenrows": { "command": "npx", "args": ["-y", "@zenrows/mcp"], "env": { "ZENROWS_API_KEY": "YOUR_ZENROWS_API_KEY" } } } }

{ "mcpServers": { "zenrows": { "command": "npx", "args": ["-y", "@zenrows/mcp"] } } }

The exact location of this config varies by client. See theper-client setup guidesfor the file path for your client.

The Zenrows MCP exposes these tool families:

The AI selects the right tool from your prompt. You don't call tools directly in code.

See the full tool referencefor every tool, parameter, and return value.

git clone https://github.com/ZenRows/zenrows-mcp cd zenrows-mcp npm install cp .env.example .env # Optional: add your API key (stdio can auto-signup) npm run dev # Run with .env loaded (requires Node.js 20.6+) npm run build # Compile to dist/ npm run inspect # Open the MCP inspector UI

- Full Zenrows MCP documentation
- Zenrows Fetch
- Zenrows Browser Sessions
- npm package
- Get your API key

Enable AI agents to get structured data from unstructured web with AgentQL.

Easy web data access. Simplified retrieval of information from websites and online sources.

Turn websites into datasets with Scrapezy

Scrapfly MCP Server gives AI agents a simple, unified way to scrape live web data with built-in anti-bot handling.

Interact with WebScraping.AI for web data extraction and scraping.

Retrieve structured data through natural language conversations

CrawlForge MCP is a production-ready MCP server with 18 web scraping tools for AI agents. It gives Claude, Cursor, and any MCP-compatible client the ability to fetch URLs, extract structured data with CSS/XPath selectors, run deep multi-step research, bypass anti-bot detection with TLS fingerprint randomization, process documents, monitor page changes, and more. Credit-based pricing with a free tier (1,000 credits/month, no credit card required).

A high-performance x402 intelligence gateway providing 20+ social and web endpoints. Powered by 6-stage routing logic—including cloud-rendered JS fetches, residential IP rotation, and automatic settlement refunds for blocked hosts. Built for AI Agents that require reliable, pay-per-request access to LinkedIn, Reddit, Instagram, and beyond without API key management

Scrape, crawl, and extract data from any website using the Firecrawl API.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

scrape

extract

batch_create

batch_status

batch_results

batch_cancel

batch_wait

browser_navigate

browser_close

browser_go_back

browser_go_forward

browser_reload

browser_click

browser_hover

browser_type

browser_fill

browser_select_option

browser_check

browser_uncheck

browser_focus

browser_press_key

browser_scroll

browser_drag

browser_get_accessibility_tree

browser_get_url

browser_get_title

browser_get_text

browser_get_attribute

browser_get_html

browser_query_selector_all

browser_screenshot

browser_generate_pdf

browser_wait_for_selector

browser_wait_for_navigation

browser_wait

browser_evaluate

browser_get_cookies

browser_set_cookies

browser_clear_cookies

browser_local_storage

browser_new_tab

browser_switch_tab

browser_batch

Claude Desktop / Cursor

McpServers

Install

More like this

@mendableai/firecrawl Mcp Server

Umut Naci

Playwright

Sequential Thinking

Filesystem

EverArt

`scrape`

`extract`

`batch_create`

`batch_status`

`batch_results`

`batch_cancel`

`batch_wait`

`browser_navigate`

`browser_close`

`browser_go_back`

`browser_go_forward`

`browser_reload`

`browser_click`

`browser_hover`

`browser_type`

`browser_fill`

`browser_select_option`

`browser_check`

`browser_uncheck`

`browser_focus`

`browser_press_key`

`browser_scroll`

`browser_drag`

`browser_get_accessibility_tree`

`browser_get_url`

`browser_get_title`

`browser_get_text`

`browser_get_attribute`

`browser_get_html`

`browser_query_selector_all`

`browser_screenshot`

`browser_generate_pdf`

`browser_wait_for_selector`

`browser_wait_for_navigation`

`browser_wait`

`browser_evaluate`

`browser_get_cookies`

`browser_set_cookies`

`browser_clear_cookies`

`browser_local_storage`

`browser_new_tab`

`browser_switch_tab`

`browser_batch`