Brave Search MCP Server Setup for Cursor IDE (2026)

The Brave Search MCP server gives Cursor's AI a way to pull current information from the live web — package versions, API changes, error messages from this week — instead of guessing from training data. Get an API key from Brave's developer portal, drop it into ~/.cursor/mcp.json, restart Cursor, and your AI can search the web mid-conversation.

Every other server in this library connects Cursor to something you already have — a repo, a ticket tracker, a database. This one is different: it connects Cursor to the entire internet, which is exactly why it needs its own troubleshooting notes around rate limits and query costs that don't apply to, say, a filesystem server.

Why Bother — What Does This Actually Fix?

Ask Cursor about a library API without web search and it answers from whatever was in its training data, which might be a year or two stale. Ask it something that changed last month — a new flag on a CLI tool, a deprecation notice, a CVE — and it either hallucinates a plausible-sounding answer or tells you it doesn't know. Brave Search closes that gap. The model can issue a real query, read real result snippets, and ground its answer in something that was published this week.

It's also useful for anything that was never in training data to begin with: your company's changelog, a GitHub issue opened yesterday, a Stack Overflow answer from three days ago.

Get a Brave Search API Key

1. Go to brave.com/search/api and sign up for a developer account
2. Choose a plan — a free tier exists specifically for testing and light usage; paid tiers scale up from there
3. Once approved, find your API key in the developer dashboard
4. Copy it somewhere safe — you'll paste it into mcp.json in a minute

Brave's free tier has historically capped out around 2,000 queries per month with a roughly 1-request-per-second rate limit. Check the current numbers on the pricing page before you build a workflow that assumes a specific ceiling — these limits are the kind of thing providers adjust without much notice.

Add It to Cursor

Open ~/.cursor/mcp.json (or Settings → MCP in Cursor) and add:

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your-brave-api-key-here"
      }
    }
  }
}

Restart Cursor completely — not just reload the window — for the new server to register.

Confirm It's Working

In Cursor chat:

Search the web for the current pricing of the Anthropic API and summarize it

If you get back a summary that references specific numbers with a plausible source, the connection works. If Cursor says it can't search the web, double check the API key was pasted without extra whitespace and that the server shows as connected in Cursor's MCP settings panel.

Two Tools, Not One

The reference implementation exposes two distinct tools, and it matters which one gets called:

Local search results depend on Brave having the underlying places/business data for a query, which isn't guaranteed to be included on every plan tier — if a location query comes back empty or errors out where a web query works fine, that's the first thing to check, not a broken MCP connection.

Prompts Worth Using

Version and compatibility checks:

Search for whether Next.js 16 has any breaking changes affecting middleware, and summarize what changed

Debugging an unfamiliar error:

I'm getting "ECONNRESET" from a Node.js fetch call to a third-party API. Search for common causes and check if this specific API has known reliability issues this month

Comparing current options:

Search for the current state of Postgres extensions for vector search — pgvector alternatives, if any have emerged recently

Fact-checking a claim before it goes in a commit message or PR description:

I want to say this migration fixes a known race condition in the connection pooler. Search for whether that's actually a documented issue for this library before I write it down.

The pattern that works best: ask for a search-and-summarize in one prompt, rather than "search for X" followed by a second "now tell me about it." Cursor chains the tool call and the synthesis in one turn either way, but being explicit about wanting a summary (not a raw link dump) gets a cleaner answer.

What This Doesn't Do

It doesn't browse — it retrieves search result snippets, not full page content. If you need Cursor to read an entire long article or documentation page rather than a search snippet, that's a fetch/browsing-style MCP server, a different tool with a different job. It also doesn't cache anything between sessions; every search is a fresh API call against your quota, so repeating the same broad query across a long chat session burns through the free tier faster than it looks like it should.

Troubleshooting

"Rate limit exceeded" after a handful of searches
You're likely on the free tier's per-second cap, not the monthly quota. Space out searches rather than firing several in one prompt chain — asking for one search-and-summarize instead of "check three different things" cuts request volume immediately.

Server connects but every search returns empty results
Test the API key directly against Brave's endpoint with curl outside of Cursor. If curl also returns nothing, the key itself is the problem — expired, revoked, or never fully activated after signup — not the MCP config.

Cursor calls the tool but never surfaces an answer
This usually means the model got results back but the response got cut off or the chat context ran long. Try a narrower, more specific query — "current LTS version of Node.js" gets a cleaner answer than "tell me everything about Node.js versions."

Works in testing, fails intermittently in real use
Free-tier monthly quotas reset on a calendar cycle, not a rolling window in most setups. If searches stop working partway through the month, check your usage dashboard before assuming the server broke.

Frequently Asked Questions

Q: Is the Brave Search MCP server free to use?
A: The server itself is free and open source. What costs money, potentially, is the underlying Brave Search API — there's a free tier for light use, with paid tiers if you need higher query volume or the local/places search feature.

Q: Can I use Google or Bing instead?
A: Not with this specific server — it's built against Brave's API. Community MCP servers wrapping Google Custom Search or SerpAPI exist separately if you specifically need Google's result set, but Brave's API is the one most setups reach for first because of its straightforward free tier.

Q: Does this replace Context7 or other documentation-specific MCP servers?
A: No, and they're not really competing — Context7 fetches structured, current documentation for known libraries; Brave Search does open-ended web queries for anything, including things with no dedicated documentation server. Many setups run both: Context7 for "what's the current API for this library," Brave Search for "has anyone reported this specific error."

Q: Will this slow down every response, since it might search the web unnecessarily?
A: The model decides when a query needs a web search based on your prompt — it doesn't search on every message. If you notice it searching when it shouldn't, be more explicit that you want an answer from its own knowledge, e.g., "without searching, what do you think causes this."

Related Guides

---