Browserbase skills: Claude Code plus hosted browser automation (bb CLI)

browserbase/skills packages Claude Code skills for Browserbase: remote browser sessions, the official bb CLI, function deploys, DevTools traces, Chrome cookie sync, fetch/search helpers, UI-test flows, and safe-browser allowlists—via npx skills add or the Claude Code plugin marketplace.

It ranked on GitHub Trending in May 2026; the table below mirrors the upstream README.

TL;DR

Install snippets

npx skills add browserbase/skills

Claude Code marketplace flow (from README):

/plugin marketplace add browserbase/skills
/plugin install browse@browserbase

Restart Claude Code after plugin installs per upstream guidance.

Why browser automation for AI agents is different

Traditional browser automation (Selenium, Playwright, Puppeteer) is built for deterministic test scripts: explicit waits, CSS selectors, sequential steps. AI agents operate under different constraints:

Intent-based vs selector-based: Agents receive natural language instructions ("find the cheapest flight to Tokyo") not XPath queries. They need browsers that can translate semantic goals into DOM operations.

Adaptive vs brittle: Human-written tests break when a website redesigns. Agents should adapt to layout changes, navigation shifts, and dynamic content without code updates.

Stealth vs detectable: Many sites block automation tools via bot detection (Cloudflare, Akamai, etc.). Agents need browsers that look like real users: realistic fingerprints, human-like mouse movements, session continuity.

Hosted vs local: Running browsers locally consumes developer machines and requires dependency management (Chrome, drivers, system libraries). Agents benefit from hosted browser infrastructure with clean sessions and managed resources.

Compliance vs cowboy: Agents that scrape data or automate user actions need audit trails, disclosure mechanisms, and consent tracking—not just "make it work."

Browserbase skills address these agent-specific requirements by packaging hosted browser infrastructure with Claude Code-native interfaces.

Skill-by-skill breakdown

browser: core automation via browse CLI

The browser skill wraps the browse CLI for task-driven automation:

What it provides:

• Natural language commands: "go to example.com and extract all product prices"
• Remote browser sessions managed by Browserbase infrastructure
• Stealth mode with realistic fingerprints and anti-detection measures
• CAPTCHA handling (integrated solvers for common providers)
• Residential proxy support for geo-specific content
• Session recording for debugging and audit

Example workflow:

1. Agent receives instruction: "Compare prices for this product on three e-commerce sites"
2. Skill launches remote browser via Browserbase API
3. Agent navigates to each site using natural language commands
4. Skill extracts structured data from DOM
5. Agent compares results and formats output

Under the hood: The browse CLI translates agent instructions into Playwright-style operations but abstracts selector brittleness. Instead of page.click('button.checkout'), the agent might say "click the checkout button" and the skill uses vision/DOM understanding to find the right element.

browserbase-cli: official bb CLI wrapper

The browserbase-cli skill exposes the full bb CLI for lower-level control:

Session management:

bb sessions create --project my-project
bb sessions get <session-id>
bb sessions list --project my-project

Project operations:

bb projects create --name "agent-automation"
bb projects update <id> --settings '{"stealth": true}'

Context management: Persistent browser contexts with saved cookies, storage, and authentication:

bb contexts create --name "logged-in-user"
bb contexts upload-cookies cookies.json

Extensions: Install browser extensions in remote sessions:

bb extensions install <extension-id>

Dashboard integration: Open Browserbase web console for manual inspection:

bb dashboard open <session-id>

This skill is for agents that need infrastructure control, not just "browse this page." Example: an agent might create a persistent context with logged-in credentials, then reuse it across multiple sessions to avoid re-authentication.

functions: serverless browser automation

The functions skill lets you deploy standalone browser automation scripts to Browserbase infrastructure:

What it enables:

• Write automation logic once, run on-demand via API
• No local browser dependencies
• Automatic scaling (Browserbase handles concurrency)
• Scheduled or event-triggered execution

