Una extensión de Chrome y un CLI que permiten a tus agentes controlar tu navegador real — con sesiones, extensiones y cookies ya disponibles. Sin instancia headless, sin detección de bots, sin memoria extra. Star en GitHub.

Otros MCP de navegador lanzan un Chrome nuevo — sin sesiones, sin extensiones, detección de bots instantánea, doble consumo de memoria. RunBrowser se conecta a tu navegador en ejecución. Una extensión de Chrome, acceso CDP completo, todos tus sitios con sesión iniciada.

Inicio rápido

Tres pasos y tu agente comienza a navegar.

Instala el CLI:

1npm i -g @jiweiyuan/runbrowser

Carga la extensión en Chrome: abre chrome://extensions/, activa el modo desarrollador, haz clic en Cargar extensión sin empaquetar, selecciona la carpeta packages/extension/dist
Haz clic en el ícono de la extensión en una pestaña — se pone verde. Empieza a usarlo:

123runbrowser navigate https://example.com
runbrowser snapshot
runbrowser click @e5

No necesitas gestionar sesiones — se crean automáticamente con el primer comando. La extensión conecta tu navegador a un relay WebSocket local en localhost:19988. El CLI envía comandos CDP a través del relay. Sin servidores remotos, sin cuentas.

Luego instala el skill — enseña a tu agente cómo usar RunBrowser:

1npx -y skills add runbrowser/runbrowser

Ícono verde = conectado. Gris = no conectado a esta pestaña.

Cómo funciona

Haz clic en el ícono de la extensión en una pestaña — se conecta vía chrome.debugger y abre un WebSocket al relay local. Tu agente (CLI o MCP) se conecta al mismo relay. Los comandos CDP fluyen directamente a través de la extensión a Chrome — sin Playwright, sin intermediarios.

