Skip to main content
Back

Browser Use's Browser-Wall Lets One Agent Control Parallel Browsers at $0.02/hr

Browser Use's new 'browser-wall' lets a single CDP endpoint orchestrate multiple cloud browsers simultaneously, with built-in profiles and proxies for scale

  • Browser-wall is Browser Use's upcoming cloud hub that routes a single CDP URL to multiple cloud browsers simultaneously.
  • A demo shows one agent controlling 4 browsers in parallel, each with separate profiles and proxies, spinning up in under a second.
  • Built on Browser Use's existing raw CDP infrastructure after the team dropped Playwright for lower-latency direct browser control.
  • New browser infrastructure is priced at $0.02/hr, 3x cheaper than the current $0.06/hr per-session rate.
  • Not yet publicly available; waitlist is open at browser-use.com.
  • Targets parallel research, multi-account automation, and high-throughput scraping workflows where managing N separate CDP connections is the current pain point.

Browser Use just teased its next infrastructure product: browser-wall, a cloud browser hub that lets a single agent control multiple browsers in parallel through one unified connection point. The demo shows an agent driving four browsers simultaneously, each loaded with separate profiles and proxies. It is not fully launched yet, but a waitlist is live.

The problem it is solving

Running browser agents at scale today is a mess of infrastructure. Running headless browsers locally often leads to crashes from memory leaks, heavy server resource usage, broken setups after browser updates, and detection by anti-bot systems. The standard workaround is to spin up a separate cloud browser session per task, but that means managing a fleet of individual CDP connections, each with its own lifecycle, proxy, and auth state.

Browser-wall collapses that complexity. Instead of your agent juggling N separate WebSocket connections, it exposes one CDP URL that acts as a router to all active cloud browsers underneath. Think of it as a load balancer, but for browser sessions.

What browser-wall actually does

Based on the announcement, browser-wall is built around three core capabilities:

  • One CDP URL to rule them all. Cloud browser APIs are services that provide remote browser instances accessible via Chrome DevTools Protocol (CDP) or WebSocket connections. Browser-wall wraps multiple of those instances behind a single endpoint, so your agent code does not change as you scale from one browser to ten.
  • Sub-second cold starts. The demo shows four browsers spinning up nearly instantly. Browser Use's new infrastructure claims sub-second cold starts and describes itself as 3x cheaper at $0.02/hr.
  • Profiles and proxies pre-loaded. Each browser in the wall comes with its own identity. Browser Use already offers anti-detect, CAPTCHA solving, and 195+ country proxies, and browser-wall appears to bundle those capabilities per-session automatically.

Why CDP is the right primitive here

CDP, or the Chrome DevTools Protocol, is the low-level wire protocol that every browser automation tool eventually talks to. Playwright, Puppeteer, and Selenium are all just wrappers around it. Browser Use made a deliberate bet on going direct.

Browser Use dropped Playwright and switched to raw CDP for faster, more capable browser automation. Playwright and Puppeteer are great for making QA tests and automation scripts short and readable, but AI browser companies have been learning the hard way that these adapters obscure important details about the underlying browsers. Browser Use decided to speak the browser's native tongue: CDP.

By switching to raw CDP, they massively increased the speed of element extraction, screenshots, and all default actions, and also added new async reaction capabilities and proper cross-origin iframe support. Browser-wall is a direct extension of that philosophy: if you are already talking raw CDP, why not route that single connection to as many browsers as you need?

The architecture under the hood

The existing Browser Use cloud already exposes individual browser sessions via CDP. Browser sessions provide direct access to Chrome browsers via DevTools Protocol (CDP), enabling advanced automation and custom browser control. Browser-wall appears to add a multiplexing layer on top, so one agent can address all sessions through a single hub rather than managing separate connections.

This is meaningful for agent orchestration. Today, if you want to run a research agent that opens four tabs in parallel on different sites, you either serialize the work or write custom concurrency logic. With browser-wall, the parallelism is handled at the infrastructure layer. Your agent just sends commands and the wall figures out which browser handles what.

Here is what the existing cloud browser connection looks like in Python today, which browser-wall would simplify further:

from browser_use import Agent, Browser, ChatBrowserUse
# Today: one browser per agent instance
browser = Browser(
    use_cloud=True,
    cloud_profile_id='your-profile-id',
    cloud_proxy_country_code='us',
)
agent = Agent(
    task="Research competitors across 4 sites simultaneously",
    llm=ChatBrowserUse(),
    browser=browser,
)
await agent.run()

Practical use cases

The single-CDP-URL design unlocks a class of workflows that are currently painful to build:

  • Parallel web research , send an agent to scrape four sources at once instead of sequentially visiting each
  • Multi-account workflows , each browser in the wall carries a different profile, so you can operate across accounts without session bleed
  • A/B testing automation , run the same agent task across different geographic proxies simultaneously to compare results
  • High-throughput data pipelines , spin up a wall of browsers for bulk extraction jobs without provisioning infrastructure
  • Competitive monitoring , watch multiple competitor pages in real time with a single agent orchestrating all sessions

Pricing and availability

Browser-wall is not yet publicly available. Browser Use is collecting signups at their site ahead of launch. Individual browser sessions currently cost $0.06/hour, charged upfront when the session starts, with unused time refunded proportionally and a minimum charge of one minute. The new infrastructure pricing, advertised at $0.02/hr, suggests browser-wall sessions will be significantly cheaper than the existing per-session model.

The broader Browser Use cloud runs on a tiered subscription model. The free plan starts at $0 with up to 3 concurrent sessions, while paid plans start at $29/month for 25 concurrent sessions, scaling to $999/month for 500 concurrent sessions. Browser-wall will likely sit on top of this credit system.

The bigger picture

The cloud browser space is getting crowded fast. Browserbase, Cloudflare Browser Run, Scrapfly, and Browserless all offer CDP-accessible cloud browsers. Cloud browser APIs solve specific infrastructure problems: they remove browser management overhead, enable instant scaling to 100 concurrent sessions, provide better anti-detection, and offer cost efficiency through pay-per-use instead of idle server capacity.

What Browser Use is betting on with browser-wall is that the next bottleneck is not individual browser sessions but the orchestration layer above them. Cloud browsers are well-suited for AI agents, with frameworks like Browser Use connecting to cloud browsers via CDP, and the scalability and session persistence of cloud browsers matching AI agent requirements well. Browser-wall is an attempt to make that connection not just functional but trivially easy to parallelize.

The real question is whether a single unified CDP endpoint can handle the routing complexity cleanly at scale, especially when different browsers in the wall are at different stages of a task. That is the engineering problem Browser Use has not yet shown in public. The demo is compelling, but the hard part is what happens when browser three crashes mid-task while browsers one, two, and four are still running.