Example deployment:

// scrape-products.ts
export async function scrapeProducts(url: string) {
  const browser = await browserbase.launch();
  const page = await browser.newPage();
  await page.goto(url);
  const products = await page.$$eval('.product', els =>
    els.map(el => ({
      name: el.querySelector('.name').textContent,
      price: el.querySelector('.price').textContent
    }))
  );
  return products;
}

Deploy via skill:

bb functions deploy scrape-products.ts

Invoke from agent:

bb functions invoke scrape-products --args '{"url": "https://example.com/products"}'

This pattern is useful when the same automation runs repeatedly (hourly price checks, daily content monitoring, etc.). The agent can trigger functions without re-explaining the logic each time.

browser-trace: deep debugging with CDP traces

The browser-trace skill captures Chrome DevTools Protocol traces for post-mortem debugging:

What it records:

• Full network waterfall (requests, responses, timings)
• DOM snapshots at each navigation
• JavaScript console logs and errors
• Performance metrics (paint times, layout shifts)
• Screenshots at key interaction points

When to use: Agent automation failed and you need to understand why. Was it a selector issue? Network timeout? JavaScript error? The trace gives you everything DevTools would show in a live session.

Storage: Traces are uploaded to S3-compatible buckets with configurable retention. The skill provides URLs for viewing in Chrome DevTools or third-party trace analyzers.

Example agent workflow:

1. Agent attempts to automate checkout flow
2. Automation fails at payment step
3. Skill automatically captured trace
4. Developer reviews trace, sees CORS error blocking API call
5. Fix underlying issue, agent retries successfully

site-debugger: AI-assisted troubleshooting

The site-debugger skill uses AI to diagnose automation failures:

How it works:

1. Automation fails with error message
2. Skill captures page state (DOM, network, console)
3. Skill sends state to LLM with debugging prompt
4. LLM suggests likely causes and remediation steps

Example output:

Failure: Unable to click "Submit" button

Diagnosis:
- Button exists in DOM but is disabled (class "btn-disabled")
- Form validation error present: "Email field required"
- Suggested fix: Fill email field before clicking submit

Recommended playbook:
1. Find email input field
2. Enter valid email
3. Wait for validation to pass
4. Retry submit button

This skill turns opaque automation failures into actionable debugging steps, reducing the iteration loop from "agent tries random things" to "agent gets specific guidance."

safe-browser: domain-allowlisted browsing

The safe-browser skill is for constrained environments where unrestricted browsing would be a security risk:

Use case: Building a customer-facing agent that can browse documentation but should not access arbitrary websites.

How it works:

• Define allowlist in configuration: ["docs.example.com", "help.example.com"]
• Skill exposes a safe_browser tool to the agent
• Tool rejects navigation to non-allowlisted domains
• Tool uses CDP (Chrome DevTools Protocol) to enforce restrictions at browser level

Example configuration:

{
  "allowed_domains": ["docs.example.com", "*.stackoverflow.com"],
  "block_third_party_requests": true,
  "disable_javascript": false
}

This is the browser equivalent of least-privilege access: give agents the minimum browsing capability needed for their task, not full internet access.

cookie-sync: share authentication between browsers

The cookie-sync skill copies cookies from your local Chrome profile into Browserbase remote sessions:

Why this matters: Many workflows require authenticated access (internal tools, subscription sites, personalized dashboards). Manually logging in during each automation is tedious and hard to script (2FA, CAPTCHAs, etc.).

Workflow:

1. Log into target site in your local Chrome
2. Run cookie-sync skill to export cookies
3. Skill uploads cookies to Browserbase persistent context
4. Agent uses that context for authenticated automation

Security note: Cookie files contain session tokens equivalent to passwords. The skill encrypts cookies in transit and at rest, but you are trusting Browserbase infrastructure with your credentials. Only sync cookies for non-critical accounts or use dedicated automation accounts.

fetch / search: lightweight alternatives to full browsers

