Best MCP Servers for Internet Search with Claude Code

Overview: The Model Context Protocol (MCP) is an open standard that connects AI assistants with external tools and data sources in a uniform way. In essence, MCP acts like a “USB-C port” for AI applications, allowing models like Anthropic’s Claude to plug into various services (databases, file systems, web APIs, etc.) through MCP servers. Claude Code – Anthropic’s agentic coding assistant that runs in your terminal – can function as an MCP client, connecting to multiple MCP servers to extend its capabilities beyond code generation. By configuring MCP servers in Claude Code, you enable Claude to perform actions such as searching the internet, browsing files, querying databases, and more, all via a standardized interface. Claude Code supports both streaming HTTP (Server-Sent Events) and local process (stdio) MCP connections for real-time data flow, and includes user safeguards (e.g. requiring confirmation before file changes) when using these powerful tools.

When it comes to internet search, several MCP servers – both open-source and commercial – can equip Claude with browsing and information-retrieval powers. In this report, we examine the leading MCP servers for web search, comparing their performance, features, extensibility, and suitability for different use cases. We then provide recommendations tailored to individual developers, researchers, and enterprise teams.

MCP and Claude Code Integration

What is MCP? The Model Context Protocol defines a client-server architecture for tool use. An MCP server wraps an external service or data source behind a common protocol (with defined actions, or “tools”), while an MCP client (like Claude Code or other AI agent frameworks) connects to the server to invoke those tools. In practice, MCP servers expose resources (which Claude can reference via an @server:resource syntax in prompts) and tools (operations Claude can call, often via special “slash” commands). For example, a GitHub MCP server might expose repository files as resources and provide tools like list_prs or open_issue. When Claude Code is connected to such a server, you could ask: “Please analyze @github:issue://123 and suggest a fix,” and Claude will fetch the issue content via MCP.

Claude Code’s use of MCP: Claude Code simplifies integrating these servers. You can add servers via the CLI (claude mcp add …) or config files. Claude Code then manages connecting to each server in the background. It will automatically list available MCP tools and resources (e.g. pressing @ shows MCP resources in auto-complete). When the model needs information (like to answer a query about current events or to retrieve documentation), it can call the appropriate MCP tool. In the case of web search, an MCP server provides a tool (often named “search”) that Claude can invoke with a query; the server executes the search and returns results which Claude can use to formulate an answer. This mechanism allows Claude to conduct internet searches within its conversation, despite the core model being static. Anthropic explicitly cautions users to trust but verify third-party MCP servers, especially those connecting to the internet, due to the risk of malicious content or prompt-injection in retrieved data docs.anthropic.com. Proper sandboxing and user confirmation (for actions like opening links or running code) mitigate these risks.

With that context, we now turn to the MCP servers best suited for enabling Claude’s web browsing. We’ll assess both open-source solutions that you can self-host, and commercial services offering managed search APIs, as summarized in Table 1 below.

Comparing Internet Search MCP Servers

Table 1: Key MCP Servers for Internet Search – features and requirements. These servers enable Claude to perform web searches by interfacing with various search engines or services. “Open-source” indicates you can self-host the connector; many open-source implementations still require an API key for the third-party service.

Discussion of Comparison

From the table and sources above, we can draw several insights:

• Open-Source Solutions (No API Key Required): Web Search MCP and Open-WebSearch MCP allow immediate, free setup of internet search in Claude Code. They achieve this by scraping search engine result pages. The Web Search MCP by “pskill9” targets Google and returns clean JSON results (title, URL, description). It’s very simple to set up – essentially running a Node script – and requires no credentials. However, because it scrapes Google’s HTML, it is vulnerable to rate limiting and layout changes. Users have reported that heavy use can trigger Google’s bot detection, causing the tool to fail until cooled down. This limitation means the Google-scraping approach is best for light, interactive use (a few queries at a time). You should avoid rapid-fire queries or incorporate delays to be safe. Despite these caveats, many find the free Google results worth the trade-off – Google’s search quality is still arguably unmatched.

