browser-search-mcp
Allows searching the web via Baidu search engine using a real browser to extract structured results.
Allows searching the web via DuckDuckGo search engine using a real browser to extract structured results.
Allows searching the web via Google search engine using a real browser to extract structured results.
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., "@browser-search-mcpsearch for the latest AI research papers on arxiv"
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.
Browser Search MCP
Real browser search for AI agents. Browser Search MCP lets Claude Desktop, Cursor, Codex, Ollama, and other MCP clients search the web through Chrome/Edge, read result pages, expand vague user questions, and report whether the results actually match the user's intent.
Search like a real browser. Read like a research agent.基于真实浏览器的 MCP 搜索引擎服务器 - 让任何支持 MCP 的大模型都能搜索网页内容。 Browser Search MCP - Web search via real browser for any LLM.
Built on the same CDP extension bridge architecture as browser-takeover-bridge.
Launch Week
If you are discovering this project from a post, start here:
Install in 30 seconds:
pip install browser-search-mcpBest default tool:
web_researchPreview query expansion:
web_search_planUse cases: local agents, private research assistants, authenticated browser search, citation-ready page reading
Launch assets: Launch Week Plan and Ready-to-post copy
Why agents use it
Need | Browser Search MCP |
No search API key | Uses your browser by default |
Real web pages | Reads and cleans top result pages |
Vague user questions | Expands natural-language intent into search queries |
Quality control | Marks results as |
Private/local workflows | Runs as an MCP server on your machine |
Logged-in browser context | Can integrate with browser-takeover bridge |
Example: plan before searching
{
"query": "home projector vs TV which is better",
"intent": {
"topic": ["projector", "TV"],
"task": ["compare", "buying guide", "recommendation"]
},
"candidate_queries": [
"home projector vs TV which is better",
"projector TV comparison pros cons buying guide",
"projector TV comparison recommendation"
]
}Example: research-ready result
{
"ok": true,
"query": "2026 exam English study plan",
"quality": "strict",
"diagnostics": {
"missing_anchor_groups": []
},
"results": [
{
"title": "Example result",
"url": "https://example.com",
"page": {
"ok": true,
"content": "Cleaned page text for the agent..."
}
}
]
}Related MCP server: Google Search Tool
Why?
Local LLMs (Ollama, etc.) cant search the web. HTTP-based search tools get blocked by anti-bot measures. This project uses a real browser to search - no API keys, no blocking, no fake results.
Quick Start
pip install browser-search-mcp
# Start the MCP server
browser-search-mcp
# Optional CLI helpers
browser-search-mcp --help
browser-search-mcp status
browser-search-mcp doctor
browser-search-mcp http 9090Then configure in any MCP client:
{
"mcpServers": {
"browser-search": {
"command": "browser-search-mcp"
}
}
}Bridge Integration (browser-takeover extension)
When installed alongside the browser-takeover-bridge extension, browser-search-mcp automatically detects the extension and routes searches through it instead of launching a headless CDP browser.
Why use the bridge?
Authenticated sessions - search while logged into services (e.g., intranet, social media, internal tools)
Faster startup - no need to launch a new browser; reuses the extension's existing connection
Lower resource usage - share one browser session instead of spawning a separate headless instance
How it works:
LLM/Agent -> MCP Client -> browser-search-mcp -> bridge (extension) -> user's browser -> search engine
The bridge check runs automatically at startup. If the extension is not detected, the server falls back to the standard CDP path (launching its own browser). No configuration needed.
Detection: Run web_search_status to see if the bridge is active:
json { "bridge": { "available": true, "search_available": true } }
Quick Demo
Search the web in seconds from any MCP-compatible LLM:
pip install browser-search-mcp
browser-search-mcpLive search result (Bing, ~5s):
[
{
"title": "What is the Model Context Protocol (MCP)?",
"url": "https://modelcontextprotocol.io/",
"snippet": "MCP is an open standard for connecting AI applications to external systems."
},
{
"title": "MCP Server Guide",
"url": "https://example.com/mcp-guide",
"snippet": "Complete guide to setting up MCP servers for web search."
},
{
"title": "Browser Search MCP",
"url": "https://github.com/fangsylar-pixel/browser-search",
"snippet": "Open source MCP server using real browser for web search."
}
]No API keys required. No blocking. Just a real browser doing real searches.
Features
Feature | Status | Description |
Google, Bing, Baidu, DuckDuckGo | Yes | DOM + JS extraction |
Persistent browser session | Yes | Reuses CDP connection |
Result caching | Yes | LRU with configurable TTL |
Config file | Yes | JSON + env vars |
Auto-reconnect | Yes | Transparent reconnection |
browser-takeover bridge | Yes | Auto-detected extension bridge |
CAPTCHA detection | Yes | Auto fallback on CAPTCHA |
Engine fallback | Yes | Automatic on failure/CAPTCHA |
Deep mode | Yes | Auto-extracts top 2 result content |
Pagination | Yes | Multi-page search support |
Time filters | Yes | hour/day/week/month/year |
Intent planning | Yes | Platform/topic/task extraction plus query expansion |
Engine health check | Yes | Tracks per-engine availability |
Cross-engine dedup | Yes | Deduplicate multi-engine results |
API providers (Tavily/Brave) | Yes | Faster, API-key based |
HTTP API | Yes | FastAPI + OpenAI compatible |
Codex plugin | Yes | Auto-install as Codex plugin |
Fallback parsers | Yes | Text-based when JS fails |
Retry on failure | Yes | Exponential backoff |
MCP Tools
Tool | Description |
| Analyze intent and candidate queries without launching a browser |
| Search a single engine, returns JSON results |
| Search multiple engines simultaneously |
| Read structured page content for a URL |
| Search and read top result pages for citation-ready research |
| Check browser, bridge, and cache status |
| Find CDP-enabled browsers |
web_search_plan is useful before an expensive search: it returns parsed intent,
required coverage anchors, and expanded candidate queries for broad customer
requests such as creator topics, product comparisons, tutorials, trends, and
recommendations.
web_research is the best default for agents that need grounded answers. It rewrites
natural-language questions into search queries, retries across engines, filters
off-topic results, and labels result quality as strict or partial based on
whether the platform/topic/task anchors were covered. It also returns diagnostics,
cleaned page content for the top results, title, final URL, description, detected
publish time, and truncation metadata.
Configuration
Config file: ~/.browser-search-mcp/config.json
Browser Mode (default)
{
"browser": {
"name": "edge",
"headless": false,
"port": 9222
},
"cache": {
"enabled": true,
"ttl": 300
}
}API Mode (faster, needs API key)
{
"provider": {
"name": "tavily",
"tavily_api_key": "tvly-your-key-here"
}
}Environment Variables
Variable | Example | Description |
|
| Run browser headless |
|
| Choose provider: browser/tavily/brave |
|
| Tavily API key |
|
| Brave Search API key |
|
| Cache TTL in seconds |
|
| Default search engine |
|
| Browser executable name |
|
| CDP remote debugging port |
|
| Browser profile directory |
|
| Explicit browser executable path |
How It Works
LLM/Agent -> MCP Client -> browser-search-mcp -> Browser (CDP) -> Search Engine
| (optional)
browser-takeover extensionMCP server finds or launches a Chrome/Edge browser with remote debugging
Navigates to the search engine
Extracts structured results via JavaScript DOM parsing
Returns title, url, snippet as JSON
Results cached for 5 minutes by default
Project Structure
browser-search-mcp/
browser_search_mcp/
config.py Configuration via JSON file + env vars
cdp.py CDP browser control with persistent sessions
bridge.py Browser-takeover extension bridge client
search.py Search orchestration with caching and retry
parsers.py Text-based search result parsers (fallback)
bridge_provider.py Bridge-based search provider (optional, auto-detected)
providers.py API search providers (Tavily, Brave)
server.py FastMCP server with 5 search tools
http_api.py HTTP API server (FastAPI + OpenAI-compatible endpoint)
setup_assistant.py Prerequisites check
.codex-plugin/ Codex plugin packaging
.github/ CI and issue templates
website/ Promotional website (GitHub Pages)
README.md, CONTRIBUTING.md, LICENSE, SUPPORT.mdRequirements
Python 3.11+
Chrome or Edge installed
Optional: browser-takeover-bridge extension (for authenticated sessions)
License
MIT
Architecture
flowchart TB
subgraph User[User Environment]
LLM[LLM / Agent]
MCP[MCP Client]
end
subgraph Browser[Browser Layer]
BRIDGE[Bridge Extension]
CDP[Chrome/Edge CDP]
end
subgraph Search[Search Layer]
BSM[browser-search-mcp]
API_PROV[API Providers]
end
subgraph Engines[Search Engines]
G[Google]
B[Bing]
BA[Baidu]
D[DuckDuckGo]
end
LLM --> MCP --> BSM
BSM -->|Priority 1| BRIDGE --> CDP --> Engines
BSM -->|Priority 2| API_PROV --> Engines
BSM -->|Priority 3| CDP --> Engines
style BSM fill:#10b981,color:#fff
style BRIDGE fill:#6366f1,color:#fff
style API_PROV fill:#f59e0b,color:#fffSupport
If this project helps you, optional support is welcome:
Bug reports and contributions are welcome. See CONTRIBUTING.md and SUPPORT.md.
Available Tools
5 toolsweb_searchB
Search the web using a real browser and return structured results. Uses Chrome/Edge via CDP (same approach as browser-takeover-bridge) to navigate to the search engine, extract results from the DOM, and return them as structured JSON. When the browser-takeover extension bridge is available, searches use the extension's authenticated browser session instead of a headless browser -- giving access to logged-in content.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The search query string | |
| engine | No | Search engine: google, bing, baidu, or duckduckgo | |
| max_results | No | Maximum number of results to return (1-20) | |
| headless | No | Run browser in headless mode (no visible window) | |
| page | No | ||
| time_range | No | ||
| deep_mode | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility. It discloses the use of Chrome/Edge via CDP, DOM extraction, and two modes (headless vs. extension). However, it lacks details on rate limits, authentication requirements, error handling, or resource consumption.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured into two paragraphs, each adding distinct information. The first sentence is clear. It is not overly verbose, though some technical details (e.g., CDP) could be condensed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (7 parameters, siblings, output schema), the description covers core behavior but omits important context like error handling, browser availability, or limitations of DOM extraction. The existence of an output schema partially compensates for return value explanation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 57% (low), yet the description adds no meaning for the undocumented parameters page, time_range, and deep_mode. The description focuses on search engine and results extraction but does not clarify these three parameters, leaving the agent with no additional insight.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search the web using a real browser and return structured results,' providing a specific verb and resource. However, it does not explicitly differentiate this tool from siblings like web_search_multi or web_search_read_page, leaving some ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions that when the browser-takeover extension is available, the search uses an authenticated session, implying a usage condition. However, it does not explicitly state when to use this tool versus alternatives, nor provides exclusions or when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
web_search_discover_browsersA
Scan for browsers with CDP enabled on common ports.
Checks ports 9222, 9223, 9333 for Chrome/Edge instances with remote debugging enabled.
Returns: JSON list of discovered browser instances
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully bears the burden of behavioral disclosure. It details the ports checked (9222, 9223, 9333) and targeted browsers (Chrome/Edge with remote debugging), and states the return type (JSON list). This provides sufficient transparency about its read-only scanning behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (three sentences) and front-loaded with the core purpose. Each sentence adds value: purpose, port details, and return format. No superfluous content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and an existing output schema, the description covers all necessary aspects: what the tool does, how it does it (ports, browsers), and what it returns. It is complete without gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, and schema description coverage is 100%. The description does not need to add parameter details, and the baseline score of 4 applies as there is no missing information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool scans for browsers with CDP enabled on specific ports. It uses a specific verb ('Scan') and resource ('browsers with CDP enabled'), and the purpose is distinct from sibling tools like web_search or web_search_read_page, which focus on web content retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing to discover Chrome/Edge instances for remote debugging. It does not explicitly state when not to use or provide alternatives, but the context (sibling tools) and specificity make the intended use clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
web_search_multiA
Search multiple search engines and combine results. Searches multiple engines in sequence and returns combined results grouped by engine.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The search query string | |
| engines | No | Comma-separated list of engines (google,bing,baidu,duckduckgo) | google,bing,duckduckgo |
| max_results_per_engine | No | Results per engine (1-10) | |
| headless | No | Run browser in headless mode | |
| page | No | ||
| time_range | No | ||
| deep_mode | No | ||
| deduplicate | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that searches are performed 'in sequence' and results are 'grouped by engine,' which is useful. However, it does not mention failure handling, rate limits, or other behavioral traits that could affect agent decisions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences (21 words) that front-load the core purpose in the first sentence and add detail in the second. Every word earns its place, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists but is not described. The description covers the basic workflow of multi-engine search and grouping but omits details like error behavior, pagination across engines, or impact of parameters like 'deep_mode'. For a tool with 8 parameters, it is minimally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50%, but the description adds no additional parameter meaning beyond what the schema provides. Parameters like 'page', 'time_range', 'deep_mode', and 'deduplicate' remain unexplained in context of multi-engine search, leaving gaps for the agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches multiple search engines and combines results. It uses the verb 'search' and resource 'multiple search engines,' and distinguishes from sibling 'web_search' (likely single engine) by specifying multi-engine and grouping.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool (when you need results from multiple engines) but does not explicitly state when not to use it or mention alternatives. It provides enough context for an agent to differentiate it from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
web_search_read_pageA
Navigate to a URL and return the visible page text. Useful for reading the full content of a search result.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The URL to navigate to | |
| max_length | No | Maximum characters to return |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden. It only says 'return the visible page text' without disclosing behaviors like JavaScript execution, error handling, or limitations (e.g., paywalls, dynamic content). This is a significant gap for a navigation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action, and contains no redundant or extraneous information. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema (not shown but indicated), which reduces the need to describe return values. However, the description lacks details on error scenarios, permission requirements, or behavior with invalid URLs. It is minimally adequate for a relatively simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for both parameters (url, max_length). The description adds no extra semantic value beyond 'Navigate to a URL,' which is already implied by the tool name and schema. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Navigate to a URL and return the visible page text,' specifying the action (navigate, return) and resource (URL, page text). It distinguishes from siblings like 'web_search' which likely executes searches, and other tools with different scopes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes 'Useful for reading the full content of a search result,' giving a clear usage context. However, it does not explicitly state when not to use it or mention alternatives, so it scores slightly below the top tier.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
web_search_statusA
Check the current browser, bridge, and provider status.
Detects available CDP browser instances, checks if the browser-takeover extension bridge is running, and reports the active provider type.
Returns: JSON status information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully shoulders behavioral disclosure. It describes the detection actions and return type accurately. It could be improved by explicitly stating it is non-destructive and read-only, but the current description is reasonably transparent for a status check.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with three sentences, no fluff, and front-loads the main purpose. Every sentence provides necessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, an output schema exists, and the description covers the essential status-checking functionality, it is fully complete for its purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the description does not need to add parameter details. Baseline 4 is appropriate as it adds no superfluous information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it checks browser, bridge, and provider status, listing specific detection targets (CDP instances, bridge extension, provider type). It distinguishes well from sibling tools like web_search which perform searches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for checking status before other operations but provides no explicit guidance on when to use versus alternatives. No exclusions or conditions are mentioned.
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.
2 tool updates
v0.2.0- Changed
web_search3 fields changed- added
Input schema / properties / deep_modeAdded value: +{ + "default": false, + "type": "boolean" +} - added
Input schema / properties / pageAdded value: +{ + "default": 1, + "type": "integer" +} - added
Input schema / properties / time_rangeAdded value: +{ + "default": "", + "type": "string" +}
- Changed
web_search_multi4 fields changed- added
Input schema / properties / deduplicateAdded value: +{ + "default": false, + "type": "boolean" +} - added
Input schema / properties / deep_modeAdded value: +{ + "default": false, + "type": "boolean" +} - added
Input schema / properties / pageAdded value: +{ + "default": 1, + "type": "integer" +} - added
Input schema / properties / time_rangeAdded value: +{ + "default": "", + "type": "string" +}
5 tool updates
v0.1.0- First observed
web_search - First observed
web_search_discover_browsers - First observed
web_search_multi - First observed
web_search_read_page - First observed
web_search_status
TDQS
Scored across 5 tools
web_search and web_search_multi are related but clearly separated by the multi-engine behavior. web_search_status and web_search_discover_browsers overlap somewhat in browser inspection, but their purposes remain distinct. web_search_read_page is unambiguous.
Most tools use the web_search_ prefix with descriptive suffixes like multi, read_page, status, and discover_browsers. The base web_search tool lacks a suffix, but the pattern remains predictable and readable overall.
Five tools is well-scoped for a browser-based search server. Search, multi-engine search, page reading, status, and browser discovery each earn their place without unnecessary overlap or bloat.
The core workflow of searching, combining results, and reading pages is well covered. Browser status and discovery support the environment side. Minor gaps like explicit browser launch/close management exist, but they are outside the apparent search-focused purpose.
Maintenance
Related MCP Connectors
Web search, browser automation, scraping, crawling and CAPTCHA solving for AI agents.
AI-powered browser automation — navigate, click, fill forms, and extract data from any website.
The best web search for your AI Agent
Web search and page-reading for AI agents. One-click OAuth connect, or a Caesar API key.
Related MCP Servers
- AlicenseBqualityBmaintenanceEnables LLMs to interact with web pages, take screenshots, and execute JavaScript in a real browser environment10246299MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to perform real-time Google searches with anti-bot protection. Bypasses search engine restrictions using advanced browser automation to extract search results locally without requiring paid API services.7MIT
- AlicenseBqualityDmaintenanceEnables LLMs and AI agents to access real-time web data, search websites, and navigate the web without getting blocked. Includes 5,000 free monthly requests and supports web scraping, browser automation, and bypassing geo-restrictions.607,8691MIT
- FlicenseNot gradedqualityCmaintenanceUnlimited, session-authenticated web search and fetch for AI tools using your own browser. Supports authenticated/paywalled pages without API keys.-