Skip to content
Skills Library
DevOps & cloud · Tool integration

browserbase

/browserbase

Browserbase runs managed headless Chromium sessions in the cloud, so browser automation, AI agents and scraping jobs need no browser infrastructure of their own. Use when someone asks to "run Playwright in the cloud", "Browserbase session", "headless browsers at scale", "scrape with proxies and CAPTCHA solving", "persist a login across browser sessions", or "use Stagehand with Browserbase". Covers sessions, proxies, contexts, parallel runs and replays.

Repository
skills ↗
Licence
Apache-2.0
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
3
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Browserbase runs managed headless Chromium sessions in the cloud, so browser automation, AI agents and scraping jobs need no browser infrastructure of their own. Use when someone asks to "run Playwright in the cloud", "Browserbase session", "headless browsers at scale", "scrape with proxies and CAPTCHA solving", "persist a login across browser sessions", or "use Stagehand with Browserbase". Covers sessions, proxies, contexts, parallel runs and replays.

Triggers from the description

run Playwright in the cloudBrowserbase sessionheadless browsers at scalescrape with proxies and CAPTCHA solvingpersist a login across browser sessionsuse Stagehand with Browserbase
Original author description

Browserbase runs managed headless Chromium sessions in the cloud, so browser automation, AI agents and scraping jobs need no browser infrastructure of their own. Use when someone asks to "run Playwright in the cloud", "Browserbase session", "headless browsers at scale", "scrape with proxies and CAPTCHA solving", "persist a login across browser sessions", or "use Stagehand with Browserbase". Covers sessions, proxies, contexts, parallel runs and replays.

How it works

  1. Overview
  2. Instructions
  3. Examples
  4. Guidelines
Original SKILL.md headings · 123 lines, 792 words
SKILL.md preview
---
name: browserbase
description: >-
  Browserbase runs managed headless Chromium sessions in the cloud, so browser
  automation, AI agents and scraping jobs need no browser infrastructure of
  their own. Use when someone asks to "run Playwright in the cloud", "Browserbase
  session", "headless browsers at scale", "scrape with proxies and CAPTCHA
  solving", "persist a login across browser sessions", or "use Stagehand with
  Browserbase". Covers sessions, proxies, contexts, parallel runs and replays.
license: Apache-2.0
compatibility: "Node.js 18+ with @browserbasehq/sdk and playwright-core; needs a Browserbase account (BROWSERBASE_API_KEY). Some options require a paid plan."
metadata:
  author: terminal-skills
  version: "1.1.0"
  category: devops
  tags: "browser-automation, cloud-browser, headless, scraping, infrastructure"
  repository: https://github.com/browserbase/sdk-node
---

# BrowserBase — Cloud Browser Infrastructure for AI Agents

## Overview

Browserbase is a hosted service that starts isolated Chromium sessions on demand. You create a session through the REST API or the Node SDK (`@browserbasehq/sdk`), receive a WebSocket `connectUrl`, and drive the browser with Playwright, Puppeteer or Selenium over CDP. The service adds proxies, CAPTCHA solving, session recording and logs, live view, and persistent contexts. Stagehand, Browserbase's open-source SDK with `act`, `extract` and `observe` primitives, uses it as its cloud browser. It is a paid, account-based service; this skill was checked against the public documentation only, not against a live account.

## Instructions

### Install and authenticate

```bash
npm install @browserbasehq/sdk playwright-core
export BROWSERBASE_API_KEY=...        # from the Browserbase dashboard, never hard-code
export BROWSERBASE_PROJECT_ID=...     # Settings page; optional, the API key can infer it
```

The REST API authenticates with the `X-BB-API-Key` header; the SDK sets it from `apiKey`.

### Create a session and connect

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

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

const session = await bb.sessions.create({
  projectId: process.env.BROWSERBASE_PROJECT_ID!,
  browserSettings: {
    viewport: { width: 1280, height: 720 },
    blockAds: true,            // default false
    solveCaptchas: true,       // default true
    recordSession: true,       // default true
  },
  proxies: true,               // Browserbase-managed proxies
  region: "us-east-1",         // us-west-2 | us-east-1 | eu-central-1 | ap-southeast-1
  timeout: 300,                // seconds, allowed range 60-21600
  keepAlive: false,            // true needs the Hobby plan or above
});

const browser = await chromium.connectOverCDP(session.connectUrl);
const page = browser.contexts()[0].pages()[0];
await page.goto("https://news.ycombinator.com");
console.log(await page.title());
await browser.close();

console.log(`Replay: https://browserbase.com/sessions/${session.id}`);
```

Other useful `browserSettings`: `os`, `allowedDomains`, `verified` (Verified Browser mode, plan dependent), `ignoreCertificateErrors`. Use `userMetadata` on the session to tag runs for later filtering.

### Persistent contexts (keep logins)

```typescript
const ctx = await bb.contexts.create({ name: "shop-admin" });

