BLOG
Bright Data Agent Browser: What It Is and How to Run One
Bright Data agent browser explained: what the product does, where it fits, and how to run a hosted Chromium agent browser over CDP.
A Bright Data agent browser is a hosted browser session that an AI agent drives remotely, backed by Bright Data's proxy and unblocking infrastructure. If you are evaluating it, the real question is not "does it exist" but "does it fit my agent's runtime model." Bright Data is, first and foremost, a data-collection company: its browser offering is built to serve scraping and unblocking workloads. That shapes what you get and what you don't.
This article covers what the Bright Data agent browser actually provides, where it fits in an agent stack, how it compares to a general-purpose hosted Chromium runtime, and how to wire an agent to a remote browser over CDP with Playwright. If you want the broader runtime picture first, read Remote browsers for AI agents.
What the Bright Data agent browser is
Bright Data's browser product is a remote, managed Chromium instance that you connect to over the Chrome DevTools Protocol (CDP). You do not install Chrome, manage a container fleet, or rotate proxies yourself. The session runs on Bright Data's infrastructure, and the company's core differentiator — a large residential and datacenter proxy network plus automated unblocking — is bundled into the session.
That framing matters. Bright Data built its business on web data collection at scale: scraping APIs, proxy networks, and unblocking for sites that actively resist automated access. The browser product inherits that DNA. It is designed for agents and scrapers that need to reach sites that block naive automation, and it assumes the workload is fundamentally about extracting data from pages.
So when you evaluate a Bright Data agent browser, you are evaluating a scraping-oriented browser runtime with strong network-layer tooling. That is a genuinely useful thing. It is also a narrower thing than a general-purpose agent runtime, and the difference shows up in production.
Where a Bright Data agent browser fits
The product is a reasonable fit when your agent's job is to read the web reliably despite anti-bot defenses. Concrete cases:
- Competitive and pricing intelligence. An agent visits retailer or marketplace pages on a schedule and extracts structured data. Proxy management and unblocking are the hard part; the browser is a means to that end.
- Lead and listing enrichment. Pulling contact details, inventory, or directory listings from sites that rate-limit or fingerprint clients.
- Research agents with hostile targets. Any workflow where a meaningful fraction of target sites return CAPTCHAs or blocks to a datacenter IP.
In each case the value is concentrated in the network layer. The browser session is a delivery mechanism for proxy-backed page loads.
Where it fits less cleanly is the general agent runtime case: long-lived sessions, persistent authenticated profiles, live human-in-the-loop debugging, and multi-tenant isolation for many concurrent agents. Those are runtime concerns, not scraping concerns, and they are where a dedicated hosted Chromium runtime tends to be the better comparison point.
How an agent connects to a hosted browser
Regardless of vendor, the integration pattern is the same, and it is worth understanding because it determines how portable your code is. A hosted browser exposes a CDP WebSocket endpoint. Your agent connects to that endpoint with Playwright, Puppeteer, Selenium, or a raw CDP client, and then drives the page as if the browser were local.
The Chrome DevTools Protocol is the contract. It is a JSON-over-WebSocket protocol that exposes domains for page navigation, DOM access, network interception, input events, and runtime evaluation. Playwright's connectOverCDP method attaches to an existing browser over that protocol rather than launching one. The Playwright CDP documentation is the authoritative reference for the client side.
Here is the shape of a connection in TypeScript:
import { chromium, Browser, Page } from "playwright";
type SessionInfo = {
cdpEndpoint: string; // wss://... from your provider's session API
};
async function runAgentTask(session: SessionInfo): Promise<string> {
let browser: Browser | undefined;
try {
// Attach to the already-running remote Chromium over CDP.
browser = await chromium.connectOverCDP(session.cdpEndpoint, {
timeout: 30_000,
});
// A remote session usually has one default context already open.
const context = browser.contexts()[0] ?? (await browser.newContext());
const page: Page = context.pages()[0] ?? (await context.newPage());
await page.goto("https://example.com/pricing", {
waitUntil: "domcontentloaded",
timeout: 45_000,
});
// Let the agent's extraction step run against the live DOM.
const heading = await page.locator("h1").first().innerText();
return heading;
} finally {
// Disconnect the client. Whether the remote session stops
// depends on the provider's session lifecycle — check its API.
await browser?.close();
}
}Two details matter in production. First, connectOverCDP attaches to an existing browser; it does not launch one, so session creation is a separate API call against the provider. Second, browser.close() on a CDP connection disconnects your client — it does not necessarily terminate the remote session. Session termination is a provider-specific call, and getting this wrong is a common source of leaked, billable sessions.
If you are new to remote sessions generally, running a remote browser online covers the lifecycle model in more depth.
Bright Data agent browser vs. a general hosted Chromium runtime
The honest comparison is not "which is better" but "which is built for your workload." Bright Data optimizes for network-layer reach. A general-purpose hosted Chromium runtime optimizes for the agent execution layer: session isolation, persistent profiles, live viewing, and predictable per-session control.
| Dimension | Bright Data agent browser | General hosted Chromium runtime |
|---|---|---|
| Primary design goal | Web data collection at scale | Agent execution and automation runtime |
| Network layer | Large proxy network, unblocking built in | Configurable proxy settings; bring your own if needed |
| Browser control | CDP over WebSocket | CDP over WebSocket |
| Client compatibility | Playwright, Puppeteer, Selenium, raw CDP | Playwright, Puppeteer, Selenium, raw CDP |
| Persistent profiles | Varies by product tier | First-class: saved logins and state across sessions |
| Live debugging | Limited / plan-dependent | Live viewer for human inspection mid-session |
| Session isolation | Per-session | Per-session, multi-tenant by default |
| Best fit | Scraping and unblocking-heavy agents | Long-running, stateful, multi-agent workloads |
| Pricing model | Quote- and plan-based | Metered; see /pricing |
Read the table as a decision aid, not a verdict. If most of your agent's difficulty is getting past blocks, Bright Data's network layer is the feature you are paying for, and it is a real advantage. If your difficulty is managing many concurrent, stateful agents with logins that must survive across runs, the runtime layer is what you need, and a general hosted Chromium runtime is the closer fit.
Many teams end up using both concepts: a proxy-backed network path for hostile targets, and a runtime that gives them session control, profiles, and observability. The two are not mutually exclusive, but they are different products solving different problems.
Production criteria to evaluate
Before committing to any hosted browser, including a Bright Data agent browser, test against these criteria with your own workloads. Vendor marketing will not answer them for you.
- Session lifecycle clarity. Can you create, inspect, and terminate a session through an API? Does disconnecting the CDP client stop billing? Ambiguity here costs money.
- Profile persistence. Can an agent log in once and reuse that authenticated state across sessions? For agents that operate behind a login, this is often the deciding factor.
- Live observability. When an agent fails at step 14, can a human watch the session or replay it? Debugging blind is the single biggest time sink in agent development.
- Concurrency and isolation. Are sessions isolated from each other? What happens to one agent's cookies and storage when another runs concurrently?
- Proxy control. Can you set proxies per session, per context, or per request? Is the proxy layer configurable, or fixed to the vendor's network?
- Client portability. Does it speak standard CDP, so your Playwright or Puppeteer code moves with you if you switch providers?
- Cost model. Is it per browser-hour, per request, per GB of proxy traffic, or a mix? Model your real workload, not the headline number.
The portability point deserves emphasis. Because CDP is a standard, code written against one hosted browser generally runs against another with only the endpoint and session-creation call changed. That is your insurance policy against lock-in. Keep the provider-specific surface — session creation, termination, proxy config — behind a thin adapter in your codebase.
Wiring an agent to a remote browser: practical notes
A few implementation details separate a demo from something that survives production.
Treat the session as a resource with a lifecycle. Create it explicitly, pass the endpoint to your agent, and terminate it in a finally block or a supervisor. Do not rely on the CDP client disconnecting to clean up.
Set timeouts at every layer. Connection timeouts, navigation timeouts, and an overall task budget. Agents that hang on a slow page burn browser-hours and block concurrency slots.
Handle the default context carefully. Remote sessions often arrive with a context and page already open. Reuse them rather than creating new ones, or you will accumulate orphaned tabs.
Log the CDP endpoint and session ID with every task. When something fails, correlating a failed agent run to a specific session is the difference between a five-minute fix and an afternoon of guessing.
Test against your actual targets. A hosted browser that performs well on example.com tells you nothing. Run it against the three or four sites that actually give your agent trouble, and measure success rate and latency.
For teams running agents that need to drive the browser interactively, remote control browser covers the human-in-the-loop patterns.
When to choose Bright Data, and when to choose otherwise
Choose a Bright Data agent browser when your agents are fundamentally data collectors operating against sites with active anti-bot defenses, and the network layer is the dominant cost of failure. The proxy network and unblocking are the product, and they are worth paying for in that scenario.
Choose a general hosted Chromium runtime when your agents are long-running, stateful, and numerous; when persistent profiles, live viewing, and per-session isolation are core requirements; and when you want the runtime layer to be the thing you optimize. Remote Browser is built for that case: hosted Chromium sessions with CDP access, Playwright/Puppeteer/Selenium compatibility, a live viewer, persistent profiles, configurable browser and proxy settings, session isolation, and usage controls. Current plans and metering are on /pricing, and the integration surface is documented at /documentation.
The two are not rivals so much as different layers. The mistake is buying a scraping-optimized browser when your problem is runtime management, or buying a runtime when your problem is that many of your target sites block you. Diagnose which problem you actually have, then pick the product that solves it.
Bottom line
A Bright Data agent browser is a proxy-backed, CDP-accessible hosted Chromium session optimized for data collection against defended sites. It is a strong fit for scraping-heavy agents and a weaker fit for stateful, multi-tenant agent runtimes. Because everything speaks CDP, your Playwright code is portable across providers — so keep the provider-specific parts behind an adapter, test against your real targets, and choose based on where your failures actually come from.