┌─────────────────────┐     ┌──────────────────────┐     ┌─────────────────┐
│   BROWSER           │     │   LOCALHOST          │     │   CLIENT        │
│                     │     │                      │     │                 │
│  ┌───────────────┐  │     │ WebSocket Server     │     │  ┌───────────┐  │
│  │   Extension   │<───────┬───>  :19988          │     │  │ CLI / MCP │  │
│  └───────┬───────┘  │ WS  │                      │     │  └───────────┘  │
│          │          │     │  /extension          │     │        │        │
│    chrome.debugger  │     │       │              │     │        v        │
│          v          │     │       v              │     │  ┌────────────┐ │
│  ┌───────────────┐  │     │  CDPExecutor         │     │  │  HTTP API  │ │
│  │ Tab 1 (green) │  │     │  (direct CDP)        │     │  │  /api/*    │ │
│  │ Tab 2 (green) │  │     └──────────────────────┘     │  └────────────┘ │
│  │ Tab 3 (gray)  │  │                                  │                 │
└─────────────────────┘     Tab 3 not controlled         └─────────────────┘

El relay multiplexa sesiones, así que múltiples agentes o instancias CLI pueden trabajar con el mismo navegador simultáneamente. Todos los comandos se ejecutan directamente vía CDP — sin dependencia de Playwright.

Colaboración

El agente trabaja en tu navegador, así que puedes colaborar. Ves todo en tiempo real — cada clic muestra un resaltado verde en el elemento objetivo, cada comando produce un destello sutil en el borde. Cuando aparece un CAPTCHA, tú lo resuelves. Cuando aparece un muro de consentimiento, haces clic. Cuando el agente se atasca, desactivas la extensión en esa pestaña, corriges manualmente, la reactivas, y el agente retoma donde se quedó.

Estás compartiendo un navegador — el agente hace el trabajo repetitivo, tú intervenes cuando necesita un humano.

Snapshots de accesibilidad

Tu agente necesita ver la página antes de actuar. Los snapshots de accesibilidad devuelven cada elemento interactivo como texto, con etiquetas @ref. 5–20KB en vez de 100KB+ de una captura de pantalla — más barato, más rápido, analizable sin visión.

1234567891011runbrowser snapshot

# Salida:
# - banner:
#     - link "Home" @e1
#     - navigation:
#         - link "Docs" @e2
#         - link "Blog" @e3
# - main:
#     - heading "Welcome" @e4
#     - button "Get started" @e5

Cada @ref es directamente utilizable en comandos. Usa snapshots como el método principal para leer páginas.

12345678910# Interactuar con refs del snapshot
runbrowser click @e5
runbrowser fill @e3 "término de búsqueda"
runbrowser get text @e4

# Filtrar solo elementos interactivos
runbrowser snapshot -i

# Limitar a un selector CSS
runbrowser snapshot -S "main"

Comandos CLI

RunBrowser proporciona 50+ comandos organizados por categoría. Cada comando soporta salida --json y creación automática de sesión.

123456789101112131415161718192021222324252627282930313233343536373839404142434445# Navegación
runbrowser navigate https://example.com
runbrowser back
runbrowser forward
runbrowser reload
runbrowser close

# Observación
runbrowser snapshot                        # árbol de accesibilidad con @refs
runbrowser snapshot -i                     # solo elementos interactivos
runbrowser screenshot shot.png             # captura de pantalla
runbrowser get url                         # URL actual
runbrowser get title                       # título de la página
runbrowser get text @e5                    # texto del elemento
runbrowser is visible @e5                  # verificar estado

# Interacción
runbrowser click @e5                       # clic
runbrowser fill @e3 "hello world"          # limpiar + rellenar
runbrowser type "búsqueda"                 # escribir en el foco actual
runbrowser press Enter                     # presionar tecla
runbrowser select @e5 "option-value"       # seleccionar opción
runbrowser check @e5                       # marcar casilla
runbrowser scroll down                     # desplazar
runbrowser hover @e5                       # sobrevolar
runbrowser viewport 1280 720              # tamaño del viewport

# Espera
runbrowser wait @e5                        # esperar elemento visible
runbrowser wait 2000                       # esperar milisegundos
runbrowser wait --text "Bienvenido"        # esperar texto

# Localizadores semánticos
runbrowser find role button click --name "Enviar"
runbrowser find text "Iniciar sesión" click

# Gestión de pestañas y marcos
runbrowser tab list
runbrowser tab new https://example.com
runbrowser frame "iframe#embed"
runbrowser frame main

# Ejecución
runbrowser eval 'document.title'           # ejecutar JS en el navegador
runbrowser cdp Page.captureScreenshot '{}' # comando CDP directo

Comandos planos para el camino principal. Subgrupos para gestión. eval para todo lo demás.

Comandos de sitio

Convierte cualquier sitio web en un comando CLI. Los comandos de sitio son plugins TypeScript que encapsulan navegación, scraping y extracción de datos. Un solo comando para obtener JSON estructurado.

12345678910# Repos tendencia de GitHub como datos estructurados
runbrowser github trending --limit 5

# RANK  NAME                 STARS   LANGUAGE
# ---   ----                 -----   --------
# 1     denoland/deno        5.2k    Rust
# 2     tauri-apps/tauri     3.8k    Rust

# Salida JSON para agentes
runbrowser github trending --limit 3 --json

Crea tus propios comandos colocando un archivo .ts en ~/.runbrowser/commands/. TypeScript completo, soporte IDE completo.

1234567891011121314151617181920// ~/.runbrowser/commands/github/trending.ts

export const description = 'GitHub trending repositories'
export const columns = ['rank', 'name', 'stars', 'language']

export const args = {
  limit: { type: 'number', default: 20, description: 'Number of items' },
}

export async function run(ctx, args) {
  await ctx.navigate('https://github.com/trending')
  const data = await ctx.evaluate(`
    [...document.querySelectorAll('article.Box-row')].map(el => ({
      name: el.querySelector('h2 a')?.textContent?.trim(),
      stars: el.querySelector('.octicon-star')?.parentElement?.textContent?.trim(),
      language: el.querySelector('[itemprop="programmingLanguage"]')?.textContent?.trim(),
    }))
  `)
  return data.slice(0, args.limit).map((item, i) => ({ rank: i + 1, ...item }))
}

Plugins TypeScript. Datos estructurados. Un comando en vez de navegar → snapshot → parsear.

Extensiones de comandos

Instala comandos mantenidos por la comunidad del repositorio runbrowser/commands. Sin clonar, sin pasos de construcción — instala y usa.

123456789101112131415161718192021222324# Listar extensiones de comandos disponibles
runbrowser commands list

# Available command extensions:
#
#   reddit
#   youtube
#   x ✓ installed
#   hackernews
#   producthunt

# Instalar una extensión
runbrowser commands install reddit
# ✓ Installed reddit/
#   → ~/.runbrowser/commands/reddit/hot.ts
#   → ~/.runbrowser/commands/reddit/search.ts

# Usar inmediatamente
runbrowser reddit hot --limit 5
runbrowser reddit search "automatización de navegador"

# Desinstalar
runbrowser commands uninstall reddit
# ✓ Uninstalled reddit/

Los comandos comunitarios se descargan como archivos TypeScript en ~/.runbrowser/commands/<site>/. Siguen el mismo formato que los comandos de sitio personalizados — puedes leerlos, modificarlos o bifurcarlos.

Cómo funciona: El CLI descarga archivos .ts del repositorio GitHub runbrowser/commands y los guarda localmente. El servidor relay los carga vía jiti en tiempo de ejecución — sin compilación necesaria. Cada extensión es un directorio con uno o más archivos de comandos.

Contribuye tus propios comandos: Crea un directorio en el repositorio runbrowser/commands con tus archivos .ts y envía un PR. Tus comandos estarán disponibles para todos vía runbrowser commands install.

Patrón de subcomandos consistente. Mantenido por la comunidad. Mismo formato TypeScript que los comandos personalizados.

Sesiones

Las sesiones se crean automáticamente — solo ejecuta un comando y funciona. Para uso avanzado, gestiona sesiones explícitamente.

123runbrowser session new              # crear sesión, muestra el id
runbrowser session list             # mostrar sesiones y claves de estado
runbrowser session delete 1         # eliminar sesión

Ejecuta múltiples agentes simultáneamente sin interferencia. Cada sesión es un sandbox aislado. Las pestañas son compartidas, el estado de sesión no.

1234567# Targeting explícito de sesión
runbrowser navigate https://a.com -s 1
runbrowser navigate https://b.com -s 2

# O establecer sesión predeterminada
export RUNBROWSER_SESSION=1
runbrowser snapshot

Grabación de pantalla

El agente graba lo que hace como video MP4. La grabación usa chrome.tabCapture en el contexto de la extensión, así que sobrevive a la navegación.

123456789# Iniciar grabación
runbrowser record start -o recording.mp4

# Navegar, interactuar — la grabación continúa entre páginas
runbrowser navigate https://example.com
runbrowser click @e5

# Detener y guardar
runbrowser record stop

Captura nativa de pestaña. Persiste a través de la navegación. Transcodificación automática H.264 MP4.

Integración MCP

RunBrowser usa un modelo MCP de 2 herramientas — skill y run. Sin proliferación de herramientas, sin esquemas inflados.

12345678{
  "mcpServers": {
    "runbrowser": {
      "command": "npx",
      "args": ["-y", "@jiweiyuan/runbrowser-mcp@latest"]
    }
  }
}

El agente llama skill para descubrir comandos, luego run para ejecutar:

skill()  → devuelve documentación CLI completa + comandos de sitio
run({ command: "navigate https://example.com" })
run({ command: "snapshot" })
run({ command: "click @e1" })
run({ command: "eval document.title" })

La herramienta run sigue la misma sintaxis que el CLI. El agente no necesita aprender una API separada.

┌──────────────────────────────────────────────────────────────────────┐
│                        Cliente MCP                                  │
│                  (Claude, Cursor, Windsurf...)                      │
└──────────────┬──────────────────────────────┬────────────────────────┘
             │                              │
        skill()                        run(command)
             │                              │
             v                              v
┌──────────────────────────────────────────────────────────────────────┐
│                     Servidor MCP RunBrowser                         │
│                                                                     │
│   ┌─────────────────┐              ┌──────────────────────────┐     │
│   │  herramienta     │              │  herramienta             │     │
│   │  skill           │              │  run                     │     │
│   │                 │              │                          │     │
│   │  Devuelve docs  │              │  Parsea comando          │     │
│   │  CLI + lista de │              │  Envía al relay          │     │
│   │  comandos       │              │  Devuelve resultado      │     │
│   └─────────────────┘              └────────────┬─────────────┘     │
│                                                 │                   │
└─────────────────────────────────────────────────┼───────────────────┘
                                                │
                                          HTTP / WS
                                                │
                                                v
                                  ┌─────────────────────────┐
                                  │   Relay :19988          │
                                  │   CDPExecutor           │
                                  └────────────┬────────────┘
                                               │
                                          chrome.debugger
                                               │
                                               v
                                  ┌─────────────────────────┐
                                  │   Tu navegador Chrome   │
                                  └─────────────────────────┘

Comparación

Por qué elegir RunBrowser.

vs Playwright MCP

	Playwright MCP	RunBrowser
Navegador	Lanza nuevo Chrome	Usa tu Chrome
Extensiones	Ninguna	Tus extensiones existentes
Estado de sesión	Nuevo	Ya conectado
Detección bot	Siempre detectado	Puede evadir
Colaboración	Ventana separada	Mismo navegador

vs BrowserUse

	BrowserUse	RunBrowser
Lenguaje	Python	TypeScript / Node.js
Navegador	Lanza nuevo Chrome (Playwright)	Usa tu Chrome
Enfoque	Framework de agente IA (LLM decide)	CLI + herramientas MCP (agente envía comandos)
Estado de sesión	Nuevo	Ya conectado
CLI	No	Sí — 50+ comandos

vs Agent Browser

	Agent Browser	RunBrowser
Navegador	Lanza Chromium headless	Tu Chrome en ejecución
Comandos	~90 (inflado)	~50 (enfocados)
Extensiones de comandos	No	Sí — instalar comandos comunitarios
CLI	Rust CLI → Node daemon	Node CLI → relay (simple)
Detección bot	Siempre detectado	Puede evadir
Pestañas reales	No	Sí

Acceso remoto

Controla Chrome en una máquina remota — Mac mini headless, VM en la nube, devcontainer. Inicia el servidor relay con bind público y token.

1234567# En la máquina host — iniciar servidor relay
runbrowser serve --host 0.0.0.0 --token <secret>

# Desde cualquier lugar — establecer variables de entorno
export RUNBROWSER_HOST=192.168.1.10
export RUNBROWSER_TOKEN=<secret>
runbrowser navigate https://example.com

También funciona para devcontainers y Docker — usa RUNBROWSER_HOST=host.docker.internal.

Seguridad

Todo funciona en tu máquina. El relay se vincula a localhost:19988 y solo acepta conexiones de la extensión. Sin servidor remoto, sin cuenta, sin telemetría.

Solo local — El servidor WebSocket se vincula a localhost. Nada sale de tu máquina.
Validación de origen — solo se acepta el origen de la extensión RunBrowser. Los sitios maliciosos no pueden conectarse.
Consentimiento explícito — solo las pestañas donde hiciste clic en el ícono son controladas.
Automatización visible — Chrome muestra un banner en las pestañas controladas. Cada acción del agente tiene retroalimentación visual (resaltado verde).