The Open-WebSearch MCP extends the free approach by using multiple search engines in tandem. According to its documentation, it supports Bing, DuckDuckGo, Brave, Baidu, and more, cycling through them to retrieve results without relying on a single provider. This multi-engine strategy improves robustness: if Google or one engine starts blocking or skewing results, others can fill in. Open-WebSearch also supports an HTTP/SSE server mode, meaning you can run it as a background service (including via Docker) and stream results to Claude as they arrive. In practice, users </current_article_content>find that Open-WebSearch yields a decent blend of results; for example, Bing and Brave might provide summaries or different coverage that complements Google. It even has the ability to fetch full articles from certain sites (like CSDN, a programming forum) when those appear in results – essentially combining search and scrape for deeper context. The trade-off is that results might be less consistent than a single-engine approach, and the setup is slightly more involved (running a local server on port 3000). Still, for a completely free and extensible solution, Open-WebSearch MCP is a strong choice. It’s maintained actively (supporting new engines via updates) and even allows configuring proxies, which can help with geo-specific searches or avoiding IP blocks.

• Official API-Based Search (Reliable, Moderate Cost): Using an official search engine API tends to offer more stability and speed at the cost of API quotas. Brave Search MCP is an example endorsed by Anthropic: it’s part of the official modelcontextprotocol/servers repository and was highlighted in early Claude Code demos. Brave Search operates its own independent web index (privacy-focused), so it doesn’t rely on Google or Bing results. This makes it an attractive alternative for those who want high-quality results without scraping. Setting it up involves obtaining a free API key from Brave (which requires registering an account). Brave offers a generous 2,000 queries per month free, with one query per second throughput on the free tier. In practice, that’s plenty for personal or development use. If more capacity is needed, Brave’s paid plans are fairly inexpensive ($3 per thousand queries, scaling up to millions of queries). Performance-wise, Brave’s API is fast – typically sub-second to a couple seconds per query – since it returns JSON results directly from their servers. The result quality is generally good for popular or factual queries, though some users note that Google’s relevance is still higher in certain long-tail searches. Brave does support advanced filters (called Goggles), and the MCP server may allow passing special parameters to refine searches (e.g. code-related queries). Overall, using Brave via MCP is a low-friction, safe way to give Claude current web search, especially if you prefer not to worry about scraping issues or want to support a Google-alternative.

Another API option is Google Custom Search (CSE). Google offers an official JSON API for search, but it requires you to set up a Custom Search Engine ID (which can be configured to search the entire web) and enable the API in a Google Cloud project. This is more upfront work (including adding a credit card for Google Cloud, even to use the free quota). The benefit is direct access to Google’s results with high reliability and up to 100 queries per day at no cost. Several community MCP servers have been created to use Google CSE – for example, one by limklister on GitHub that the Claude user community cites. With CSE, after the free daily 100 queries, costs are $5 per 1000 queries (with Google’s 10k/day cap), which is reasonably affordable. This path is recommended if you must have Google-quality results and are okay with a bit of configuration. When comparing Google’s API to Brave’s: Google’s results can be more relevant for technical documentation or very recent news (Google’s index is extremely comprehensive), whereas Brave is sufficient for many general purposes. Some users actually opt to set up both and use Brave for most queries, falling back to Google API for tougher cases – but within Claude Code, that would mean configuring two MCP servers and knowing when to invoke each, which complicates the workflow. If simplicity is the goal, choose one: Brave API for hassle-free setup vs. Google API for maximum search quality.

• AI-Powered Search Engines: A new category of search, exemplified by Perplexity’s Sonar API, blends large language models with live web data. The Perplexity Ask MCP server (developed by the Perplexity team and open-sourced) allows Claude to delegate a question to Perplexity’s backend. Perplexity’s model will perform its own multi-step search on the internet and return a synthesized answer with cited sources. Essentially, Claude can leverage Perplexity as an agent to do research on its behalf. The upside is that the returned information is already summarized and contextualized – often saving tokens and time. For example, if you ask Claude (with the Perplexity MCP enabled) a question like “What were the latest findings of the James Webb Telescope?”, Claude could call the Perplexity tool, which might return a two-paragraph answer citing a NASA press release and a news article from last week. Claude can then incorporate that answer into the conversation (with proper attribution). This is powerful for question-answering use cases where the user wants a quick, authoritative response with references. It also mitigates some prompt-injection risk, since Perplexity’s model will filter and interpret the raw web content, rather than dumping potentially malicious text directly to Claude.