The fetch and search skills provide HTTP-based data access when you do not need a full browser:

fetch skill: Simple HTTP requests with agent-friendly interfaces:

fetch https://api.example.com/data --headers '{"Authorization": "Bearer token"}'

Faster and cheaper than launching a browser for API access or static content.

search skill: Web search without browser overhead:

search "DeepSeek V4 pricing comparison"

Returns search results (titles, snippets, URLs) that the agent can summarize or use for further browsing.

Use these skills when:

• Target is a JSON API (fetch)
• Target is static HTML with no JavaScript (fetch)
• You need search results without visiting each page (search)

Reserve full browser automation for:

• JavaScript-heavy SPAs
• Sites with bot detection
• Interactive workflows (clicking, scrolling, form filling)

ui-test: adversarial testing for web UIs

The ui-test skill runs exploratory testing against your web applications:

Modes:

1. Diff-based: Agent compares current UI to previous snapshot, identifies changes, tests affected areas
2. Exploration: Agent crawls site looking for broken links, console errors, accessibility issues
3. Regression: Agent runs through user flows (signup, checkout, etc.) to catch breakage

Example output:

Test run: E-commerce checkout flow
- ✓ Product search works
- ✓ Add to cart works
- ✗ Checkout button unresponsive (console error: "payment.js failed to load")
- ✗ Accessibility issue: Missing alt text on product images

This skill is useful for continuous testing: let the agent run ui-test after each deployment to catch regressions before users do.

Why ExplainX readers should care

Browsing is the usual second hop after MCP tools: our MCP guide explains the protocol; Browserbase skills are a vendor pack that wires hosted browser infra into Claude Code with reviewable SKILL.md units—the same composability story as agent skills.

If DOM snapshots spam your transcript, pair with context-mode—browser tools are exactly the output class those projects target.

The value proposition: instead of writing custom Playwright scripts and managing browser infrastructure, you give Claude Code a skill that says "browse this competitive product page" and get back structured data. The skill handles stealth, proxies, CAPTCHA, error recovery, and tracing. You handle the high-level workflow.

Security and compliance considerations

Browser automation introduces risks that simple API calls do not:

Credentials exposure: Cookie-sync and authenticated sessions mean agents handle your login tokens. Use dedicated automation accounts, rotate credentials regularly, and audit session logs.

Bot policy compliance: Many sites prohibit automated access in their Terms of Service. Scraping without permission can violate ToS or laws (CFAA in the US, similar statutes globally). Understand legal boundaries before deploying agents that crawl third-party sites.

Data privacy: Agents might collect personal data during browsing (emails, names, addresses). Ensure you have legal basis for collection and processing. Browserbase provides audit trails for compliance, but you are responsible for lawful use.

Allowlisting: Use safe-browser skill for customer-facing agents to prevent agents from accessing arbitrary websites. A misconfigured agent with full browsing can exfiltrate data or access internal tools.

Rate limiting: Even if browsing is allowed, excessive automation can be interpreted as abuse or DDoS. Implement rate limits and respect robots.txt.

Transparency: When agents interact with services on behalf of users, users should understand what is being accessed and why. Build consent flows and activity logs into your UX.

Cost and operational model

Browserbase pricing (as of May 2026, verify current rates):

Sessions: Billed by duration (minutes of browser runtime)

• Typical range: $0.10–$0.50 per session depending on session length and features (stealth, proxies)

Functions: Serverless execution priced per invocation + runtime

• Cold starts add latency but reduce idle costs

Contexts: Persistent browser contexts with saved state

• Storage costs for cookies, localStorage, cache

Bandwidth: Outbound data transfer from browser sessions

Comparison to self-hosted:

• Self-hosted Playwright: Free compute if you already have servers, but DevOps overhead for browser management, updates, scaling
• Browserbase: Pay-per-use, zero ops, instant scale, but recurring costs

Cost optimization:

• Use fetch/search skills instead of full browsers when possible (10x–100x cheaper)
• Reuse persistent contexts instead of creating new sessions
• Implement caching (if you scraped product data 5 minutes ago, reuse it)
• Set session timeouts to avoid runaway costs from stuck automations

Integration with Claude Code and agent workflows

The skills package is designed for Claude Code's execution model:

SKILL.md structure: Each skill is a markdown file with:

• Description of what the skill does
• Parameters the agent should provide
• Expected output format
• Example invocations

Tool calling: Claude Code translates agent intent into skill invocations:

Agent: "Check if competitor site has lowered prices"
→ Claude Code: Invoke browser skill with task "navigate to competitor.com/pricing and extract prices"
→ Browserbase: Launch browser, execute task, return structured data
→ Claude Code: Present data to agent
→ Agent: "Yes, prices dropped 10%, recommend we match"

Iterative refinement: If first browsing attempt fails, agent sees error and can retry with adjusted strategy:

Attempt 1: "Click login button" → Error: "Button not found"
Agent reasoning: "Maybe login is in a menu"
Attempt 2: "Click menu icon, then click login" → Success

Multi-skill composition: Agents can chain skills:

1. Use search skill to find product comparison sites
2. Use browser skill to scrape each site
3. Use fetch skill to check our own pricing API
4. Compare and generate recommendation

This composability is why skills beat monolithic automation: each piece does one thing well, agents orchestrate the workflow.

Stagehand: complementary tool from Browserbase

The README links Stagehand as a related project. Stagehand is a different take on browser automation:

Stagehand focus: Developer-facing library for building AI-powered browser automation (think "Playwright with AI guidance")

Browserbase skills focus: Pre-packaged Claude Code skills for common automation tasks

Use Stagehand when you are writing code that drives browsers with AI assistance. Use Browserbase skills when you want Claude Code to have browsing capability without writing automation code.

Practical examples

Competitive intelligence:

• Agent monitors competitor pricing pages daily
• Detects changes via ui-test skill
• Alerts when prices drop or new products launch

User research:

• Agent browses landing pages and records session traces
• Analyzes user flows for friction points
• Suggests UX improvements based on observed patterns

Integration testing:

• Agent runs through signup → purchase flow in staging environment
• Uses browser-trace to debug failures
• Compares production vs staging behavior

Content migration:

• Agent browses legacy CMS
• Extracts content using safe-browser with allowlist
• Reformats and uploads to new platform

Accessibility audits:

• Agent crawls site with ui-test skill
• Identifies missing alt text, color contrast issues, keyboard navigation problems
• Generates prioritized fix list

Comparison with alternatives

Playwright / Puppeteer: Lower-level libraries you control fully. Browserbase skills abstract infrastructure and common patterns. Choose Playwright when you need custom automation logic; choose Browserbase skills when you want agent-ready browsing.

Selenium: Older WebDriver-based approach. Slower, more brittle than modern tools. Browserbase uses Chromium via CDP for better performance and stealth.

BrowserStack / Sauce Labs: Focus on cross-browser testing with manual and automated scripts. Browserbase focuses on AI agent use cases with NLP-driven automation.

Custom scraping scripts: One-off Python scripts with BeautifulSoup or Scrapy. Work for static sites but break on JavaScript-heavy apps and bot detection. Browserbase handles modern web complexity.

Choose based on your control-vs-convenience tradeoff: full control requires more code and ops; Browserbase skills trade some control for speed and agent-friendliness.

Related on ExplainX

• What is MCP? Model Context Protocol guide
• What are agent skills?
• skills-lock.json: reproducible agent skills
• context-mode: MCP sandboxing

Sources

• Repository: github.com/browserbase/skills
• Stagehand: github.com/browserbase/stagehand
• Claude Code skills (Anthropic help): linked from Browserbase README

Skill names, CLIs, and SaaS pricing change. Treat this as May 6, 2026 README context.