Concurrency management

Key limits

Browser automation becomes powerful when you can run multiple browser sessions simultaneously. Whether you’re collecting data at scale, running parallel tests, or serving multiple users, understanding concurrency and rate limits is critical. To ensure system stability and fair resource allocation, two key limits apply:

Max Concurrent Browsers: The maximum number of browser sessions that you can run at the same time
Session Creation Limit: The maximum number of new browser sessions you can create within any 60-second period

If either limit is reached, your request will receive a 429 (too many requests) error.

One Minute Minimum: each browser session requires dedicated resources and has a minimum runtime of one minute, even if closed before.

Limits by plan

These limits depend on your plan:

Plan	Free	Developer	Startup	Scale
Max Concurrent Browsers	3	25	100	250+
Session Creation Limit per minute	5	25	50	150+

Limits and concurrency per project

Concurrency is assigned at the organization level — if you’re on the Developer plan, you have 25 total concurrent browsers allotted to your organization, distributed across your projects as you see fit. With one project, all concurrent browsers simply go to that one project. When you create a second project, 1 concurrent browser is automatically added to your second project (since you need at least one browser per project). This subtracts from your first project. If you have two projects, here’s how the concurrency will assign by default:

Developer plan: Project 1 (24 browsers) + Project 2 (1 browser)
Startup plan: Project 1 (99 browsers) + Project 2 (1 browser)
Scale plan: Fully custom

Adjust concurrency

You can adjust the concurrency for your projects in the dashboard. Go to your organization page, then click on the triple dots next to the project you want to adjust and select “Update concurrency”. Then you can adjust the concurrency for each project.

Using your concurrency

Once you know your concurrency limits, you can put them to work. Run multiple browser sessions in parallel to speed up processing a list of URLs, running tests across pages, or powering multi-agent workflows.

Parallel sessions

You can use Promise (TypeScript) or asyncio (Python) to run your browser sessions in parallel. The example below extracts article headlines from multiple pages of Hacker News concurrently — each page gets its own browser session:

TypeScript
Python

import { chromium } from "playwright-core";
import { Browserbase } from "@browserbasehq/sdk";

const bb = new Browserbase({ apiKey: process.env.BROWSERBASE_API_KEY! });

const pages = [1, 2, 3];
const urls = pages.map((p) => `https://news.ycombinator.com/?p=${p}`);

async function getHeadlines(url: string) {
  const session = await bb.sessions.create();
  const browser = await chromium.connectOverCDP(session.connectUrl);

  try {
    const page = browser.contexts()[0].pages()[0];
    await page.goto(url, { waitUntil: "domcontentloaded" });

    const headlines = await page.$$eval(".titleline > a", (links) =>
      links.map((a) => ({ title: a.textContent, href: a.href }))
    );

    return { url, headlines };
  } finally {
    await browser.close();
  }
}

// Run all 3 pages concurrently
const results = await Promise.allSettled(urls.map(getHeadlines));

for (const result of results) {
  if (result.status === "fulfilled") {
    console.log(`\n--- ${result.value.url} ---`);
    result.value.headlines.forEach((h, i) => console.log(`${i + 1}. ${h.title}`));
  } else {
    console.error("Session failed:", result.reason);
  }
}

import asyncio
import os
from playwright.async_api import async_playwright
from browserbase import Browserbase

bb = Browserbase(api_key=os.environ["BROWSERBASE_API_KEY"])

pages = [1, 2, 3]
urls = [f"https://news.ycombinator.com/?p={p}" for p in pages]

async def get_headlines(url: str, pw):
    session = bb.sessions.create()
    browser = await pw.chromium.connect_over_cdp(session.connect_url)

    try:
        page = browser.contexts[0].pages[0]
        await page.goto(url, wait_until="domcontentloaded")

        links = await page.query_selector_all(".titleline > a")
        headlines = []
        for link in links:
            title = await link.text_content()
            href = await link.get_attribute("href")
            headlines.append({"title": title, "href": href})

        return {"url": url, "headlines": headlines}
    finally:
        await browser.close()

async def main():
    async with async_playwright() as pw:
        results = await asyncio.gather(
            *(get_headlines(url, pw) for url in urls),
            return_exceptions=True,
        )
        for result in results:
            if isinstance(result, Exception):
                print(f"Session failed: {result}")
            else:
                print(f"\n--- {result['url']} ---")
                for i, h in enumerate(result["headlines"], 1):
                    print(f"{i}. {h['title']}")

asyncio.run(main())

Reaching limits: 429s

When reaching the session concurrency limit of your plan, any subsequent request to create a new session will return an HTTP 429 Too Many Requests error. That means the request was effectively dropped. For example, if you have a Developer plan (with a limit of 25 concurrent sessions) you can create up to 25 sessions in a 60 second window. If you try to create a 26th session within that window, it will be rate limited and return an HTTP 429 error. To check the status of your rate limit, you can look at the headers of the response:

x-ratelimit-limit - How many requests you can make.
x-ratelimit-remaining - How many requests remain in the time window.
x-ratelimit-reset - How many seconds must pass before the rate limit resets.
retry-after - If the max has been reached, this is the number of seconds you must wait before you can make another request. This is documented here.

HTTP/1.1 429 Too Many Requests
Content-Type: application/json
x-ratelimit-limit: 25
x-ratelimit-remaining: 0
x-ratelimit-reset: 45
retry-after: 45

Handling rate limits

If you’re attempting to run more sessions than your current project’s concurrency limit, some session creation requests will return a 429. One option is to wrap session creation in a retry helper that respects the retry-after header:

TypeScript
Python

const MAX_RETRIES = 5;

async function createSessionWithRetry() {
  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
    try {
      return await bb.sessions.create();
    } catch (error: any) {
      if (error.status !== 429 || attempt === MAX_RETRIES - 1) throw error;

      const retryAfter = parseInt(error.headers?.["retry-after"] ?? "2", 10);
      const backoff = retryAfter * 1000 * Math.pow(2, attempt);
      await new Promise((resolve) => setTimeout(resolve, backoff));
    }
  }
}

MAX_RETRIES = 5

async def create_session_with_retry():
    for attempt in range(MAX_RETRIES):
        try:
            return bb.sessions.create(
                project_id=os.environ["BROWSERBASE_PROJECT_ID"],
            )
        except Exception as error:
            status = getattr(error, "status_code", None)
            if status != 429 or attempt == MAX_RETRIES - 1:
                raise

            retry_after = int(getattr(error, "headers", {}).get("retry-after", 2))
            backoff = retry_after * (2 ** attempt)
            await asyncio.sleep(backoff)

Serverless Alternative: Functions provide built-in concurrency management and automatic session lifecycle. Functions handle session creation and cleanup automatically, making them ideal for high-concurrency workloads without manual session management.

If you need more concurrency, upgrade to a plan with higher limits. See Plans for more details, or reach out to Browserbase at support@browserbase.com with any questions.

Welcome

Platform

Use cases

Optimization

Account

Key limits

Limits by plan

Limits and concurrency per project

Adjust concurrency

Using your concurrency

Parallel sessions

Reaching limits: 429s

Handling rate limits

Welcome

Platform

Use cases

Optimization

Account

​Key limits

​Limits by plan

​Limits and concurrency per project

​Adjust concurrency

​Using your concurrency

​Parallel sessions

​Reaching limits: 429s

​Handling rate limits

Key limits

Limits by plan

Limits and concurrency per project

Adjust concurrency

Using your concurrency

Parallel sessions

Reaching limits: 429s

Handling rate limits