> ## Documentation Index
> Fetch the complete documentation index at: https://docs.brightdata.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Bright Data for your coding agent

> Get structured data from the Bright Data Scraper API inside Claude Code, Cursor or Codex, in three commands. Then llms.txt, agent skills, the CLI and MCP.

Get structured data out of the Bright Data Scraper API from inside Claude Code, Cursor or Codex. Paste this in:

<Prompt description="Read https://docs.brightdata.com/llms.txt, then use the Bright Data Scraper API to scrape https://www.amazon.com/dp/B0FQFB8FMG and show me the title, price and rating." icon="sparkles" actions={["copy"]}>
  Read [https://docs.brightdata.com/llms.txt](https://docs.brightdata.com/llms.txt), then use the Bright Data Scraper API to scrape [https://www.amazon.com/dp/B0FQFB8FMG](https://www.amazon.com/dp/B0FQFB8FMG) and show me the title, price and rating.
</Prompt>

The agent reads the documentation index, installs what it needs and returns the record. To run the same thing yourself, or to see what it installed, start below.

## Get your first Scraper API result

Two commands to structured JSON from the Bright Data Scraper API. Same result as the [human quickstart](/quickstart), driven from the terminal.

<Steps>
  <Step title="Install and authenticate">
    ```bash theme={null}
    npm i -g @brightdata/cli
    bdata login
    ```

    `bdata login` opens a browser to authorize, so you never paste a key. Use `bdata login --device` over SSH or in any headless environment.

    If a global install is blocked on your machine, run each command through `npx` instead:

    ```bash theme={null}
    npx -p @brightdata/cli bdata login
    ```

    Keep the `-p @brightdata/cli` part. `npx` does not put `bdata` on your PATH, so every command needs the prefix, and the short `npx bdata` resolves to an unrelated package on npm rather than the Bright Data CLI.
  </Step>

  <Step title="Scrape a page">
    ```bash theme={null}
    bdata pipelines amazon_product "https://www.amazon.com/dp/B0FQFB8FMG" --pretty
    ```

    You should see the product JSON printed. This takes 10 to 30 seconds.

    ```json theme={null}
    [
      {
        "title": "Apple AirPods Pro 3 Wireless Earbuds with Active Noise Cancellation",
        "asin": "B0FQFB8FMG",
        "brand": "Apple",
        "final_price": 199.99,
        "currency": "USD",
        "rating": 4.4,
        "reviews_count": 14411
      }
    ]
    ```

    The full record carries 67 fields. Run `bdata pipelines list` to see every available pipeline type.
  </Step>
</Steps>

Install the [agent skills](#how-do-i-install-bright-data-skills) and the agent reaches for these commands itself:

```bash theme={null}
npx skills add brightdata/skills
```

Then ask in plain language instead of typing the CLI:

```text Prompt theme={null}
Scrape https://www.amazon.com/dp/B0FQFB8FMG and tell me the price and rating.
```

## How do I scrape a different site?

Change the pipeline type. The CLI names each one after what it collects, so there is no `dataset_id` to look up.

```bash theme={null}
bdata pipelines linkedin_person_profile "https://www.linkedin.com/in/satyanadella" --pretty
```

| Site                          | Pipeline type                                                                  |
| :---------------------------- | :----------------------------------------------------------------------------- |
| Amazon                        | `amazon_product`, `amazon_product_reviews`, `amazon_product_search`            |
| LinkedIn                      | `linkedin_person_profile`, `linkedin_company_profile`, `linkedin_job_listings` |
| Instagram                     | `instagram_profiles`, `instagram_posts`, `instagram_reels`                     |
| TikTok                        | `tiktok_profiles`, `tiktok_posts`, `tiktok_shop`                               |
| YouTube                       | `youtube_videos`, `youtube_profiles`, `youtube_comments`                       |
| Walmart, eBay, Etsy, Best Buy | `walmart_product`, `ebay_product`, `etsy_products`, `bestbuy_products`         |

For the current set:

```bash theme={null}
bdata pipelines list
```

Search engines are not pipelines. Use `bdata search` for Google, Bing and Yandex results, and `bdata scrape` for any page that has no pre-built scraper.

With the skills installed you do not pick the type yourself. Ask for the data and the agent matches the site to a pipeline:

```text Prompt theme={null}
Get me the follower count and recent posts for the Bright Data LinkedIn company page.
```

## What the agent sets up

| What it gives the agent                                                     | How                                                             | Setup                |
| :-------------------------------------------------------------------------- | :-------------------------------------------------------------- | :------------------- |
| Knows which Bright Data product to use, and how the APIs work               | [llms.txt](#how-do-i-give-my-agent-the-full-documentation)      | One line in a prompt |
| Runs search, scraping and structured extraction through the Bright Data CLI | [Agent skills](#how-do-i-install-bright-data-skills)            | One command          |
| Calls 60+ web tools live from inside the agent's tool loop                  | [Bright Data MCP](#how-do-i-connect-the-bright-data-mcp-server) | One command          |
| Drives scrapers, zones and a remote browser from the terminal               | [Bright Data CLI](/products/cli/overview)                       | One command          |

These are not alternatives. See [how they fit together](#should-i-use-skills-mcp-or-both).

## Prerequisites

* A [Bright Data account](https://brightdata.com/?hs_signup=1\&utm_source=docs). New accounts get **5,000 free credits every month**, no credit card required
* A coding agent with terminal access: Claude Code, Cursor, Codex or any of the 40+ agents the skills ecosystem supports

## How do I give my agent the full documentation?

Point the agent at `llms.txt`, a structured index of every Bright Data documentation page following the [llms.txt standard](https://llmstxt.org). Every entry links to the `.md` version of the page, so the agent reads clean markdown with no HTML to parse.

```text Prompt theme={null}
Read https://docs.brightdata.com/llms.txt to understand the available Bright Data
products, then help me choose the right API for scraping Amazon product pages.
```

To make it permanent instead of per-prompt, save the index into your project so every session has it:

<CodeGroup>
  ```bash Claude Code theme={null}
  mkdir -p .claude && curl -o .claude/brightdata-docs.txt https://docs.brightdata.com/llms.txt
  ```

  ```bash Cursor theme={null}
  mkdir -p .cursor/rules && curl -o .cursor/rules/brightdata.md https://docs.brightdata.com/llms.txt
  ```

  ```bash Codex theme={null}
  curl -s https://docs.brightdata.com/llms.txt >> AGENTS.md
  ```
</CodeGroup>

Two files are published. `llms.txt` is the index and is the right default for a live agent session. `llms-full.txt` is the entire documentation in one file, meant for RAG pipelines and long-context injection rather than interactive use.

<Tip>
  The token-efficient pattern for agents: load `llms.txt` to see what exists, identify the relevant page, then fetch that page's `.md` URL for the detail. Append `.md` to any documentation URL to get the markdown, for example [`/products/mcp-server/overview.md`](/products/mcp-server/overview.md).
</Tip>

Prefer to have the agent query the docs live instead of loading a file? The [Docs MCP](/general/docs-mcp) exposes this documentation as searchable MCP resources, so the agent retrieves pages inside its own reasoning loop. It is a separate server from the Bright Data MCP below: the Docs MCP reads documentation, the Bright Data MCP reaches the live web.

Building a retrieval pipeline rather than a live agent session? Use `llms-full.txt`, which is the complete documentation as one markdown file:

```python theme={null}
import httpx
from langchain.text_splitter import MarkdownTextSplitter

docs = httpx.get("https://docs.brightdata.com/llms-full.txt").text
chunks = MarkdownTextSplitter(chunk_size=1000, chunk_overlap=100).create_documents([docs])
vectorstore.add_documents(chunks)
```

<Warning>
  `llms-full.txt` is large. For a live agent session, load `llms.txt` first and fetch individual `.md` pages on demand instead. It uses far fewer tokens.
</Warning>

## How do I install Bright Data skills?

Skills are reusable instruction sets defined in `SKILL.md` files that give your agent embedded Bright Data API knowledge and the commands to act on it through the Bright Data CLI. One command installs them and auto-detects which agents you have:

```bash theme={null}
npx skills add brightdata/skills
```

The skills call `bdata` directly, so the global install from [step 1](#get-your-first-scraper-api-result) is what makes them work. Without `bdata` on your PATH the skills' `command -v bdata` check fails.

Confirm the install landed:

```bash theme={null}
npx skills list
```

Each installed skill prints on its own line with its path and the agents it was linked into:

```text theme={null}
Project Skills

search ./.agents/skills/search Agents: Codex, Cursor
```

An empty list means the install did not take. Re-run `npx skills add brightdata/skills` and answer the scope prompt.

The bundle covers search, scraping, structured extraction, the SDKs, proxies, Scraper Studio and MCP orchestration. The ones you will reach for first:

| Skill           | What it gives the agent                                                                                    |
| :-------------- | :--------------------------------------------------------------------------------------------------------- |
| Search          | Google, Bing and Yandex results as structured JSON. Runs on the SERP API                                   |
| Scrape          | Any webpage as clean markdown, with CAPTCHA solving and JavaScript rendering. Runs on the Web Unlocker API |
| Data Feeds      | Structured extraction from Amazon, LinkedIn, Instagram, TikTok, YouTube and more                           |
| Scraper Studio  | Builds a custom scraper for a site with no pre-built one                                                   |
| Bright Data MCP | Orchestrates the MCP tools in one integration                                                              |
| Best Practices  | API selection guide, auth patterns and code examples in Python and JavaScript                              |

Run `npx skills add brightdata/skills --list` for the current set.

Once installed, the agent invokes them directly:

```bash theme={null}
bdata search "your query" --engine google --json --pretty
bdata scrape "https://example.com"
bdata pipelines amazon_product "https://www.amazon.com/dp/B0FQFB8FMG" --pretty
```

### Install into a specific agent

<Tabs>
  <Tab title="Claude Code">
    ```bash theme={null}
    npx skills add brightdata/skills -a claude-code
    ```

    Skills land in `.claude/skills/` in your project, or `~/.claude/skills/` with `-g`. Claude Code discovers them on the next session. Verify with `npx skills list -a claude-code`.
  </Tab>

  <Tab title="Cursor">
    ```bash theme={null}
    npx skills add brightdata/skills -a cursor
    ```

    Skills land in `.cursor/skills/`. Cursor Composer picks them up automatically. Reference one in chat: `Use the scrape skill to extract content from https://example.com`.
  </Tab>

  <Tab title="Codex">
    ```bash theme={null}
    npx skills add brightdata/skills -a codex
    ```

    Skills land in `.agents/skills/`, the shared location Codex reads alongside `AGENTS.md`.
  </Tab>

  <Tab title="Every agent at once">
    ```bash theme={null}
    npx skills add brightdata/skills --all

    # Non-interactive, for CI
    npx skills add brightdata/skills --all -y
    ```

    The CLI auto-detects every agent you have installed and distributes the files to each.
  </Tab>

  <Tab title="Any other agent">
    Each skill is plain markdown, so you can inject it into any system prompt or RAG index:

    ```bash theme={null}
    git clone https://github.com/brightdata/skills.git
    cat skills/bright-data-best-practices/SKILL.md
    ```
  </Tab>
</Tabs>

Add `-g` to any command to install globally across projects.

### Manage installed skills

```bash theme={null}
npx skills list      # what is installed
npx skills check     # are there updates
npx skills update    # update to latest
npx skills remove brightdata/skills
```

Skills are part of the [open agent skills ecosystem](https://github.com/vercel-labs/skills) and work across 40+ coding agents. The source, including each `SKILL.md` and its runnable scripts, lives at [github.com/brightdata/skills](https://github.com/brightdata/skills). New skills are added regularly, so star the repository to follow along.

## How do I connect the Bright Data MCP server?

The Bright Data MCP server gives your agent live web access through 60+ tools for search, scraping, structured extraction and browser automation. It runs on the Web Unlocker API, so every request handles proxy rotation, anti-bot challenges and CAPTCHA solving.

Each snippet below puts an API key in an agent config file. Those files are commonly committed to version control, so treat the key as you would any other secret. To avoid a long-lived key in a file entirely, the server also accepts [OAuth 2.1](/products/mcp-server/remote/oauth), where the user signs in through a browser.

<CodeGroup>
  ```bash Claude Code theme={null}
  claude mcp add --transport sse brightdata "https://mcp.brightdata.com/sse?token=YOUR_API_KEY"
  ```

  ```json Cursor theme={null}
  {
    "mcpServers": {
      "brightdata-mcp": {
        "command": "npx",
        "args": ["-y", "@brightdata/mcp"],
        "env": {
          "API_TOKEN": "YOUR_API_KEY"
        }
      }
    }
  }
  ```

  ```bash Codex CLI theme={null}
  codex mcp add brightdata --env API_TOKEN=YOUR_API_KEY -- npx -y @brightdata/mcp
  ```
</CodeGroup>

Then try it with a prompt like `Extract the Bright Data overview section from LinkedIn`.

<Tip>
  **Control token usage.** Load only the tools you need with [tool groups](/products/mcp-server/tools), for example `groups=ecommerce,social`, or name individual tools such as `tools=web_data_amazon_product`. A smaller tool list means a smaller context and more usable requests.
</Tip>

Two versions exist. The [remote server](/products/mcp-server/remote/quickstart) is fully managed and needs no setup. The [local server](/products/mcp-server/local/quickstart) is self-hosted for on-premise or private cloud. See the [MCP server overview](/products/mcp-server/overview) for both, and the [integration guides](/products/mcp-server/integrations/overview) for other clients.

## Should I use skills, MCP or both?

Skills and the CLI are the default pair. Skills carry the knowledge: which Bright Data product fits a task, how to authenticate, how to handle pagination and errors. The CLI executes. Neither costs a live request until the agent runs a command.

The MCP server matters when an agent has no terminal. It exposes the same capabilities as tools inside the agent's own loop, which is the only route for a hosted assistant or a client that cannot shell out.

This page lists terminal access as a prerequisite, so MCP is optional here. Add it when you want live web access inside the tool loop rather than through a shell.

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do I need to install anything globally?">
    No. `npx skills add brightdata/skills` and `npx -y @brightdata/mcp` both fetch on demand, so there is no global dependency to maintain. The Bright Data CLI can also run through npx: `npx -p @brightdata/cli brightdata --version`.
  </Accordion>

  <Accordion title="Does the MCP server use the same free tier?">
    Yes. The MCP server draws from the same account-level [free tier](/general/account/billing-and-pricing/free-tier) of 5,000 credits per month, from a single shared pool, because it runs on the Web Unlocker API. On team accounts that pool is shared across all users in the account.
  </Accordion>

  <Accordion title="Does the MCP server need a username?">
    No. Both the remote and local MCP servers authenticate with your API key only. Usernames in the format `brd-customer-{customer_id}-zone-{zone_name}` are for native proxy access, not MCP. If a third-party tool asks for a username, leave it empty.
  </Accordion>

  <Accordion title="Which agents are supported?">
    Skills work across the 40+ agents in the [open agent skills ecosystem](https://github.com/vercel-labs/skills), including Claude Code, Cursor and Codex. The MCP server works with any MCP-compatible client. `llms.txt` works with anything that can fetch a URL.
  </Accordion>

  <Accordion title="Can my agent build a scraper for a site with no pre-built scraper?">
    Yes. Give it a target URL and a sentence describing the fields you want, and the Bright Data CLI generates the scraper through Scraper Studio. Copy-pasteable prompts for the full build, run and self-heal loop are in [Scraper Studio coding agent prompts](/products/scraper-studio/coding-agent-prompts).
  </Accordion>
</AccordionGroup>

## Next steps

<CardGroup cols={3}>
  <Card title="Choose a product" icon="compass" href="/product-selector">
    Match your target site to the right Bright Data product, then go straight to its first request.
  </Card>

  <Card title="Build a scraper with prompts" icon="messages" href="/products/scraper-studio/coding-agent-prompts">
    Copy-pasteable Claude Code, Cursor and Codex prompts that build, run and self-heal a scraper.
  </Card>

  <Card title="Bright Data CLI" icon="terminal" href="/products/cli/overview">
    Scrape, search, manage zones and control a remote browser from the terminal.
  </Card>
</CardGroup>