canonical: https://jentic.com/apis/browserbase.com/browserbase

# Browserbase API

The Browserbase API runs headless browser sessions in the cloud for automation and scraping. It creates and controls sessions, manages reusable contexts and browser extensions, and exposes session logs, recordings, downloads, and live debug URLs. Requests authenticate with an API key sent in the X-BB-API-Key header.

## For AI agents

Create and control cloud headless browser sessions, manage contexts and extensions, and retrieve session logs, recordings, and downloads.

## Scope

Does not handle proxy management, CAPTCHA solving, or data storage - use for running and inspecting cloud headless browser sessions only.

## Capabilities

- Create and control cloud headless browser sessions
- Manage reusable browser contexts for persistent state
- Upload and manage browser extensions for sessions
- Retrieve session logs, recordings, and downloads
- Get live debug URLs and project usage details

## Use cases

### Cloud browser automation

A scraping or automation workflow needs a real browser it does not have to host. The Browserbase API creates a session in the cloud, returns control and debug URLs, and cleans up when done, so a backend runs browser tasks without managing infrastructure.

Example prompt: Create a session via POST `/v1/sessions` and return its live debug URL for the automation client

### Persistent context reuse

Automations that log in once and reuse the state need persistent contexts. The context operations create and update reusable contexts so a session can start already authenticated instead of repeating a login.

Example prompt: Create a context via POST `/v1/contexts` and attach it when creating a new session

### Session observability

Debugging an automation requires visibility into what the browser did. The session operations expose logs, recordings, and downloads so a developer can inspect a run after it completes.

Example prompt: Retrieve logs via GET `/v1/sessions/{id}/logs` and the recording via GET `/v1/sessions/{id}/recording`

### AI agent web automation

An AI agent that browses the web can run real sessions without hand-wiring the Browserbase key. Through Jentic the agent discovers the session operations by intent and calls them with the stored credential.

Example prompt: Search Jentic for 'start a headless browser session', load the schema, and open a session for a browsing task

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/sessions` | Create a headless browser session |
| GET | `/v1/sessions` | List browser sessions |
| GET | `/v1/sessions/{id}` | Retrieve a single session |
| POST | `/v1/contexts` | Create a reusable browser context |
| GET | `/v1/sessions/{id}/logs` | Retrieve the logs for a session |
| GET | `/v1/sessions/{id}/recording` | Retrieve the recording for a session |

## Key resources

- **Sessions** — Create, list, update, and inspect headless browser sessions
- **Contexts** — Create and update reusable browser contexts for persistent state
- **Extensions** — Upload and manage browser extensions used in sessions
- **Projects** — List projects and retrieve their usage

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 44 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 99 / 100
  - Developer Experience & Jentic Compatibility: 58 / 100
  - AI-Readiness & Agent Experience: 21 / 100
  - Agent Usability: 94 / 100
  - Security: 50 / 100
  - AI Discoverability: 40 / 100
- **View full report:** https://jentic.com/apis/browserbase.com/browserbase/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Browserbase API by hand means setting the X-BB-API-Key header on every request and shaping the session, context, and extension payloads yourself. Through Jentic you install once, import the API from the API Directory, store your credential once, and your agent calls it.
- **Permission scoping:** The Browserbase API addresses sessions, contexts, and extensions by id in the URL path, so you can limit the agent to the operations it needs, such as creating a session or reading its logs. You credit the agent only with the operations you allow, so deleting an extension stays out unless you add it.
- **Credential handling:** Your the Browserbase credential is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'start a headless browser session', and Jentic returns the matching Browserbase operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Browserless API** — Hosted headless Chrome for automation and scraping
- **ScraperAPI** — Managed proxy scraping without running a browser
- **Firecrawl API** — Crawl and convert pages to structured data

## FAQ

### What authentication does the Browserbase API use?

The Browserbase API authenticates with an API key sent in the X-BB-API-Key header. Through Jentic the key is stored encrypted in your own instance and injected into each request at run time.

### Is there a the Browserbase API MCP server?

You don't need an MCP server to give your agent the Browserbase API. Jentic connects it directly from the API Directory: import it, store your credential once, and your agent calls it. That keeps another server's tool definitions out of your agent's context while still giving it the operation set from the spec.

### Can I reuse a login across Browserbase sessions?

Yes. Create a context with POST `/v1/contexts` to persist browser state such as cookies, then attach that context when you create a session so it starts already authenticated.

### Can I limit what my agent is allowed to do with the Browserbase API?

Yes. Because you run Jentic One yourself, your own rules decide which the Browserbase API operations and credentials the agent may use. You grant only the operations it needs, such as creating a session, so deleting an extension stays off limits unless you add it. The choice of what the agent may call is yours.

### How do I connect my agent to the Browserbase API through Jentic?

Search Jentic by intent such as 'start a headless browser session' to discover the operation, load its input schema, and your agent calls it with your stored credential injected at run time. To run it on your own infrastructure, install Jentic One from its GitHub repo.