Extending Cursor AI Capabilities via Bright Data MCP

This guide covers how to connect Cursor to Bright Data’s MCP so its AI agent can search, scrape, and read live web pages without leaving your IDE. You will learn:

1. What Cursor is and why it has become so popular.
2. The main reasons to add a game-changing MCP server like Bright Data’s to Cursor.
3. How to connect Cursor to Bright Data MCP.
4. How to install the official Bright Data plugin from the Cursor Marketplace in one click.

Let’s dive in!

What Is Cursor?

Cursor is an AI-powered code editor built as a fork of Visual Studio Code. Its core functionality, like any text editor, is to provide an interface for writing code. Still, what makes it special is its built-in deep AI integration.

Instead of basic autocomplete, Cursor uses LLMs to understand your entire codebase and context. This enables it to provide smart features like:

• Conversational prompts: Describe what you want in plain English, and Cursor will write or edit the code for you.
• Multi-line autocomplete: It suggests and completes entire blocks of code, not just single lines.
• AI-driven refactoring: It can intelligently optimize, clean up, and fix your code based on project-wide context.
• Debugging assistance: Ask the AI to find and explain bugs in your code.

Cursor turns a standard code editor into a proactive, highly intelligent pair programmer. It supports multiple LLMs from various providers and includes built-in support for tools through MCP.

Why Add Bright Data’s MCP to Cursor

Behind the scenes, Cursor relies on known LLM models. While its integration is deeper and more polished than most tools, it still faces the same core limitation as any LLM: AI knowledge is static!

After all, AI training data reflects a snapshot in time. That quickly becomes outdated, especially in fast-evolving fields like software development. Now, imagine giving Cursor’s AI agent the ability to:

• pull in the latest tutorials and documentation for RAG workflows,
• consult live guides as it writes code, and
• browse real-time websites as easily as it can navigate your local files.

That is precisely what you unlock by connecting Cursor to Bright Data’s MCP!

Bright Data MCP offers access to 69 AI-ready tools built for real-time web interaction and data collection. These are all powered by the rich Bright Data AI infrastructure.

Every Bright Data account ships with 5,000 requests per month, renewed on the first of each month, with no credit card needed to start. Those requests are one shared pool that every Bright Data MCP tool draws from, so nothing in the toolset sits behind an upgrade. These are the tools your Cursor agent will reach for most often:

Tool	Description
search_engine	Retrieve search results from Google, Bing, or Yandex in JSON or Markdown.
scrape_as_markdown	Scrape any webpage into clean Markdown format, bypassing bot detection and CAPTCHA.
discover	Search the web and rank results by AI-driven relevance, with geo, date, and keyword filters.
search_engine_batch	Run up to 10 search queries in parallel in a single call.
scrape_batch	Scrape up to 10 webpages in one request and get back URL/content pairs.

Beyond these, Bright Data MCP includes tools for cloud browser automation and structured data retrieval from platforms like Amazon, YouTube, LinkedIn, TikTok, Google Maps, and many others. Every one of them bills against the same 5,000 requests. Search, scrape, and structured-data calls cost one request each, while browser automation is metered by traffic at five requests per MB, so putting the whole monthly allowance through browser sessions works out to close to 1 GB.

Here are just a few examples of what becomes possible when extending Cursor with Bright Data’s MCP:

1. Retrieve the latest API references or framework tutorials, then auto-generate working code or project scaffolds.
2. Instantly fetch up-to-date search engine results and embed them into your documentation or code comments.
3. Gather live web data to create realistic test mocks, analytics dashboards, or automated content pipelines.

To explore the full range of capabilities, take a look at the Bright Data MCP documentation.

How to Integrate Bright Data MCP into Cursor for an Enhanced AI Coding Experience

In this step-by-step section, you will see how to connect a local Bright Data MCP server instance to Cursor. This setup provides a supercharged AI experience with 69 tools available directly in your IDE. If you would rather skip the manual configuration, there is also a one-click path through the Cursor Marketplace, covered further down.

In detail, we will use the Bright Data MCP tools to create an Express backend with a mocked API that returns real-world data from Amazon. This is just one example of the many use cases supported by this integration.

Follow the instructions below!

Prerequisites

To follow along with this tutorial, make sure you have:

• A Cursor account. Note that Cursor lists MCP servers, plugins, skills, and hooks under its paid individual plans, so check the current pricing page before you start.
• A Bright Data account with an active API key.

Do not worry about setting up Bright Data right now. You will be guided through the process as you go through the article!

