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 addor the Claude Code plugin marketplace.
It ranked on GitHub Trending in May 2026; the table below mirrors the upstream README.
Restart ClaudeCode 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:
Agent receives instruction: "Compare prices for this product on three e-commerce sites"
Skill launches remote browser via Browserbase API
Agent navigates to each site using natural language commands
Skill extracts structured data from DOM
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:
bash
bb sessions create --project my-project
bb sessions get <session-id>
bb sessions list --project my-project
Extensions: Install browser extensions in remote sessions:
bash
bb extensions install <extension-id>
Dashboard integration: Open Browserbase web console for manual inspection:
bash
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
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:
Agent attempts to automate checkout flow
Automation fails at payment step
Skill automatically captured trace
Developer reviews trace, sees CORS error blocking API call
Fix underlying issue, agent retries successfully
site-debugger: AI-assisted troubleshooting
The site-debugger skill uses AI to diagnose automation failures:
How it works:
Automation fails with error message
Skill captures page state (DOM, network, console)
Skill sends state to LLM with debugging prompt
LLM suggests likely causes and remediation steps
Example output:
snippet
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
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:
Log into target site in your local Chrome
Run cookie-sync skill to export cookies
Skill uploads cookies to Browserbase persistent context
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:
Faster and cheaper than launching a browser for API access or static content.
search skill: Web search without browser overhead:
bash
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:
Diff-based: Agent compares current UI to previous snapshot, identifies changes, tests affected areas
Exploration: Agent crawls site looking for broken links, console errors, accessibility issues
Regression: Agent runs through user flows (signup, checkout, etc.) to catch breakage
Example output:
snippet
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.ai 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:
snippet
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:
snippet
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:
snippet
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.