The downsides are that this approach is somewhat a black box – you’re trusting Perplexity’s summaries – and it may not be suitable if you need to independently verify or analyze raw data. Additionally, the Sonar API is a paid service. Perplexity advertises it as relatively affordable, and indeed it’s geared towards developers (with tiers like Sonar vs Sonar Pro). The exact pricing isn’t publicly listed in the docs we reviewed, but likely it involves a subscription or per-query fee (Perplexity Pro accounts currently cost around $20/month for unlimited personal use, which gives an idea). Enterprises can get custom plans for Sonar API. From a performance perspective, Perplexity is quite fast considering it’s doing on-the-fly reasoning – simple queries may return in 2-3 seconds, complex ones a bit longer. They also provide features like source customization (you could ask it to focus on certain domains) and more citations in the higher-tier version. The Sonar Pro tier’s ability to handle multi-step queries and larger context is useful if you expect Claude to ask broad or multifaceted questions via this tool (e.g. a market research query that needs combining information from multiple articles). In summary, Perplexity’s MCP server is ideal for “research assistant” style interactions, where Claude essentially outsources web research and gets back a digested answer. It’s less applicable if you need Claude to fetch a specific piece of raw data or do step-by-step web navigation – those cases are better served by the direct search + crawl solutions below.

• Enterprise-Grade Web Access (Search + Crawl): For advanced use cases – such as integrating Claude into business workflows that require extensive web data gathering, competitive intelligence, or monitoring – services like Bright Data (and to a lesser extent, Firecrawl or Apify) shine. Bright Data’s MCP server is an open-source project with nearly 1k stars, reflecting the interest in a robust connector for their platform. Unlike the simpler search-only tools, Bright Data MCP is more like a Swiss Army knife for web data: it provides a Search tool (which queries major search engines through Bright Data’s SERP API), but also Crawl and Browser tools to retrieve full page content, follow links, and even simulate user interactions in a headless browser. In effect, Claude can use Bright Data to search for relevant pages, then automatically crawl those pages for deeper information, all while benefiting from Bright Data’s large proxy network to avoid IP blocking and geo-restrictions. For example, if tasked with analyzing a competitor, Claude (via Bright Data MCP) could search for the competitor’s product, find news articles, then fetch those article pages, and possibly even log into a web app or scrape a pricing table – tasks that go beyond a normal search engine. Bright Data’s solution is high-performance and scalable. The SERP API can retrieve results from Google, Bing, Yahoo, etc., in real-time and in parallel. The pricing of $1.05 per 1,000 search requests is reasonable for enterprise volume (roughly $0.001 per query), but keep in mind this does not include the additional data retrieval; crawling pages has its own cost (they charge by data or requests for their other APIs). The service is pay-as-you-go, so an organization can scale up usage as needed. Importantly, Bright Data is a trusted vendor in the web scraping space, with compliance measures and a legal team ensuring the data collection stays within acceptable use (they provide a SOC 2 Type II certified platform, similar to Firecrawl’s compliance badge). Enterprises concerned about legality or security of scraping often prefer using such vetted services rather than rolling their own scraper.

The Bright Data MCP server can be deployed in a cloud environment or alongside Claude Code. A typical deployment might be to run the MCP server on an AWS EC2 or Docker container, configured with your Bright Data API token, and then point Claude Code to that server (via its URL). Since Claude Code supports remote HTTP/SSE servers, team members could share a single Bright Data MCP endpoint as well. Security in this model is twofold: (1) You must secure your Bright Data API key and endpoint (using HTTPS and possibly organizational proxies). (2) You rely on Bright Data’s compliance – they handle CAPTCHAs and bot detection in a way that is unlikely to inject malicious content, but theoretically any web page content fetched could contain scripts or payloads. Claude Code will treat fetched text as data (not executing scripts), and Bright Data’s API typically returns text or structured data (JSON), so the risk is mostly on the prompt content side. As always, one should sanitize or have Claude summarize external text before directly following any instructions from it.

Besides Bright Data, Firecrawl is an emerging alternative that also offers an MCP server for web data. Firecrawl focuses on ease of use – the setup is a single claude mcp add command with an NPM package and API key firecrawl.dev. It provides both search and scraping capabilities, claiming to handle dynamic content (JavaScript-heavy sites) as well. Some developers prefer Firecrawl for quick projects, as it has a friendly “playground” UI and templates for common tasks firecrawl.dev firecrawl.dev. However, as a startup service, its search results quality and coverage might not match Bright Data or Perplexity – it’s likely using a combination of Bing for search and its own crawlers for data extraction. Firecrawl’s pricing is not openly listed, but presumably they have a free tier or trial and then usage-based fees. For an enterprise, Firecrawl is less battle-tested than Bright Data, but for a developer or small startup, it could be a convenient middle ground: more capability than a free scraper, but simpler and possibly cheaper than Bright Data for moderate use. Additionally, Apify (a web scraping platform) has an MCP integration which can be extremely powerful if you need to run custom scraping workflows (Apify Actors) through Claude. For instance, one could trigger an Apify actor that does a complex search & scrape job and returns results to Claude. That said, using Apify via MCP is more specialized and would appeal to those already invested in Apify’s ecosystem.

