Provides web search capabilities via the Brave Search API, allowing AI agents to perform searches with custom parameters (count, country, language, freshness) using your own API key to avoid IP blocks.
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., "@web-tools-mcp-server search for recent tech news"
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.
Drop-in MCP replacement for Claude's native web_search and web_fetch tools. Solves the "failed to fetch" / "failed to crawl" errors caused by IP blocks and user-agent detection on Claude's default infrastructure.
┌──────────────────────────────────────────────────────────────────┐
│ web-tools-mcp-server │
│ │
│ web_search ──────► Brave Search API ($5/1k queries) │
│ Your own API key = your own IP = no blocks │
│ │
│ web_fetch ──────► Strategy: AUTO (default) │
│ │ │
│ ├─ 1. Direct fetch │
│ │ • Rotating real-browser User-Agents │
│ │ • Full browser headers (Sec-Ch-Ua, etc.) │
│ │ • Optional proxy (Bright Data / any) │
│ │ │
│ └─ 2. Jina Reader fallback (on 403/429/503) │
│ • Server-side JS rendering │
│ • Returns clean LLM-ready markdown │
│ • Free tier (no key needed) │
└──────────────────────────────────────────────────────────────────┘Related MCP server: ai-first-scraper-mcp
Problem with native tools | How this MCP fixes it |
Claude's IP is known and blocked by many sites | Your proxy IP (Bright Data residential) or at minimum your own server's IP |
Claude's user agent is detected as a bot | Rotates through 12+ real browser UAs with matching Sec-Ch-Ua headers |
JS-heavy sites return empty content | Jina Reader renders JS server-side, returns clean markdown |
"Failed to fetch" with no fallback | Auto strategy tries direct → falls back to Jina automatically |
Search results may be limited | Brave's 35B+ page index, you control the API key |
Node.js 18+
Brave Search API key — Get one here ($5 free credit/month)
Optional: Jina API key for higher rate limits — Get one here (free tier works without key)
Optional: Proxy URL (Bright Data, or any HTTP/SOCKS5 proxy)
# Clone or copy this directory
cd web-tools-mcp-server
# Install dependencies
npm install
# Build
npm run build
# Verify it compiled
ls dist/index.jsVariable | Required | Description |
| Yes | Brave Search API subscription token |
| No | Proxy URL for direct fetches. Format: |
| No | Jina Reader API key for higher rate limits. Free tier works without it. |
| No | Alternative to PROXY_URL (standard env var) |
| No | Alternative to PROXY_URL (standard env var) |
export PROXY_URL="http://brd-customer-XXXXX-zone-XXXXX:PASSWORD@brd.superproxy.io:22225"export PROXY_URL="http://brd-customer-XXXXX-zone-residential:PASSWORD@brd.superproxy.io:22225"Add to your Claude Code MCP configuration (~/.claude/claude_code_config.json or per-project .claude/config.json):
{
"mcpServers": {
"web-tools": {
"command": "node",
"args": ["/absolute/path/to/web-tools-mcp-server/dist/index.js"],
"env": {
"BRAVE_API_KEY": "your-brave-api-key-here",
"PROXY_URL": "http://user:pass@proxy:port",
"JINA_API_KEY": "optional-jina-key"
}
}
}
}Or using the CLI:
claude mcp add web-tools \
-e BRAVE_API_KEY=your-key \
-e PROXY_URL=http://user:pass@proxy:port \
-- node /absolute/path/to/web-tools-mcp-server/dist/index.jsEdit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"web-tools": {
"command": "node",
"args": ["/absolute/path/to/web-tools-mcp-server/dist/index.js"],
"env": {
"BRAVE_API_KEY": "your-brave-api-key-here",
"PROXY_URL": "http://user:pass@proxy:port",
"JINA_API_KEY": "optional-jina-key"
}
}
}
}Restart the Claude desktop app after saving.
web_searchSearch the web via Brave Search API.
Parameters:
query (string, required): Search query. 1-6 words recommended.
count (number, optional): Results count, 1-20. Default: 10.
offset (number, optional): Pagination offset. Default: 0.
country (string, optional): Two-letter country code (e.g., "us").
search_lang (string, optional): Language code (e.g., "en").
freshness (string, optional): Time filter — "pd", "pw", "pm", "py", or "YYYY-MM-DDtoYYYY-MM-DD".
web_fetchFetch a URL with anti-detection capabilities.
Parameters:
url (string, required): Full URL to fetch (must include https:// or http://).
strategy (string, optional): Fetch strategy. Default: "auto".
"auto": Direct fetch first, Jina Reader fallback on block.
"direct": Direct fetch only (UA rotation + proxy).
"jina": Jina Reader only (JS rendering, clean markdown output).
Is the site JS-heavy or known for aggressive anti-bot?
├── Yes ──► Use strategy="jina"
└── No
├── Do you have a proxy configured?
│ ├── Yes ──► Use strategy="auto" (default) — direct with proxy, Jina fallback
│ └── No ──► Use strategy="auto" — tries without proxy, Jina catches failures
└── Is it a raw API/JSON endpoint?
└── Yes ──► Use strategy="direct" — Jina would mangle the JSONThe user agent pool in src/constants.ts should be updated periodically to match current browser versions. Check whatismybrowser.com/guides/the-latest-user-agent for current strings.
Component | Cost | Notes |
Brave Search API | $5/1k queries | $5 free credit/month |
Jina Reader | Free tier | 1M tokens free, no key needed |
Bright Data (optional) | ~$8-15/GB residential | Pay-as-you-go available |
Typical monthly for light use | ~$0-5 | Under 1k searches + Jina free tier |
"BRAVE_API_KEY environment variable is required"
→ Set the BRAVE_API_KEY env var in your MCP config.
Direct fetch always returns 403
→ Configure PROXY_URL with a residential proxy (Bright Data), or rely on Jina fallback (strategy="auto").
Jina returns empty/garbage → Some sites block Jina too. Configure a Bright Data residential proxy and use strategy="direct".
"undici ProxyAgent could not be loaded"
→ Your Node.js version doesn't bundle undici properly. Run: npm install undici in the project directory.
MIT
Fetch multiple URLs in parallel with anti-detection capabilities. Much faster than calling web_fetch multiple times.
Use this after web_search to fetch the top 3-4 results in a single call instead of making separate web_fetch calls.
Args:
urls (string[], required): Array of URLs to fetch (max 10). Each must include https:// or http://.
strategy (string, optional): "auto", "direct", or "jina". Applied to all URLs. Default: "auto".
Returns: Combined results for all URLs, each with page content, HTTP status, strategy used, and content size. Failed URLs are clearly marked.
Example: urls=["https://docs.python.org/3/library/asyncio.html", "https://nodejs.org/en/docs/guides/event-loop"]
Inputs: urls (required), strategy.
Fetch the contents of a web page with anti-detection capabilities.
This tool replaces the native web_fetch. It uses rotating real-browser user agents, optional proxy (Bright Data or any HTTP/SOCKS5), and automatic fallback to Jina Reader API for sites that block direct access.
Three fetch strategies:
"auto" (default): Tries direct fetch first (with UA rotation + proxy if configured). If blocked (403/429/503/captcha), automatically falls back to Jina Reader.
"direct": Direct HTTP fetch only. Uses rotating browser user agents and your configured proxy. Returns raw HTML.
"jina": Uses Jina Reader API exclusively. Best for JS-heavy sites. Returns clean LLM-ready markdown. Handles rendering server-side.
For fetching multiple URLs at once, use web_bulk_fetch instead — it's faster and uses a single tool call.
Args:
url (string, required): The URL to fetch. Must include https:// or http://.
strategy (string, optional): "auto", "direct", or "jina". Default: "auto".
Returns: Page content (HTML for direct, markdown for Jina), HTTP status, final URL after redirects, and which strategy was used.
Inputs: url (required), strategy.
Search the web using the Brave Search API. Returns titles, URLs, descriptions, and snippets.
This tool replaces the native web_search with anti-detection capabilities — queries go through the Brave Search API with your own API key, avoiding IP blocks.
Args:
query (string, required): Search query. Keep it short and specific (1-6 words).
count (number, optional): Number of results, 1-20. Default: 10.
offset (number, optional): Pagination offset. Default: 0.
country (string, optional): Two-letter country code for localized results.
search_lang (string, optional): Language code (e.g., 'en').
freshness (string, optional): Time filter — 'pd', 'pw', 'pm', 'py', or 'YYYY-MM-DDtoYYYY-MM-DD'.
Returns: Search results with title, url, description for each result. Includes extra_snippets when available.
Examples:
"latest Node.js release" -> query="Node.js latest release", freshness="pw"
"Python asyncio tutorial" -> query="Python asyncio tutorial"
Inputs: query (required), count, offset, country, +2 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 3 tools
Each tool has a distinct purpose: web_fetch retrieves a single page, web_bulk_fetch retrieves multiple pages in parallel, and web_search performs a web search. There is no overlap between these operations; even web_fetch and web_bulk_fetch are clearly differentiated by the number of URLs they handle.
All tool names follow a consistent verb_noun pattern with a web_ prefix: web_fetch, web_search, web_bulk_fetch. The naming is predictable and clearly indicates the action and resource, with 'bulk' correctly modifying the fetch verb.
With only three tools, the set is well-scoped for a web utility server. Each tool covers a distinct primary use case (single fetch, bulk fetch, search), and the size is appropriate without being bloated or too sparse.
The tool surface covers the core operations for the domain: searching the web and fetching one or multiple pages, with strategy options (auto/direct/jina) for different anti-blocking needs. No obvious gaps for typical web research workflows, as pagination via count/offset is available in web_search.
Web search, browser automation, scraping, crawling and CAPTCHA solving for AI agents.
Agent-native internet gateway: typed search, fetch, scrape, crawl, and extract via the Clawifi API.
Web search and page reading for AI agents, including JSON APIs, RSS feeds and YouTube.
Web search, fetch, extract, and research for AI agents. Markdown output + AI-synthesized answers.
