How to Run Browser Automation at Scale in the Cloud (2026)

Put jobs in a queue and give each one its own isolated remote browser, driven over CDP with Playwright or Puppeteer. Cap concurrent browsers at your plan's limit, reuse logins with saved profiles, add proxies only for sites that block you, retry failures with backoff, and stop every browser when its job ends. Self-hosting Chrome in containers can be cheaper at high, steady utilization, but you own scaling, fingerprints and crashes.

We make Browser Use. Facts about the other six providers come from their own docs and pricing pages, checked October 27, 2026, and linked in each cell. Our maintained comparison is Cloud browsers for AI agents.

Limits that matter at scale

Full comparison of all seven (proxies, CAPTCHA, regions, self-hosting): Best Browser Infrastructure for AI Agents (2026): 7 Providers Compared.

Where others fit better than us:

• Longer sessions: Anchor (no upper limit), Kernel (no published max), Steel Enterprise (24 h), Hyperbrowser (12 h), Browserbase (6 h). Ours stop at 4 h.
• Long idle waits: Kernel charges nothing while a browser is in standby.
• Regions, self-hosting, Firefox or WebKit: see the full comparison. We run in the US and Frankfurt, and the EU deployment has fewer features (docs).

For site access, see our browser stealth benchmark.

Architecture

job queue
  -> workers (max = concurrency)
  -> 1 remote browser per job
  -> results, screenshots, logs

• One browser per job. No shared cookies or tabs between jobs, and a crash kills one job, not ten.
• The queue is yours. SQS, Redis or a Postgres table. Workers pull a job, create a browser, run, stop it, ack the job.
• Record the browser ID with the job. A cleanup job can then stop browsers whose job already finished.
• Logins: save them in a profile once and pass the profile ID when you create a browser (Browser Use profiles).

Concurrency and rate limits

Two limits, counted separately: browsers running at once, and how fast you can call the API or create sessions.

• Browser Use: concurrency by lifetime top-ups (table above). API requests: max(25, 2 × concurrency) per second per project, the general bucket capped at 100. A 429 carries Retry-After; honor it (docs).
• Browserbase: 5, 25, 50 or 150+ new sessions per minute by plan, so Startup takes about 2 minutes to start all 100 (docs).
• Anchor: 5, 25, 100 or 200+ new sessions per minute (Free, Starter, Growth, Enterprise); Team not published (docs).
• Steel: 60 or 600 requests per minute on Launch or Scale (pricing).
• Kernel: a separate create rate; browser pools skip it, so use one for bursts (docs).

Cap workers at your concurrency limit and pace creates under the create rate; keep the backlog in your own queue.

Cost math: an example

Example workload: 1,000 jobs a day, 3 browser-minutes each, 20 running at once, for 30 days. That is 1,500 browser-hours and 30,000 browser starts. List prices from the table, monthly billing, cheapest plan that allows 20 at once. Totals leave out traffic, CAPTCHA and model costs.

Browser Use's proxy is on by default ($5/GB). The $30 assumes proxyCountryCode: null, which bills traffic at $0.20/GB (pricing), as Anchor does without a proxy (docs). Kernel includes proxy traffic in stealth mode (pricing).

What moves the number:

• Leaked browsers. Browser Use charges the session timeout up front (60 min default) and refunds the unused part when you stop it. Never stopped means billed to the timeout (docs).
• Short jobs. Browser Use and Browserbase bill per minute with a 1-minute minimum; Anchor adds $0.01 per browser.
• Proxy traffic. At our $5/GB, a job that pulls 10 MB through the proxy costs $0.05, more than 2 hours of browser time. Measure MB per job first.

Reliability checklist

• Timeouts at three levels: per page action, per job, and the browser's own session timeout.
• Retries with backoff: retry 429s, 5xx and navigation timeouts with exponential backoff and jitter; honor Retry-After; cap attempts.
• Stop browsers in finally. Closing the CDP connection does not stop a Browser Use browser (docs).
• On failure, save evidence: screenshot, URL, console errors, browser ID. Turn on recording when you debug (enableRecording on Browser Use).
• Idempotent tasks: give each job an ID and check before you submit a form or pay, so a retry does not do it twice.

Code: N jobs, LIMIT browsers at a time

Browser Use Cloud, TypeScript, from the quickstart.

npm install browser-use-sdk playwright
export BROWSER_USE_API_KEY=your_key
npx tsx scale.ts

// scale.ts
import { BrowserUse } from "browser-use-sdk/v4";
import { chromium } from "playwright";
 
const client = new BrowserUse();
// your plan's concurrency (10 at $0)
const LIMIT = 10;
const urls = [
  "https://example.com",
  "https://example.org",
];
 
async function runJob(url: string) {
  // timeout in minutes: the browser stops
  // by then even if stop() never runs
  const session = await client.browsers.create({
    // no proxy; set a country code (e.g. "us")
    // only for sites that block you
    proxyCountryCode: null,
    timeout: 15,
  });
  try {
    if (!session.cdpUrl) throw new Error("no CDP URL");
    const browser =
      await chromium.connectOverCDP(session.cdpUrl);
    try {
      const context = browser.contexts()[0];
      const page =
        context.pages()[0] ?? (await context.newPage());
      await page.goto(url, { timeout: 60_000 });
      return await page.title();
    } finally {
      // closes the connection, not the cloud browser
      await browser.close();
    }
  } finally {
    // stops the browser, refunds unused time
    await client.browsers.stop(session.id);
  }
}
 
type Result = { url: string; title?: string; error?: string };
 
async function main() {
  const queue = [...urls];
  const results: Result[] = [];
  await Promise.all(
    Array.from({ length: LIMIT }, async () => {
      for (let url = queue.shift(); url; url = queue.shift()) {
        try {
          results.push({ url, title: await runJob(url) });
        } catch (e) {
          results.push({ url, error: String(e) });
        }
      }
    }),
  );
  console.log(results);
}
 
main();

Any CDP provider works the same way: create a session with its API, chromium.connectOverCDP(url), then end the session with its API. Playwright notes that a CDP connection is lower fidelity than its own browserType.connect() protocol (Playwright docs).

Self-host vs managed

• Self-host: Playwright's Docker image, run with --init and --ipc=host; without --ipc=host Chromium can run out of memory and crash (Playwright Docker docs). playwright run-server lets remote workers connect. You own autoscaling, proxies, fingerprints, CAPTCHAs, crash recovery and browser updates.
• Managed: you pay per browser-hour; the provider runs isolation, proxies, CAPTCHA solving, live view and recordings.
• Pick self-hosting when target sites do not block you and you already run containers. Pick managed when sites block you or your load is bursty.

More

• Cloud browsers for AI agents: the comparison we keep current
• Best Browser Infrastructure for AI Agents (2026): 7 Providers Compared
• Browser stealth benchmark
• Browser Use pricing and concurrency docs