Technical Considerations

Enabling internet search in Claude Code via MCP requires attention to a few technical details:

• Networking & Protocol Support: Claude Code can connect to MCP servers running locally (as subprocesses) or remotely (over HTTP/SSE). Local servers (like the simple Node.js ones) use stdin/stdout by default – the claude mcp add <name> <command> launches the server and pipes data. This is straightforward for single-user setups. Remote servers (like a team-shared Bright Data service) should be added with --transport http or --transport sse and a URL. SSE (Server-Sent Events) is particularly useful for search: an engine can stream partial results or list items as it finds them. Open-WebSearch, for example, opens an SSE stream at /sse for incremental result delivery. Claude Code natively supports this, meaning Claude can start formulating an answer while more results are still arriving, improving responsiveness. Not all servers implement SSE; most API-based ones (Brave, Google, Perplexity) return a batch of results. If using an HTTP server without SSE, Claude Code will wait for the full response before proceeding. In terms of networking, ensure your firewall or environment allows the connections (Claude Code will need internet access to call the search APIs or the MCP server needs internet). If operating in a corporate setting, you might route traffic through a proxy – Claude Code’s docs note that it supports a corporate proxy configuration for outgoing calls.

• Language Bindings & Extensibility: Most of the MCP servers we discussed are written in Node.js (JavaScript/TypeScript), often distributed via npm packages for easy install (npx -y <package> as shown in many examples). This is convenient for Claude Code (which itself is Node-based). However, MCP servers can be built in any language – what matters is they adhere to the protocol (usually communicating JSON over stdin/stdout or HTTP). If your team prefers Python, for instance, you could use the MCP specification to write a Python-based web search server. In fact, Context7, a tool for fetching programming docs, is implemented in Python and integrates via MCP. For the servers in this report, you will mostly use Node. Bright Data’s SDKs cover multiple languages for direct API use, but their MCP server is in Node (they provide a Docker image as well). Perplexity’s connector and Brave’s are in Node. The takeaway is that developers have flexibility – you can fork or modify open MCP server code to add features (e.g. add a new search engine to Open-WebSearch, or add custom filtering of results before returning to Claude). This extensibility is a key advantage of MCP’s open standard. Organizations can build internal MCP servers to interface with proprietary data or specialized search tools, and use them alongside these public web search servers.

• Context Window and Data Limits: When Claude performs a search and gets back results, how much can it take in? Claude 2 (Opus 4) has a very large context window (100K tokens), but Claude Code might be using models like Claude 3.5/4 with 16K or 100K context depending on version. The MCP server results count and content should be tuned with that in mind. For example, returning 10 full web pages of text would obviously overflow any context. Good practice (reflected in these servers) is to return snippets or summaries. The Web Search MCP returns just title and snippet (a few lines each). Perplexity returns a concise answer (maybe a couple hundred words). Bright Data’s search tool returns just titles, URLs, and short excerpts by default; you would then explicitly use its “crawl” tool if you want more from a particular URL. This two-step approach – search then selective retrieval – is recommended to maximize relevance and avoid flooding Claude with too much data. Claude Code’s interface also shows MCP fetched content as attachments or references, allowing you to scroll through if needed, but Claude itself will only consider what’s included in the prompt it constructs. Throughput is another aspect: if an agent loop triggers many searches or large fetches, you could hit API limits or slow down responses. For instance, a chain-of-thought approach might naively fire off 5 search queries in parallel; Brave’s free tier would choke on >1 QPS. Sequential use or batching within one query is safer. Some MCP servers (like Sequential Thinking tool) were created to help LLMs reason step-by-step – Anthropic suggests using those instead of excessive internet queries for complex tasks when using Claude 3.7 Extended mode. In short, the design of your prompts/agent should be mindful of how and when to call the search tool, to stay within rate limits and preserve latency.

