Browserbase

oficial

Automatiza interacciones del navegador en la nube (por ejemplo, navegación web, extracción de datos, llenado de formularios y más)

GitHub

3.4k

¿Qué puedes hacer con Browserbase MCP?

Iniciar una sesión de navegador en la nube — Pídele a tu asistente que cree o reutilice una sesión de Browserbase con start.
Navegar a cualquier URL — Dirige el navegador a una página web específica usando navigate.
Realizar acciones en una página — Indica al asistente que haga clic, escriba o interactúe con elementos mediante act.
Observar elementos interactivos — Solicita una lista de elementos accionables de la página que coincidan con una instrucción usando observe.
Extraer datos estructurados — Obtén información de la página actual usando extract, opcionalmente guiado por una instrucción en lenguaje natural.
Finalizar la sesión del navegador — Cierra limpiamente la sesión activa de Browserbase con end.

Documentación

Servidor MCP de Browserbase

Archivado

Este repositorio está archivado y ya no recibe mantenimiento.

Se publicó originalmente como una implementación de referencia y se conserva con fines históricos. No debe interpretarse como representativo de los servicios o la implementación de producción actuales de Browserbase.

cover

El Protocolo de Contexto de Modelo (MCP) es un protocolo abierto que permite la integración fluida entre aplicaciones LLM y fuentes de datos y herramientas externas. Ya sea que estés construyendo un IDE potenciado por IA, mejorando una interfaz de chat o creando flujos de trabajo de IA personalizados, MCP proporciona una forma estandarizada de conectar los LLM con el contexto que necesitan.

Este servidor proporciona capacidades de automatización de navegadores en la nube usando Browserbase y Stagehand. Permite a los LLM interactuar con páginas web, extraer información y realizar acciones automatizadas.

Esta es una versión autoalojable del servidor MCP alojado de Browserbase con las mismas herramientas y funcionalidad. Recomendamos usar la versión alojada para la configuración más sencilla.

Herramientas

Este servidor expone 6 herramientas que coinciden con el servidor MCP alojado de Browserbase:

Herramienta	Descripción	Entrada
`start`	Crear o reutilizar una sesión de Browserbase	(ninguna)
`end`	Cerrar la sesión actual de Browserbase	(ninguna)
`navigate`	Navegar a una URL	`{ url: string }`
`act`	Realizar una acción en la página	`{ action: string }`
`observe`	Observar elementos accionables en la página	`{ instruction: string }`
`extract`	Extraer datos de la página	`{ instruction?: string }`

Cómo configurar

Actualmente soportamos 2 transportes para nuestro servidor MCP, STDIO y SHTTP. Recomendamos usar SHTTP con nuestro servidor MCP alojado para aprovechar el servidor a plena capacidad.

SHTTP (MCP Alojado):

Usa el servidor MCP alojado de Browserbase en https://mcp.browserbase.com/mcp. Esta es la forma más fácil de empezar -- nosotros alojamos el servidor y proporcionamos los costos de LLM para Gemini, el modelo de mejor rendimiento en Stagehand.

Para instrucciones completas de configuración, consulta la documentación de MCP de Browserbase.

Si tu cliente soporta SHTTP:

{
  "mcpServers": {
    "browserbase": {
      "type": "http",
      "url": "https://mcp.browserbase.com/mcp"
    }
  }
}

Si tu cliente no soporta SHTTP:

{
  "mcpServers": {
    "browserbase": {
      "command": "npx",
      "args": ["mcp-remote", "https://mcp.browserbase.com/mcp"]
    }
  }
}

STDIO (Autoalojado):

Puedes usar nuestro servidor alojado en NPM o ejecutarlo completamente en local clonando este repositorio.

Nota: Si quieres usar un modelo diferente, tienes que añadir --modelName a los argumentos y proporcionar esa clave respectiva como argumento. Más información abajo.

Para ejecutar vía NPM (Recomendado)

Ve a tu JSON de Configuración MCP y añade el Servidor Browserbase:

{
  "mcpServers": {
    "browserbase": {
      "command": "npx",
      "args": ["@browserbasehq/mcp"],
      "env": {
        "BROWSERBASE_API_KEY": "",
        "BROWSERBASE_PROJECT_ID": "",
        "GEMINI_API_KEY": ""
      }
    }
  }
}

¡Eso es todo! Recarga tu cliente MCP y estarás listo para usar.

Para ejecutar 100% local:

Opción 1: Instalación directa

git clone https://github.com/browserbase/mcp-server-browserbase.git
cd mcp-server-browserbase
npm install && npm run build

Opción 2: Docker

git clone https://github.com/browserbase/mcp-server-browserbase.git
cd mcp-server-browserbase
docker build -t mcp-browserbase .

Luego, en tu JSON de Configuración MCP, ejecuta el servidor:

Usando Instalación Directa

{
  "mcpServers": {
    "browserbase": {
      "command": "node",
      "args": ["/path/to/mcp-server-browserbase/cli.js"],
      "env": {
        "BROWSERBASE_API_KEY": "",
        "BROWSERBASE_PROJECT_ID": "",
        "GEMINI_API_KEY": ""
      }
    }
  }
}

Usando Docker

{
  "mcpServers": {
    "browserbase": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "BROWSERBASE_API_KEY",
        "-e",
        "BROWSERBASE_PROJECT_ID",
        "-e",
        "GEMINI_API_KEY",
        "mcp-browserbase"
      ],
      "env": {
        "BROWSERBASE_API_KEY": "",
        "BROWSERBASE_PROJECT_ID": "",
        "GEMINI_API_KEY": ""
      }
    }
  }
}

Configuración

El servidor MCP de Browserbase acepta los siguientes flags de línea de comandos:

Flag	Descripción
`--proxies`	Habilitar proxies de Browserbase para la sesión
`--verified`	Habilitar Identidad Verificada de Browserbase (Solo para usuarios del Plan Scale)
`--advancedStealth`	Alias obsoleto para `--verified`
`--keepAlive`	Habilitar Sesión Keep Alive de Browserbase
`--contextId <contextId>`	Especificar un ID de Contexto de Browserbase a usar
`--persist`	Si se debe persistir el contexto de Browserbase (por defecto: true)
`--port <port>`	Puerto en el que escuchar para transporte HTTP/SHTTP
`--host <host>`	Host al que enlazar el servidor (por defecto: localhost, usar 0.0.0.0 para todas las interfaces)
`--browserWidth <width>`	Ancho del viewport del navegador (por defecto: 1024)
`--browserHeight <height>`	Alto del viewport del navegador (por defecto: 768)
`--modelName <model>`	El modelo a usar para Stagehand (por defecto: google/gemini-2.5-flash-lite)
`--modelApiKey <key>`	Clave API para el proveedor de modelo personalizado (requerido al usar modelos personalizados)
`--experimental`	Habilitar características experimentales (por defecto: false)

Estos flags pueden pasarse directamente a la CLI o configurarse en tu archivo de configuración MCP.

Nota: Estos flags solo pueden usarse con el servidor autoalojado (npx @browserbasehq/mcp o Docker).

Configuración del Modelo

Stagehand usa por defecto el modelo Gemini 2.5 Flash Lite de Google, pero puedes configurarlo para usar otros modelos como GPT-4o, Claude u otros proveedores.

Importante: Al usar cualquier modelo personalizado (no predeterminado), debes proporcionar tu propia clave API para ese proveedor de modelo usando el flag --modelApiKey.

{
  "mcpServers": {
    "browserbase": {
      "command": "npx",
      "args": [
        "@browserbasehq/mcp",
        "--modelName",
        "anthropic/claude-sonnet-4.5",
        "--modelApiKey",
        "your-anthropic-api-key"
      ],
      "env": {
        "BROWSERBASE_API_KEY": "",
        "BROWSERBASE_PROJECT_ID": ""
      }
    }
  }
}

Nota: El modelo debe ser soportado en Stagehand. Consulta la documentación aquí.

Enlaces

Licencia

Licenciado bajo la Licencia Apache 2.0.