Browserbase
Browserbase is a serverless platform that enables developers to run, manage, and monitor headless browsers at scale, offering seamless integration with tools like Playwright, Puppeteer, and Selenium.
Verdict
Common use cases
- Scrape competitor pricing pages weekly
- Test checkout flows across browsers
- Capture screenshots for design reviews
- Debug session logs after failed automation
- Download artifacts from completed sessions
Integration
- Vendor
- Browserbase
- Category
- developer-tools
- Auth
- API_KEY
- Tools
- 10
- Composio slug
browserbase_tool
Tools
- Create a new browser context
Tool to create a new browser context. use when you need to obtain upload credentials for a custom user-data-directory in a project.
- Create Browser Session
Tool to create a new browser session. use when you need an isolated browser context before performing any page interactions.
- Download Session Artifacts
Tool to download files from a specific session. use after session completion to retrieve all generated artifacts in a zip archive.
- List Browser Sessions
Tool to list all browser sessions. use when you need to retrieve sessions with optional filtering by status or metadata query.
- Retrieve a browser context
Tool to retrieve details of a specific browser context. use when you have a context id and need its metadata.
- Retrieve a browser session
Tool to retrieve details of a specific browser session. use when you have a session id and need its metadata (status, urls, timestamps).
- Retrieve Session Debug URLs
Tool to retrieve live debug urls for a specific session. use when you need to connect to a running session for debugging.
- Retrieve Session Logs
Tool to retrieve logs of a specific session. use after actions in a session to inspect network events and data exchange.
- Update Browser Context
Tool to update a specific browser context. use when you need fresh upload url and encryption details for an existing context, after obtaining a valid context id.
- Update Browser Session
Tool to update the status of a specific browser session. use when you need to request session completion before timeout to avoid additional charges.
Setup
Setup guide
- 11. In Switchy, open your workspace settings and navigate to the Integrations tab. 2. Find Browserbase in the MCP directory and click Connect. 3. You'll be prompted to paste an API key — generate one from your Browserbase dashboard under API Settings. 4. Paste the key into Switchy and click Authorize. 5. Switchy confirms the connection and lists the available tools. 6. Open any Space and type '@Browserbase create a new browser session' to test — the MCP should return a session ID and debug URL. 7. If you see session metadata, the integration is live and ready for automation tasks.
What teammates see: by default, memories from Browserbase are scoped to the Space (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.
Works well with
Top models
Compatibility data appears once enough Spaces have used this MCP together with a given model.
How Switchy teams use it
Starter prompts
Launch Test Session
@Browserbase create a new browser session and give me the debug URL so I can monitor it in real time.Open in a Space →
List Recent Sessions
@Browserbase list all browser sessions from the past day and show me their statuses and any error messages.Open in a Space →
Retrieve Session Logs
@Browserbase retrieve the session logs for session ID [paste ID here] and summarize any failed requests or timeouts.Open in a Space →
Download Artifacts
@Browserbase download all artifacts from session ID [paste ID here] and confirm when the zip is ready.Open in a Space →
Check Context Details
@Browserbase retrieve the details for browser context ID [paste ID here] and show me the metadata and upload credentials.Open in a Space →
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
@Browserbase list all browser sessions from the last 24 hours that are still running
Found 3 active browser sessions in your Browserbase project: 1. Session abc123 (started 2h ago) — navigated to example.com/dashboard, status: RUNNING 2. Session def456 (started 45m ago) — navigated to api.example.com/docs, status: RUNNING 3. Session ghi789 (started 12m ago) — navigated to staging.example.com, status: RUNNING All sessions are currently active. You can retrieve debug URLs or logs for any session using its ID.
This example shows the MCP's ability to query session metadata with filters. Requires a valid Browserbase API key. Sessions are isolated browser contexts — useful for parallel testing or scraping workflows. Note that session lists may be large in active projects; consider filtering by status or time range.
@Browserbase create a new browser session and navigate to github.com/trending to capture a screenshot
Created new browser session jkl012 in your Browserbase project. Session is now running and navigated to github.com/trending. Session details: - ID: jkl012 - Status: RUNNING - Created: 2 seconds ago - Initial URL: https://github.com/trending You can retrieve debug URLs to connect live, or download session artifacts (including screenshots) after the session completes. Session will auto-terminate after the configured timeout.
This example demonstrates session creation and the side-effect of spinning up a real browser context in Browserbase's infrastructure. The session persists until explicitly closed or timed out. Useful for headless automation, but be aware of your project's session concurrency limits and per-session costs.
@Browserbase download all artifacts from session jkl012 and summarize what files were generated during the crawl
Downloaded session artifacts from jkl012 (zip archive, 2.4 MB). Contents: - screenshot_final.png (1920x1080, captured at session end) - network_logs.json (142 requests, including API calls to github.com) - console_output.txt (3 warnings, no errors) - page_html.html (final DOM snapshot) The session captured a full-page screenshot of GitHub's trending page, logged all network traffic, and preserved the final HTML state. No JavaScript errors were recorded. This artifact set is typical for a single-page navigation with screenshots enabled.
This example pairs Browserbase's artifact retrieval with AI reasoning to interpret session outputs. Artifacts are only available after session completion. Useful for post-hoc analysis of scraping runs or test sessions. Requires sufficient storage quota in your Browserbase project; large sessions (video recordings, many screenshots) can exceed free-tier limits.
Use-case deep-dives
When Browserbase wins for distributed QA workflows
A 6-person eng team runs Playwright tests overnight but wakes up to flaky failures with no local repro. Browserbase is the right call here because the session logs and debug URLs let anyone on the team attach to the exact browser state that failed—no Docker setup, no "works on my machine" loops. The retrieve-session-logs tool pulls network events and console output; the debug-URL tool gives live access if the session is still warm. This works until your test suite hits 200+ parallel sessions daily, at which point the API-key-only auth becomes a bottleneck for audit trails. If your team runs fewer than 50 test sessions a day and needs fast failure triage, Browserbase collapses the debug cycle from hours to minutes.
Why Browserbase fits bug-report validation workflows
A 3-person support team gets vague bug reports ("the checkout button doesn't work") and needs to reproduce them in the customer's exact browser config before escalating to eng. Browserbase handles this cleanly: create a session with the customer's user-agent and viewport, run the repro steps, then download the session artifacts (screenshots, HAR files) as a zip. The list-sessions tool lets the team filter by metadata to find past repros for similar issues. This breaks down if your support volume exceeds 30 reproductions per week—at that scale, the 10-tool surface area feels thin and you'll want deeper integration with your ticketing system. For low-to-mid-volume support teams that need on-demand browser isolation without maintaining a Selenium grid, Browserbase is a clean win.
When Browserbase is overkill for scheduled data collection
A solo growth analyst needs to scrape 12 competitor pricing pages every Monday morning for a board deck. Browserbase can do this—spin up a session, navigate the pages, download artifacts—but it's the wrong tool. The session-based model adds latency (you're paying for a full browser context when a headless Puppeteer script would finish in 30 seconds), and the API-key auth means the analyst has to hardcode credentials or ask eng for help. If the scrape needs to bypass bot detection or rotate proxies, Browserbase starts to make sense, but for straightforward weekly scrapes with stable selectors, a cron job and a $5 VPS beats this. Browserbase wins when the scrape is ad-hoc, collaborative, or needs session replay for debugging—not for set-it-and-forget-it scheduled jobs.
Frequently asked
What does the Browserbase MCP do in Switchy?
It lets AI agents spin up remote browser sessions on Browserbase's infrastructure, then scrape pages, download artifacts, or debug live sessions. Your team can automate web tasks that need real browsers — like testing JS-heavy sites or capturing screenshots — without managing headless Chrome locally. The MCP wraps Browserbase's session API so agents call tools like Create Browser Session or Retrieve Session Logs instead of writing curl commands.
Do I need a Browserbase account to use this MCP?
Yes. You authenticate with a Browserbase API key, which means someone on your team must have a Browserbase account and generate a key from their dashboard. Switchy stores the key encrypted, but every session the MCP creates counts against your Browserbase plan limits. If you're on Browserbase's free tier, expect to hit session caps quickly with multiple agents running.
Can the MCP interact with pages inside the browser session?
No. The MCP creates and manages sessions, retrieves logs, and downloads artifacts after the fact — but it doesn't click buttons or fill forms. For page interaction you'd pair this with a separate automation tool or use Browserbase's Playwright/Puppeteer SDKs directly. Think of this MCP as the session orchestrator, not the browser driver.
Why use this instead of calling Browserbase's API directly?
If you're already writing code, the API is faster. The MCP makes sense when you want AI agents to decide when to launch a browser session mid-conversation — like an agent that scrapes a competitor's pricing page only if the user asks. It trades control for convenience: agents get natural-language access to session lifecycle without you hardcoding every endpoint.
Who on the team should connect the Browserbase MCP?
Whoever owns your Browserbase account and understands session costs. Each browser session burns minutes on your plan, so the person connecting it should know which agents need browser access and set usage guardrails. If your team runs dozens of agents, you'll want someone monitoring Browserbase usage to avoid surprise bills.