• Authentication & Security: Each API-based server needs a key or token, which you typically provide via an environment variable in the MCP config (as shown in the config snippets above for Brave and Firecrawl firecrawl.dev). Claude Code supports OAuth flows for MCP too, but for search APIs, a simple API key header is usually used. It’s important to not hard-code secrets into any shared project config; use user-level scope for these servers so that keys live in your local ~/.claude.json (Claude’s global config) rather than in a project file under version control. Regarding security models, using a managed API (Brave, Google, Perplexity) means your queries and possibly some user data are sent to those third parties. If confidentiality is a concern, consider self-hosted solutions. A self-hosted scraper like Open-WebSearch still sends queries to engines, but without disclosing the full conversation context. Claude will only send the query string to the MCP server, not any private user code or data around it, unless you explicitly include that in the search query. So leakage risk is low, but not zero: e.g., if you ask “Search for companies similar to ”, you just exposed that project name to the search engine. Policy tip: for enterprise settings, implement a filter that intercepts search queries to prevent accidental inclusion of secrets. One could even modify an MCP server to ignore or warn on queries that look like they contain a company’s internal code or IDs.

Finally, all retrieved data should be treated as untrusted content. Claude’s judgment is generally good at not executing code from an answer or not taking malicious text as directives, but prompt injection via a web page is a real possibility (a webpage could include hidden instructions like “Ignore previous directions” in some HTML comment that a naive scraper might capture). A defense-in-depth approach is advisable: have Claude request summaries of pages rather than raw dumps when using these tools. The Claude Code UI also visually separates fetched content and typically does not execute any HTML/JS, so the main risk is only if the model is tricked by text. Anthropic’s model has some safety training against that, and you as the user/operator remain in control – you can always verify sources that Claude cites from its search.

Use Case Recommendations

Given the above analysis, here are our recommendations for the “best” MCP web search server, recognizing that “best” depends on your specific needs:

• For Individual Developers / Enthusiasts (budget-conscious): Open-WebSearch MCP is the best starting point. It’s free, relatively easy to run, and its multi-engine approach offers a balance of reliability and result diversity. You won’t need to sign up for any API keys, and you can tweak the code if you’re adventurous. If you prefer sticking to Google results and don’t mind occasional hiccups, the simpler Google-scraping Web Search MCP is also effective, but expect to occasionally update it or deal with blocks. Both of these keep your costs at $0 and your setup local. If you do have a bit of budget or prefer not to worry about scraping at all, Brave Search MCP with the free tier API key is an excellent low-friction alternative – we’d recommend this for most hobbyists who just want a dependable way to ask Claude factual questions or do lightweight research on current events. The result quality is usually sufficient, and you avoid the risk of getting shut out by Google for scraping.

• For Coding/Research Assistance: If your main use case is using Claude Code to assist in programming or academic research, you likely want authoritative answers with citations. Here, Perplexity’s Ask MCP shines. It essentially gives Claude the superpower of an expert research assistant that can pull in up-to-date information with sources. For example, when coding, you might ask “Has this Python library fixed bug X in recent releases?” – Claude (via Perplexity) could return a summary from release notes or GitHub issues. This saves you from manually opening browser tabs. The caveat is cost and dependency on an external LLM service: ensure you have a Perplexity API access (the Pro plan if needed) and monitor usage. If using Perplexity isn’t feasible, an alternative is Context7 MCP (if your searches are primarily for documentation/code examples) – Context7 is designed to fetch latest documentation for APIs and libraries. It’s a specialized tool (e.g., pulling official docs for Python, JavaScript, etc., without general web noise). In combination, one might use Context7 for code-related “searches” and a general search for everything else. But if choosing one, Perplexity’s broader ability and quality make it the best for research-oriented queries.

• For Enterprise / Production Applications: Bright Data MCP is our top recommendation. Its comprehensive feature set (search + browse + scrape), scalability, and vendor support make it suited for enterprise deployments. You can integrate Claude (or any AI agent built on Claude’s API) with Bright Data to enable use cases like automated news monitoring, competitor website analysis, or customer review aggregation – tasks where the AI regularly pulls lots of web data and distills insights. Bright Data’s service model (API with strong uptime guarantees, compliance assurances, and support) aligns with enterprise needs. While there is a cost, it’s usage-based and can be optimized (e.g., you might schedule certain queries during off-peak times, or reuse results via caching on your side if the same info is needed repeatedly). The ease of handling edge cases (CAPTCHA, IP blocks) is a major reason to choose Bright Data over trying to maintain your own scraping infrastructure. Additionally, Bright Data’s MCP server is open-source; even if Bright Data as a company were a concern, one could adapt the code to use a different proxy network or in-house tools. This gives a level of future-proofing. For internal security, you can deploy the MCP server within your network (calls from Claude to the server stay internal; the server then makes outbound web requests). This isolation, plus options to restrict which URLs or domains the server may access, form a solid security model.