// First run: log in, then close the session so the state is saved
const first = await bb.sessions.create({
  browserSettings: { context: { id: ctx.id, persist: true } },
});

// Later run: already authenticated; persist: false = read the state, do not change it
const later = await bb.sessions.create({
  browserSettings: { context: { id: ctx.id, persist: false } },
});
```

Wait a few seconds after closing a `persist: true` session before reusing the context, and do not run two sessions on one context at once, or the site may log you out.

### Parallel runs

```typescript
async function titles(urls: string[], concurrency = 5) {
  const out: { url: string; title?: string; error?: string }[] = [];
  for (let i = 0; i < urls.length; i += concurrency) {
    const batch = urls.slice(i, i + concurrency);
    const settled = await Promise.allSettled(batch.map(async (url) => {
      const s = await bb.sessions.create({ projectId: process.env.BROWSERBASE_PROJECT_ID! });
      const b = await chromium.connectOverCDP(s.connectUrl);
      try {
        const p = b.contexts()[0].pages()[0];
        await p.goto(url, { waitUntil: "domcontentloaded" });
        return { url, title: await p.title() };
      } finally {
        await b.close();
      }
    }));
    settled.forEach((r, j) =>
      out.push(r.status === "fulfilled" ? r.value : { url: batch[j], error: String(r.reason) }));
  }
  return out;
}
```

### Stagehand

Stagehand is installed separately (`@browserbasehq/stagehand`, which also needs zod). Its constructor changed between major versions, so follow the README of the version you install rather than copying older snippets; the primitives (`act`, `extract`, `observe`) stay the same.

## Examples

### Example 1: Scrape a page that blocks datacenter IPs

**User prompt:** "Grab the product titles from this retailer, it blocks my server's IP."

The agent creates a session with `proxies: true` and a nearby `region`, connects with `chromium.connectOverCDP`, extracts titles with `page.$$eval`, closes the browser, and prints the replay URL. Result: a JSON list of titles; if the run is blocked, the replay shows where.

### Example 2: Reuse a logged-in session

**User prompt:** "Log into our supplier portal once and let nightly jobs reuse it."

The agent creates a context named `supplier-portal`, runs one interactive login with `persist: true`, stores the context id in `SUPPLIER_CONTEXT_ID`, and has nightly jobs create sessions with that context. When the portal expires the cookie, the job reports "login required" instead of retrying blindly.

## Guidelines

- Credentials come from environment variables; never commit API keys or put them in page scripts.
- Always close the browser in `finally`; sessions otherwise run until `timeout` and count against your concurrency limit.
- Stay within your plan's concurrent-session limit; batch with `Promise.allSettled`.
- Proxies, CAPTCHA solving and recordings do not make scraping permitted: respect the target's terms and robots rules.
- A recorded session can contain typed passwords or personal data; set `recordSession: false` for sensitive logins.
- `keepAlive`, regions and some stealth options depend on the plan; check the dashboard if the API rejects a field.
- For a local one-off script, plain Playwright is simpler and free; use Browserbase when you need scale, proxies or observability.
Files in this package (2)
  • SKILL.md 7 KB
  • _scores.json 3 KB

Versions

RepositoryScoreLicence
This page · TerminalSkills/skills100Apache-2.0
poly-gents/syncolab-skills100Apache-2.0

Database snapshot: 13.11.2026 · package version 9889a087aa2a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95browserbase-sessions
    Create and manage persistent Browserbase cloud browser sessions with authentication persistence. Use when you need to automate browsers, maintain logged-in sessions across interactions, scrape authenticated pages, or manage cloud browser instances.
  • 100stagehand
    Operate Browserbase Stagehand, the MIT-licensed browser-agent SDK and `browse` CLI for local or Browserbase Chromium automation, natural-language `act`, `observe`, and `extract`, typed WebMCP calls, cloud Search/Fetch, Playwright migrations, and Browserbase MCP integration. Use…
  • 95browserbase-cookbook
    Find and adapt Browserbase cookbook examples for browser automation, Stagehand, Playwright, authentication, extraction, agent frameworks, and business workflows. Use when selecting an example, implementing from a Browserbase recipe, or troubleshooting its setup.
  • 90build-browser-agent
    Build or adapt a consumer browser agent with Stagehand v4 and Browserbase using the Browsie pattern. Use for adding persistent browser tools, Browserbase Contexts, vaults, human handoff, CAPTCHA state, channels, or an inspection UI to an agent application. Do not use for a…
  • 95functions
    Deploy serverless browser automation as cloud functions using Browserbase. Use when the user wants to deploy browser automation to run on a schedule or cron, create a webhook endpoint for browser tasks, run automation in the cloud instead of locally, or asks about Browserbase Functions.
  • 100browser-use-to-stagehand
    Migrate browser-use (Python) browser-automation scripts to Stagehand v3 (TypeScript) on Browserbase. Use when the user wants to convert, port, rewrite, or migrate a browser-use Agent script to Stagehand, map browser-use features/APIs to Stagehand primitives…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.