Skip to main content
Glama

start_browser

Launch a persistent browser session via Pure CDP Mode to enable subsequent automation steps like navigation, clicking, and text entry. Supports headless, incognito, ad-block, and proxy options.

Instructions

Launch a persistent SeleniumBase Pure CDP Mode browser session.

This must be called before browser interaction tools such as navigate, get_content, click, type_text, or find_elements. The same browser session remains active across subsequent MCP tool calls until close_browser is called or the server process exits.

Pure CDP Mode communicates directly with the browser through the Chrome DevTools Protocol rather than WebDriver. This provides SeleniumBase's CDP-based browser automation capabilities without using WebDriver as the browser-control layer.

Args: url: Optional URL to open immediately after the browser launches. If omitted, the browser starts without navigating to a requested page.

headless: Controls whether the browser runs without a visible window.
    If True, always run headless. If False, always run headed.
    If omitted (None), the default depends on the operating system:
    Linux defaults to headless because MCP/server environments
    commonly do not have a graphical desktop, while Windows and macOS
    default to headed so that a visible browser window is available.
    Use True or False to explicitly override the OS-specific default
    on any operating system.

use_chromium: Use Chromium instead of Google Chrome. This is useful
    when Google Chrome is not installed. SeleniumBase can manage the
    Chromium browser when this option is enabled.

browser_executable_path: Explicit filesystem path to the browser
    executable when it is not installed in a standard location.
    Do not combine this with use_chromium=True.

incognito: Launch Chrome/Chromium in incognito mode.

guest: Launch Chrome/Chromium in guest mode. Do not combine this with
    incognito=True.

ad_block: Enable SeleniumBase's basic ad-blocking functionality.

proxy: Optional proxy server. Examples include
    "SERVER:PORT" or "USER:PASS@SERVER:PORT".

Returns: A confirmation message when the browser starts successfully, including the effective headless setting, or a descriptive error when browser startup fails.

Lifecycle: Call start_browser once at the beginning of a browser automation workflow. Reusing the existing session preserves cookies, tabs, navigation history, localStorage/sessionStorage, and other browser state between tool calls. Call close_browser when finished.

Environment requirements: The MCP runtime must have a compatible Chrome or Chromium browser available. If the browser executable cannot be discovered, use use_chromium=True or provide browser_executable_path explicitly.

On Linux, the default is headless=True so the browser can run in
typical server/container environments without a graphical desktop.
Set headless=False when a graphical display is available and a visible
browser is desired. On Windows and macOS, the default is
headless=False. Set headless=True when running without a desktop or
when a visible browser window is not desired.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
urlNo
guestNo
proxyNo
ad_blockNo
headlessNo
incognitoNo
use_chromiumNo
browser_executable_pathNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. Changed3 schema fields changedv4.53.3
    • addedInput schema / properties / headless / anyOf
      Added value: +[
      +  {
      +    "type": "boolean"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • changedInput schema / properties / headless / default
      Previous value: -falseNew value: +null
    • removedInput schema / properties / headless / type
      Removed value: -"boolean"
  2. Changed2 schema fields changedv1.0.1
    • addedInput schema / properties / browser_executable_path
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Browser Executable Path"
      +}
    • addedInput schema / properties / use_chromium
      Added value: +{
      +  "default": false,
      +  "title": "Use Chromium",
      +  "type": "boolean"
      +}
  3. First observedv1.0.0

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full responsibility for behavioral disclosure. It clearly reveals that the session is persistent across tool calls, maintains browser state (cookies, tabs, history, storage), and runs until close_browser is called or the server exits. It explains the CDP-based communication versus WebDriver, the OS-dependent headless default, and the availability of fallbacks like use_chromium and browser_executable_path when the browser cannot be found.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is longer than the average MCP description, but the added length is purposeful: each block (Args, Returns, Lifecycle, Environment requirements) adds non-redundant integration-level detail. It could be slightly tightened by folding the OS-specific headless rules into one mention instead of repeating them in the Args and Environment sections; this repetition costs it a perfect score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an 8-parameter, zero-annotation tool with no schema-level descriptions, the description is highly complete. It specifies every parameter, returns a structured message (confirmation or error), gives lifecycle guidance, and enumerates environment prerequisites. It leaves nothing essential about how or when to call this tool, and the output schema covers the return payload.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With schema description coverage at 0%, the description fully compensates by explaining not only what each of the 8 parameters does (open a URL, control headless mode, choose Chromium, specify an executable path, incognito, guest, ad-block, and proxy) but also the mutual exclusivity constraints (browser_executable_path not with use_chromium, and guest not with incognito). Real included conventions for proxy format and default headless behavior per OS, making each parameter actionable.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description immediately states the core function with a specific verb and resource: 'Launch a persistent SeleniumBase Pure CDP Mode browser session.' It goes beyond a generic launch description by naming the browser-control layer (Pure CDP Mode) and explicitly positioning itself as the prerequisite for interaction tools like navigate, click, and type_text, which clearly differentiates it from those sibling tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides strong usage context: it must be called before browser interaction tools, should be called once at the start of a workflow, and close_browser should be called when finished. It also explains the session remains available across calls. However, it does not explicitly outline scenarios where starting a browser is not appropriate or compare itself to a non-browser alternative, leaving room for an explicit when-not-to-use statement.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/seleniumbase/SeleniumBase'

If you have feedback or need assistance with the MCP directory API, please join our Discord server