It’s worth noting that Firecrawl could be a fit for startups or teams that need web search/scraping but find Bright Data’s scale or pricing overshooting their needs. Firecrawl’s integration is user-friendly and it emphasizes structured data extraction (they tout “no more hallucinations – ground your AI with real web data” as a benefit, likely by providing clean extracted facts) firecrawl.dev. If Bright Data is a heavyweight solution, Firecrawl is more lightweight and might be more cost-effective at small scale. However, it’s less proven, so for mission-critical use we lean towards Bright Data or even a hybrid approach (e.g., use the Apify MCP alongside Claude for specific scripted tasks that an AI alone might struggle with – Apify could handle, say, logging into a site and retrieving data, then pass it to Claude for analysis).

• Privacy-Sensitive or Offline Scenarios: There are cases where even hitting the public internet is problematic (e.g., confidential projects where queries themselves are sensitive). In such cases, obviously an “internet search” might be disallowed entirely. But one could envision using MCP with a closed data source – for example, a local archive of web data or an internal search engine. If that applies, the MCP framework still helps: you could implement a custom MCP server that queries your internal knowledge base or a self-hosted index (like an offline Wikipedia or Common Crawl subset). For anything truly offline, the OpenMemory MCP or similar could be considered, but those are more for persistent agent memory rather than search. Generally, if internet access is not permitted, you’re outside the scope of these specific tools. If limited access is allowed but privacy is key, using Brave (self-hosted) or Google API with strict controls is advisable over using third-party LLM services. With Google CSE, you at least know the queries are going to Google’s servers and nowhere else, under terms of your enterprise agreement. With Perplexity or Bright Data, you introduce another party. All the commercial providers in this space (Anthropic included) have usage policies and data handling commitments, so it comes down to your risk tolerance and possibly regulatory compliance.

Conclusion: To empower Claude Code with internet search, the “best” MCP server depends on your context. For most users experimenting with Claude Code, Brave Search MCP offers a sweet spot of reliability and zero-cost operation, essentially giving Claude a safe browsing capability. Free open-source tools like Open-WebSearch MCP are fantastic and cost-free, but require a bit more hands-on maintenance and have inherent limitations (due to scraping). In professional settings where up-to-the-minute information is crucial, Perplexity’s Sonar API through the Ask MCP server can dramatically improve Claude’s usefulness by delivering verified, cited answers. And for heavy-duty data gathering tasks or enterprise agents, Bright Data’s MCP stands out as the comprehensive solution built to scale with your needs – effectively giving Claude “eyes and hands” on the live web in a controlled, robust manner brightdata.com. By carefully selecting and configuring the MCP server that fits your use case, you ensure that Claude Code becomes not just a coding assistant but a window to the world’s knowledge, all while maintaining the speed, context awareness, and security that professional applications require.

Sources:

• Anthropic (2024). Introducing the Model Context Protocol. (Definition of MCP and purpose)

• Anthropic Developer Docs (2025). Claude Code – Model Context Protocol. (Claude Code integration and server config)

• pskill9 (2024). Web Search MCP – README. (Google search MCP server features and usage)

• Aas-ee (2024). Open-WebSearch MCP – README. (Multi-engine search capabilities)

• Reddit r/ClaudeAI (2025). “Alternative to Brave Search MCP: Google Custom Search”. (Brave vs Google CSE free limits and quality)

• Thurrott, P. (2023). Brave releases its Search API. (Brave Search API pricing and tiers)

• Perplexity AI (2025). Sonar API Launch Announcement. (Sonar API features: citations, sources, tiers)

• Bright Data (2025). Bright Data MCP – Product Page. (All-in-one web access, features and “no blocking”) brightdata.com

• Bright Data GitHub (2025). brightdata-mcp Repository. (Open-source MCP server by Bright Data)

• Reddit r/ClaudeAI (2025). “Setting Up MCP Servers in Claude Code”. (List of available servers and setup tips)