A basic understanding of how MCP functions, how Cursor works, and the tools provided by Bright Data MCP will also be helpful.

Step #1: Get Started with Cursor

Install the Cursor version for your operating system, open it, and log in with your account.
If this is your first time launching the application, complete the setup wizard.

You should then see something like this:

Great! Now open your project folder and get ready to use the built-in AI coding agent, extended with Bright Data MCP.

Step #2: Configure Your LLM

By default, Cursor runs in “Auto” mode and routes each request to a model on your behalf. Bright Data MCP behaves the same way whichever model it lands on, so if you are happy with Auto, feel free to skip to the next section. Change the model only when you want a specific one driving the tool calls.

If you want to change the default model, search for “cursor settings” and select the equivalent option:

In the tab that opens, go to the “Models” tab:

Here, you can configure which LLM Cursor’s AI agent should utilize. Cursor splits the catalog into two usage pools that bill separately. The Cursor Models pool covers Composer 2.5, Grok 4.5, and Grok 4.6, and carries the most generous included usage on every paid plan. The Other Models pool covers third-party frontier models such as Claude Opus 5, Claude Sonnet 5, Gemini 3.1 Pro, and GPT-5.6, each charged at its own API rate. All of them can call Bright Data MCP tools, so pick whichever model you already trust for agentic work.

Search for the model you want and toggle it on. On paid plans, you can also plug in your own API key for that provider, in which case Cursor bills the usage to you rather than drawing from your included pool. Once the model is enabled, open the “New Chat” panel on the right, click the “Auto” dropdown, and select your model there so the agent uses it for every request in that chat.

Well done! Cursor is now operating through your configured LLM.

Step #3: Test Bright Data’s MCP on Your Machine

Before connecting Cursor to Bright Data MCP, verify that you can actually run the server locally. That is required because the MCP server will be configured through STDIO.

Begin by signing up for Bright Data. Otherwise, if you already have an account, just log in. For a quick setup, follow the instructions in the “MCP” section of the dashboard:

For more guidance, refer to the instructions below.

First, generate your Bright Data API key and store it in a safe place. You will need it in the next step. We will assume that your API key has Admin permissions, as that simplifies the Bright Data MCP integration.

Now, install Bright Data MCP globally on your machine via this npm command:

npm install -g @brightdata/mcp

Verify that the MCP server works by launching it:

API_TOKEN="<YOUR_BRIGHT_DATA_API_KEY>" npx -y @brightdata/mcp

Or, equivalently, in PowerShell:

$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API_KEY>"; npx -y @brightdata/mcp

Replace the <YOUR_BRIGHT_DATA_API_KEY> placeholder with your Bright Data API token. These commands set the required API_TOKEN environment variable and launch Bright Data MCP locally through the @brightdata/mcp package.

If successful, you should see an output like this:

On the first launch, Bright Data MCP creates two default zones in your Bright Data account:

• mcp_unlocker: A zone for Web Unlocker.
• mcp_browser: A zone for Browser API.
  Bright Data MCP relies on those two services to power its 69 tools.

If you want to check that the zones were set up, reach the “Proxies & Scraping Infrastructure” page in your Bright Data account. You should spot the two zones in the table:

Note: If your API token does not have Admin permissions, the two zones will not be automatically created. In that case, define them manually and set them via environment variables as explained on GitHub.

By default, the server starts with its core search and scrape tools. To expose the full set of 69, add the PRO_MODE="true" environment variable:

API_TOKEN="<YOUR_BRIGHT_DATA_API_KEY>" PRO_MODE="true" npx -y @brightdata/mcp

Or, on Windows:

$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API_KEY>"; $Env:PRO_MODE="true"; npx -y @brightdata/mcp

Everything those tools do draws on the same 5,000 monthly requests, so switching the full set on does not move you onto a different plan. Usage only shifts to pay-as-you-go pricing once the monthly pool is spent, and an account with no deposited funds simply stops rather than running up a bill. If you would rather keep the list short, the GROUPS environment variable loads a single bundle instead, as in GROUPS="ecommerce,social", which keeps your agent’s context smaller and its tool choice sharper.

Terrific! You just made sure that the Bright Data MCP server works locally. Kill the MCP process, as you are about to configure Cursor to start it for you and connect to it.

Step #4: Configure Bright Data MCP in Cursor

Begin by searching for “>mcp” and selecting “View: Open MCP Settings” option:

In the “Tools & MCP” section, click the “Add Custom MCP” button:

This will open the following mcp.json configuration file:

As you can see, by default, it is empty. For Bright Data’s MCP integration, fill it as below:

{
  "mcpServers": {
    "Bright Data": {
      "command": "npx",
      "args": ["-y", "@brightdata/mcp"],
      "env": {
        "API_TOKEN": "<YOUR_BRIGHT_DATA_API_KEY>",
        "PRO_MODE": "true"
      }
    }
  }
}

Next, save the file using Ctrl + S (or Cmd + S on macOS):

The above configuration replicates the npx command we tested earlier, using environment variables to pass credentials and settings:

• API_TOKEN is required. Set this to the Bright Data API key you generated earlier.
• PRO_MODE is optional, and it is what exposes the full set of 69 tools. Drop it if you would rather keep only the core search and scrape tools.

In other words, Cursor will use the configuration in mcp.json to execute the npx command seen earlier. It will run a Bright Data MCP process locally, connect to it, and get access to the exposed tools.

Close the mcp.json tab, as the Cursor + Bright Data MCP integration is complete!

Note: If you prefer not to use STDIO and want to use SSE or streamable HTTP, Bright Data’s MCP also provides a fully hosted remote server. In that case, drop the command and args keys and give Cursor a url of https://mcp.brightdata.com/mcp?token=<YOUR_BRIGHT_DATA_API_KEY> instead, which skips the Node.js install altogether. Append &pro=1 to that URL to expose the full toolset there too.

Step #4 (Alternative): Install the Bright Data Plugin from the Cursor Marketplace

Editing mcp.json by hand is not the only route. Bright Data also publishes an official plugin in the Cursor Marketplace, listed under “Data & Analytics” and manually reviewed by the Cursor team before publication. Installing it wires up the same Bright Data MCP server you just configured, so treat this as a replacement for the previous step rather than something to run on top of it.

To install it, open “Customize” in the Cursor sidebar, find the Bright Data plugin, press “Install,” and choose whether to scope it to the current project or to your user profile. If you prefer the keyboard, typing /add-plugin bright-data in the chat does the same thing. Either way, run /bd-setup afterwards: that command checks the MCP connection, walks you through pasting your API token if it is missing, and reports which tools and zones you ended up with.

What the plugin adds on top of a bare MCP entry is context. Instead of leaving the agent to guess which of the 69 tools fits a given request, it ships six skills, seven slash commands, two rules, and a dedicated research subagent:

Skill / command	What it does
bd-search / /bd-search	Live search engine results through the SERP API.
bd-scrape, bd-batch-scrape / /bd-scrape	Single or parallel URL extraction via Web Unlocker, up to 10 URLs per call.
bd-browser / /bd-browser	Interactive browser automation for JS-heavy or login-gated pages.
bd-structured-data / /bd-data	Structured JSON from Amazon, LinkedIn, Instagram, TikTok, YouTube, Reddit, Zillow, and more.
bd-code / /bd-code	Generates Python or Node.js integration code for any Bright Data product.
web-researcher	A subagent that runs multi-source research and returns answers with citations.

The two rules are the quiet win here. One is a routing guide that tells the agent which Bright Data product suits which kind of task, and the other enforces citation standards on anything pulled from the web. In practice that means fewer runs where Cursor spins up a browser session when a plain scrape would have done, and fewer answers that quote a page without saying where it came from. The plugin source is public on GitHub if you want to read the skills and rules before installing them.

Step #5: Verify Tool Availability from the MCP Integration

It is time to check whether Cursor has successfully connected to the Bright Data MCP server and can access all its tools.

To do that, go back to the “Tools & MCP” section in the “Cursor Settings” tab. You should now see the configured “Bright Data” option, listing all available tools:

Expand the “N tools enabled” dropdown (where N is the number of tools enabled) to inspect all the available tools:

Note that Cursor automatically connects to the server and retrieves its 69 tools.
If you left PRO_MODE out of the configuration, you will see only the core search and scrape tools instead. Here, you can also activate or deactivate tools as you prefer. By default, they are all activated.

Once confirmed, close the “Cursor Settings” tab. Prepare to take advantage of these tools for an extended AI-powered coding experience!

Step #6: Run a Task with the Enhanced AI Coding Agent

To test the capabilities of your Cursor coding agent, you need a prompt that exercises the newly configured web data retrieval features.

For example, suppose you are building a backend in Express.js for your e-commerce application. You want to mock an API that returns real-world Amazon product data.

Achieve that with a prompt like this:

Scrape the data from the following Amazon products:
1. https://www.amazon.com/Clean-Skin-Club-Disposable-Sensitive/dp/B07PBXXNCY/
2. https://www.amazon.com/Neutrogena-Cleansing-Towelettes-Waterproof-Alcohol-Free/dp/B00U2VQZDS/
3. https://www.amazon.com/Medicube-Zero-Pore-Pads-Dual-Textured/dp/B09V7Z4TJG/

Then, save the scraped data to a local JSON file. Next, create a simple Express.js project with an endpoint that accepts an ASIN (representing an Amazon product) and returns the corresponding data read from the JSON file.

With the full toolset enabled, execute the above prompt in Cursor.

This is what happened next, step by step:

1. The LLM configured in Cursor identifies web_data_amazon_product as the tool for retrieving Amazon product data.
2. For each of the three Amazon products in the prompt, you are asked for permission to run web_data_amazon_product to fetch the data.
3. You grant permission for each tool, triggering asynchronous data collection tasks (which, under the hood, call the Bright Data Amazon Scraper).
4. The retrieved data for each product is displayed in JSON format.
5. The configured model processes the retrieved data and populates a products.json file with it.
6. Cursor creates the npm project structure, defining package.json, and the index.js file with the Express server logic.
7. You are asked for permission to install the project dependencies via npm install. This will result in a package.json file and in the node_modules/ folder.
8. You are asked for permission to run the server with npm start.

Note: Even if it was not explicitly specified in the prompt, the agent also decided to ask for project dependency installation and server setup. That was a nice addition!

In this example, the final output will produce a project structure as follows:

your-project/
├── node_modules/
├── index.js
├── package.json
├── package-lock.json
└── products.json

Perfect! Let’s inspect the result to see if it achieves the intended goal.

Step #7: Explore the Output Project

As the AI coding agent generated the files, they appeared in the left column in Cursor.

Disclaimer: Your files may differ from what is shown below, as different AI runs can produce different results.

Start by inspecting the products.json file:

As you can see, this contains a simplified version of the scraped data returned by the web_data_amazon_product tool:

Important: web_data_amazon_product actually returns all product data from the Amazon page, not just a few fields. Still, the AI decided to include only the most relevant fields. With some prompt optimization, you can instruct the AI to include all fields if desired.

Next, open index.js to see the Express.js server logic:

Specifically, the mocked endpoint for product data retrieval uses the path /product/:asin.

Continue by inspecting the other files, but they should all be fine. So, press the “Keep All” button to confirm the AI-generated output and get ready to put your project under test!

Step #8: Test the Produced Project

Your Express.js application should already be running, as the agent asked for permission to run npm start. If it has not, you can start it manually with:

npm start

Your Express.js backend should now be running at http://localhost.

Next, run the following cURL command to test the GET /product/:asin endpoint:

curl "http://localhost/product/B07PBXXNCY"

Where B07PBXXNCY is the ASIN of one of the Amazon products mentioned in the prompt.

You should see something like this:

Wonderful! That data was fetched to the generated products.json file correctly. The result corresponds to (a simplified version of) the data from the original Amazon page.

If you have ever tried to scrape product data from Amazon, you know how challenging it can be due to their notorious Amazon CAPTCHA and other anti-bot measures. Surely, no vanilla LLM can retrieve that data on the fly.

This demonstrates the power of combining Bright Data MCP with Cursor. Now, this was just a very simple example. However, with the 69 tools available and the right prompts, you can handle more advanced scenarios directly within your IDE!

Et voilà! An Express backend with a mocked API endpoint has been successfully created, thanks to the Cursor + Bright Data MCP integration.

Conclusion

In this blog post, you learned how to take full advantage of MCP integration in Cursor. The AI coding agent built into the IDE is already helpful, but it becomes far more capable and resourceful once connected to Bright Data’s MCP. Whether you wire it up by hand through mcp.json or install the Marketplace plugin in one click, the agent ends up with the same 69 tools.

This integration gives Cursor the ability to perform live web searches, extract structured data, consume dynamic data feeds, and even automate browser interactions. All that, directly from within your coding environment.

To build even more advanced AI-powered workflows, explore the complete suite of services and data solutions available in Bright Data’s AI ecosystem.

Create a free Bright Data account today and start experimenting with our AI-ready web data tools. Every account includes 5,000 requests per month at no cost, covering search, scraping, structured data, and browser automation alike, which is more than enough to work through this tutorial and keep going.