Potencia tu agente
El comando propio del publicador. No es un endpoint de PlugMCP.
Host a copy with our keys and logs.
npx -y [email protected]Claude Code no tiene enlace de instalación para un comando local. Copia el comando de abajo y ejecútalo en una terminal.
claude mcp add browser-ipc-cdp -- npx -y browser-ipc-cdp@3.15.1Ejecútalo en una terminal.
{ "mcpServers": { "browser-ipc-cdp": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
¿URL remota o un comando en tu máquina? En qué se diferencian las dos instalaciones
Ejecutar en PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirControl remoto de navegadores Chromium (Brave, Chrome, Edge) via IPC con CDP dinamico. Abre tu navegador real con todas tus sesiones, detecta o asigna puerto automaticamente, configura portproxy/firewall para WSL, y actualiza el MCP de Claude Code. Sin puertos fijos, sin hacks de registry, sin configuracion manual.
npm i browser-ipc-cdp
npx browser-ipc-cdp
Despues /mcp en Claude Code y listo. El wrapper resuelve el puerto dinamico solo, no hay que reescribir .mcp.json cuando cambia.
Si alguna vez, usando el MCP, una pestaña se quedaba a medio cargar (sin error en consola, sin nada en el log) y parecia que Brave habia perdido internet: eso era un bug, y esta arreglado. Actualiza con:
npx -y browser-ipc-cdp@latest # y reconecta con /mcp
Eran dos causas, las dos en la intercepcion de requests (setup_request_interception, mock_api, block_resources, capture_payloads, add_auth_header, redirect_to_local, throttle_api):
Requests pausadas que nadie reanudaba. Al activar la intercepcion, el navegador puede mandar la confirmacion y la primera rafaga de requests pausadas juntas; el manejador todavia no estaba escuchando y esas requests se quedaban esperando para siempre. Era intermitente porque dependia del timing de la red local. → El manejador ahora se registra antes de activar la intercepcion.
Cerrar el MCP dejaba la intercepcion puesta. Si el MCP moria (cerrar Claude Code, reiniciar la sesion) con la intercepcion activa, nunca se desactivaba en el navegador. → Ahora hay una limpieza que corre al salir por cualquier via y revierte todo lo que los tools hayan dejado puesto: intercepcion, stealth, monitores y el overlay.
Si te vuelve a pasar con una version anterior, el remedio manual es llamar clear_request_interception o cerrar la pestaña.
Detalle tecnico completo: docs/ARQUITECTURA-MVC.md seccion 13.
browser-ipc-cdp se puede usar de tres formas. Elige la que prefieras.
npm i browser-ipc-cdp
npx browser-ipc-cdp
Luego /mcp en Claude Code para conectar el server brave. El instalador detecta/abre el navegador y configura el .mcp.json solo.
Instalable directo desde este repo:
/plugin marketplace add alexis14kl/browser-ipc-cdp
/plugin install browser-ipc-cdp@browser-ipc-cdp
Reinicia Claude Code (o corre /reload-plugins) para que cargue el MCP del plugin. La primera llamada baja chrome-devtools-mcp con npx una sola vez (despues queda cacheado).
Funciona tanto en el CLI de Claude Code como en la app de escritorio (Ajustes -> Plugins -> Agregar marketplace, con alexis14kl/browser-ipc-cdp o la URL de git). Nota: el hosting de plugins de claude.ai rechaza un directorio bin/ de nivel superior en la raiz del plugin (sus ejecutables entrarian al PATH sin aparecer en la superficie de aprobacion de admin), por eso el CLI vive en cli.js en la raiz y no en bin/.
.mcpb (un clic)browser-ipc-cdp.mcpb desde Releases.Trae chrome-devtools-mcp incluido (no necesita npm ni npx) y usa el Node que trae Claude Desktop.
Nota: no corras las tres a la vez contra el mismo navegador — todas usan el proxy en el puerto
9333y colisionarian. Elige una por entorno (o cambia el puerto en la config del bundle/plugin).
cf_clearance ya validada, no parece botbrowser-ipc-cdp expone el subsistema Network del navegador. Cualquier request HTTP/HTTPS, WebSocket, XHR o fetch se puede observar, interceptar, modificar o bloquear.
Esta herramienta esta destinada a testing personal, automatizacion propia y desarrollo. El usuario es responsable de:
NO se autoriza el uso para:
Distribuida bajo licencia MIT — el autor (Alexis Malambo) no se hace responsable del mal uso por terceros (clausula AS IS, WITHOUT WARRANTY OF ANY KIND).
Cree browser-ipc-cdp como solucion de IA para mantener tus sesiones reales activas y que un asistente (Claude Code) pueda controlar tu navegador via el MCP de Brave — sin perder cookies, 2FA ni extensiones.
Es software libre (MIT) y lo mantengo en mi tiempo. Si te sirvio o te ahorro trabajo, podes invitarme un cafe:
Cualquier aporte ayuda a seguir mejorando el proyecto. Gracias! 🙌
Sistema para controlar tu Brave Browser real (con todos tus datos, bookmarks, passwords, extensiones y sesiones) desde Claude Code via IPC (Inter-Process Communication) + CDP (Chrome DevTools Protocol) con puerto dinamico.
Sin puerto fijo, sin sesion separada, sin perder tus datos. Tu Brave de uso diario controlado por IA.
browser-ipc-cdp lanza Brave (JS puro, sin dependencias externas)
|
v
--remote-debugging-port=0 (OS asigna puerto aleatorio)
|
v
Brave escribe DevToolsActivePort (archivo IPC)
|
v
CdpService lee el puerto → guarda en cdp_info.json
|
v
MCP "brave" (brave_mcp_launcher.js) lo resuelve on-demand
|
v
Claude Code usa mcp__brave__* para controlar el navegador
El launcher ya no pasa el puerto del navegador directo a chrome-devtools-mcp.
Levanta un proxy local en puerto fijo (default 9333) y chrome-devtools-mcp
apunta siempre ahi:
chrome-devtools-mcp ──> http://127.0.0.1:9333 (proxy, puerto FIJO)
|
v re-resuelve el puerto real EN CADA conexion
Brave/Chrome en :54xxx (cambia en cada reinicio)
Esto elimina el problema clasico: el puerto se resolvia UNA vez al arrancar el
MCP, y si el navegador arrancaba despues (o se reiniciaba con port=0, que da
puerto nuevo cada vez) el MCP quedaba apuntando a un puerto muerto hasta
reiniciarlo. Con el proxy, la siguiente llamada re-resuelve sola: no hay que
reiniciar el MCP nunca por cambio de puerto, y el cliente (la IA) solo conoce
UN puerto que no cambia.
BROWSER_CDP_PROXY_PORT cambia el puerto fijo (default 9333; si esta ocupado prueba los siguientes).BROWSER_CDP_NO_PROXY=1 desactiva el proxy (comportamiento legacy).BROWSER_CDP_EXTRA_PROFILES User Data dirs extra donde buscar DevToolsActivePort (separados por ; : ,).BROWSER_CDP_CURSOR=0 apaga el overlay del cursor (encendido por defecto desde v3.0.1).browser-ipc-cdp-mcp --resolve-only (imprime el puerto resuelto) y --proxy-only (solo el proxy, sin MCP).Mejoras v2.3.1:
--remote-debugging-port, antes el cliente MCP cortaba por
timeout (30s en Claude Code); ahora el MCP arranca al instante y el navegador
se resuelve/lanza en background, on-demand via el proxy.x-cdp-proxy: browser-ipc-cdp. Si al arrancar el puerto 9333 lo ocupa un
proxy huerfano de una sesion anterior, el nuevo lo detecta por ese header, lo
mata y toma el puerto — el puerto fijo se mantiene fijo (antes caia a 9334).Mejoras v3.0.x:
src/): platform/ (Strategy por OS: win/darwin/linux/wsl),
services/ (cdp-service, cdp-proxy, auto-launch, browser-detect, cursor-overlay),
controllers/ (cli, mcp) y views/ (logger, cdp-info). Una sola implementacion
de cada cosa; el CLI y el MCP consumen los mismos servicios.
Ver docs/ARQUITECTURA-MVC.md.BROWSER_CDP_CURSOR=0. Best-effort: si falla, el MCP sigue igual.# Tu Brave real (bookmarks, passwords, extensiones, todo) + configura el MCP
npx browser-ipc-cdp
# Forzar un navegador concreto
npx browser-ipc-cdp --browser brave # o chrome / edge
# Perfil limpio separado (para testing, no toca tus datos)
npx browser-ipc-cdp --clean
# Puerto fijo en vez de dinamico
npx browser-ipc-cdp --port 9222
Todo es JS puro (Node ≥ 20.19), sin dependencias externas. El MCP tambien abre el navegador solo (auto-launch) si no encuentra ninguno con CDP activo.
Modos de perfil:
Despues de ejecutar, el script muestra:
Navegador: Chrome/146.0.7680.80
Puerto CDP: 58553
CDP URL: http://127.0.0.1:58553
WebSocket: ws://127.0.0.1:58553/devtools/browser/...
Tambien puedes verificar manualmente:
http://127.0.0.1:{PUERTO}/json/version → Info del navegador
http://127.0.0.1:{PUERTO}/json/list → Pestanas abiertas
El instalador (npx browser-ipc-cdp) configura el MCP "brave" automaticamente.
Tambien puedes hacerlo a mano en .mcp.json:
{
"mcpServers": {
"brave": {
"command": "npx",
"args": ["-y", "-p", "browser-ipc-cdp", "browser-ipc-cdp-mcp"]
}
}
}
El
-p browser-ipc-cdpes obligatorio si el paquete no esta instalado (global o local):browser-ipc-cdp-mcpes el nombre del bin, no del paquete.El wrapper resuelve el puerto dinamico solo (via el proxy fijo
:9333): no hay que actualizar.mcp.jsoncuando cambia el puerto del navegador. Si el navegador no esta abierto, el MCP arranca igual y lo lanza on-demand en la primera tool call.
Conecta con /mcp y tienes 67 tools listas. Sin config extra.
browser-ipc-cdpexpone el CDP completo de Chromium mas herramientas propias. Cada tool trabaja sobre tu navegador real con tus sesiones activas.
modify_response— intercepta la respuesta REAL del servidor y la modifica antes de que llegue al frontend. UsajsonPatchpara sobreescribir campos del JSON oreplaceBodypara reemplazar el body entero.
Estas tools son atajos semanticos sobre el sistema de intercepcion. Diseñadas para testers avanzados que necesitan velocidad y precision.
Tools ofensivas/defensivas que operan a nivel CDP — por debajo del sandbox JavaScript. Requieren uso responsable y autorizado. Ver seccion Uso responsable.
Requieren uso responsable y autorizado en entornos controlados.
# Ver que tabs hay abiertas
mcp__brave__list_pages
# Ir a Google con tu sesion real
mcp__brave__navigate_page { url: "https://google.com" }
# Screenshot del estado actual
mcp__brave__take_screenshot
# Scroll a un elemento
mcp__brave__scroll_to { selector: "#footer" }
mcp__brave__scroll_to { y: 1200, behavior: "smooth" }
# Mockear una API para testear sin backend
mcp__brave__mock_api {
urlPattern: "*/api/users*",
responseBody: [{ id: 1, name: "Test User" }]
}
# Modificar respuesta real del servidor (cambiar role sin tocar backend)
mcp__brave__setup_request_interception {
rules: [{
name: "elevate-role",
urlPattern: "*/api/me*",
action: "modify_response",
jsonPatch: { "role": "admin", "permissions.write": true }
}]
}
# Bloquear todo el tracking y ads
mcp__brave__block_resources { categories: ["analytics", "ads"] }
# Testear como responde tu UI a un error 500
mcp__brave__inject_error { urlPattern: "*/api/checkout*", statusCode: 500 }
# Agregar token a todas las requests sin interceptar
mcp__brave__set_extra_headers { headers: { "Authorization": "Bearer mi-token-aqui" } }
# Simular conexion 3G
mcp__brave__emulate_network { preset: "3g" }
# Limpiar cache antes de test de performance
mcp__brave__clear_browser_cache
# Medir cobertura JS de un flujo
mcp__brave__start_js_coverage
# ... hacer acciones en la pagina ...
mcp__brave__stop_js_coverage { minCoverage: 80 }
# Detectar CSS no utilizado
mcp__brave__start_css_coverage
# ... navegar la pagina ...
mcp__brave__stop_css_coverage { unusedOnly: true }
# Exportar la pagina a PDF
mcp__brave__print_to_pdf { path: "C:/output/reporte.pdf" }
# Ver el localStorage de la app
mcp__brave__get_local_storage
# Leer el arbol de accesibilidad
mcp__brave__get_accessibility_tree { depth: 3 }
Cada bloque es un flujo end-to-end que puedes pedirle a Claude directamente. El agente de IA ejecuta los tools en secuencia, correlaciona resultados y reporta.
Objetivo: verificar que login funciona y persiste sesión correctamente.
1. navigate_page → ir a /login
2. fill_form → usuario + contraseña
3. click → botón Ingresar
4. wait_for → texto "Bienvenido" o dashboard
5. take_screenshot → evidencia visual
6. get_cookies → verificar cookie de sesión presente (HttpOnly, Secure)
7. get_local_storage → verificar token guardado (si aplica)
Objetivo: verificar que la UI responde correctamente a errores del servidor.
1. navigate_page → ir a la sección a testear
2. inject_error → urlPattern "*/api/productos*", statusCode 500
3. click / fill → ejecutar la acción que dispara la petición
4. wait_for → mensaje de error en UI ("Algo salió mal", toast, etc.)
5. take_screenshot → evidencia del estado de error
6. inject_error → statusCode 404 (repetir con distintos códigos)
7. inject_error → statusCode 401 (verificar redirect a login)
8. clear_request_interception → limpiar
Objetivo: comparar comportamiento de UI con backend real vs respuesta mockeada.
# Con backend real
1. navigate_page + monitor_network → capturar requests reales
2. get_request_body → ver payload exacto que envía el frontend
3. capture_payloads → ver todos los POST bodies
# Con backend mockeado (aislar frontend)
4. mock_api { urlPattern: "*/api/*", responseBody: {...} }
5. navegar y ejecutar flujo → la UI recibe datos sintéticos
6. take_screenshot → comparar con estado real
Objetivo: medir qué código JS/CSS realmente se usa en un flujo y dónde están los cuellos de botella.
1. clear_browser_cache → test desde cero
2. start_js_coverage + start_css_coverage
3. performance_start_trace
4. navigate_page → ejecutar flujo completo (login → acción principal → logout)
5. performance_stop_trace → ver eventos, long tasks, layout thrashing
6. stop_js_coverage { minCoverage: 70 } → funciones no ejecutadas = dead code
7. stop_css_coverage { unusedOnly: true } → reglas CSS sin uso = CSS muerto
8. analyze_network_waterfall → recursos lentos, mixed content, protocolos
9. take_memory_snapshot → detectar memory leaks post-flujo
Objetivo: verificar que la UI es accesible y no rompe AT (lectores de pantalla).
1. navigate_page → ir a la página a auditar
2. get_accessibility_tree { depth: 4 } → ver jerarquía ARIA real
3. lighthouse_audit → score accesibilidad + lista de violaciones
4. evaluate_script → document.querySelectorAll('[role]') para ver roles
5. get_dom_element → verificar aria-label, aria-describedby en inputs clave
Objetivo: verificar que la app guarda y limpia el estado correctamente.
# Pre-flujo
1. get_local_storage / get_session_storage / get_cookies → baseline vacío
# Después de login
2. get_cookies → sesión establecida
3. get_local_storage → tokens/preferencias guardados
# Después de logout
4. get_cookies → cookie de sesión eliminada
5. get_local_storage → estado limpio
6. get_session_storage → limpio
# IndexedDB (apps con cache offline)
7. list_indexed_db → ver bases y object stores
8. get_indexed_db_data → verificar registros sincronizados
Objetivo: verificar comportamiento en móvil sin dispositivo físico.
1. emulate { device: "iPhone 14" } → viewport + UA + touch
2. navigate_page → cargar la app
3. take_screenshot → ver layout mobile
4. emulate_network { preset: "3g" } → simular red lenta
5. navigate_page → medir tiempo de carga real en 3G
6. analyze_network_waterfall → identificar recursos que bloquean render
7. emulate { restore: true } → volver a desktop
Objetivo: verificar hardening básico de la app antes de release.
1. navigate_page + security_audit_headers → CSP, HSTS, X-Frame-Options, CORS
2. detect_third_party_scripts → scripts de terceros no autorizados
3. analyze_third_party_risk { waitMs: 3000 } → scripts dinámicos + ofuscación
4. extract_http_only_cookies → verificar cookies marcadas HttpOnly + Secure
5. stealth_check → fingerprint de automatización visible
# Verificar que la app NO filtra datos en error responses
6. inject_error { urlPattern: "*/api/*", statusCode: 500 }
7. monitor_network → revisar que el body del error no exponga stack traces / paths internos
Objetivo: testear validaciones del backend con inputs malformados, manteniendo auth.
1. navigate_page + login → establecer sesión real
2. replay_request {
url: "https://app.com/api/search",
method: "POST",
body: '{"query":"{{INPUT}}"}',
fuzz: {
INPUT: ["normal", "", "' OR 1=1--", "<script>alert(1)</script>", "A".repeat(5000)]
}
}
3. Analizar respuestas: status 400=validado, 500=crash, 200 con datos = posible SQLi
Objetivo: testear cómo reacciona el frontend a datos manipulados sin tocar el backend.
1. network_intercept_modify { action: "start" }
2. network_intercept_modify {
action: "add_rule",
urlPattern: "*/api/user*",
stage: "response",
responseModifications: {
jsonPatch: [
{ op: "set", path: "/role", value: "superadmin" },
{ op: "set", path: "/permissions", value: ["read","write","delete","admin"] }
]
}
}
3. navigate_page → cargar el perfil del usuario
4. take_screenshot → ver si la UI muestra opciones de admin (privilege escalation test)
5. network_intercept_modify { action: "stop" }
Objetivo: ejecutar un flujo completo y capturar TODOS los errores sin intervención manual.
1. monitor_console → activar captura de logs (persiste entre navegaciones)
2. monitor_network → activar captura de requests
3. [ejecutar flujo completo: login → navegación → acción → logout]
4. monitor_console → buscar errores/warnings
5. monitor_network → buscar requests fallidas (status >= 400), requests lentas
6. get_request_body → ver body completo de cualquier request sospechosa
Objetivo: verificar si la app ejecuta scripts inyectados en respuestas (XSS stored/reflected).
1. network_intercept_modify { action: "start" }
2. network_intercept_modify {
action: "add_rule",
urlPattern: "*/dashboard*",
stage: "response",
responseModifications: {
injectScript: "window.__xssVerified = true; console.log('XSS payload ejecutado');"
}
}
3. navigate_page → /dashboard
4. evaluate_script → "window.__xssVerified" # true = CSP no bloquea scripts inyectados
5. list_console_messages → verificar log del payload
6. bypass_csp { enabled: false } # si hay CSP, desactivar para comparar
El instalador se auto-copia a una ruta fija (~/.browser-ipc-cdp/app) y
las configs MCP apuntan ahi — nunca al cache volatil de npx. Actualizar:
npx -y browser-ipc-cdp@latest
Eso reemplaza el contenido de la ruta fija con swap atomico: lo viejo se
borra por completo (incluidos archivos que la version nueva ya no trae) y
lo nuevo queda. Luego reconecta con /mcp en Claude Code para que el proceso
MCP corra la version nueva.
Ademas, tanto el CLI como el launcher MCP avisan si hay una version mas nueva
en npm (chequeo best-effort contra el registry; sin red no molesta). El
launcher loguea siempre su version a stderr ([brave-mcp] browser-ipc-cdp vX.Y.Z)
para que sea obvio que version esta corriendo la IA.
Desinstalar (borra la ruta fija y quita la entrada brave de los
.mcp.json/.claude.json conocidos):
npx -y browser-ipc-cdp --uninstall
Modo desarrollo: si ejecutas el instalador desde un checkout git del repo, no
se crea copia fija — las configs apuntan al repo (flujo npm link intacto).
Inter-Process Communication — browser-ipc-cdp se comunica con Brave sin usar la red: lanza el navegador con --remote-debugging-port=0 y lee el puerto que el propio Brave escribe en el archivo DevToolsActivePort.
Abrir Brave con --remote-debugging-port=9222
→ Puerto fijo → conflictos
→ Necesita regla de firewall
→ Necesita portproxy para WSL
Proceso padre lanza Brave con --remote-debugging-port=0
→ OS asigna puerto aleatorio (ej: 58553)
→ Brave escribe puerto en DevToolsActivePort (IPC via filesystem)
→ Proceso padre lee el archivo → sabe el puerto
→ Conexion directa, sin firewall, sin conflictos
Cuando pasas --remote-debugging-port=0, le dices al sistema operativo:
"dame cualquier puerto disponible". El OS elige uno libre (ej: 58553, 62301, etc.)
y Brave lo escribe en DevToolsActivePort para que otros procesos lo lean.
Es el mismo patron que usa:
Chrome DevTools Protocol — protocolo para controlar navegadores Chromium (Chrome, Brave, Edge, Opera, ginsbrowser) programaticamente.
Permite:
WSL no puede acceder a 127.0.0.1 de Windows directamente.
Para que Claude Code (WSL) llegue a Brave (Windows):
netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=58553 connectaddress=127.0.0.1 connectport=58553
netsh advfirewall firewall add rule name="CDP Dynamic Range" dir=in action=allow protocol=TCP localport=50000-65000
grep nameserver /etc/resolv.conf
# Resultado: 172.20.176.1 (puede cambiar entre reinicios)
{
"DEBUG_PORT": 55610,
"DEBUG_WS": "ws://127.0.0.1:55610/devtools/browser/...",
"BROWSER": "Chrome/150.0.7871.128",
"CDP_URL": "http://127.0.0.1:9333",
"BACKEND_URL": "http://127.0.0.1:55610",
"MODE": "PROXY",
"UPDATED_AT": "2026-07-18T20:41:41.714Z"
}
Otros scripts deben usar CDP_URL: con MODE: "PROXY" apunta al proxy fijo,
que sigue valido aunque el navegador se reinicie. BACKEND_URL es el puerto
real del navegador y cambia en cada arranque. Nota: tanto el CLI como cada
instancia del MCP escriben este archivo; con varias sesiones concurrentes el
contenido refleja la ultima que escribio.
Con tu Brave real conectado via IPC + CDP, Claude Code puede:
Todo sin necesidad de login adicional — usa tus sesiones activas.
1. Instalar (una sola vez):
npx browser-ipc-cdp # detecta el navegador y configura el MCP "brave"
2. En Claude Code: /mcp → brave conectado
3. Listo! Claude Code controla tu navegador real.
Si no estaba abierto, la primera tool call lo lanza sola (auto-launch
en JS puro) y el proxy :9333 re-resuelve el puerto en cada conexion.
Opcional (manual):
npx browser-ipc-cdp # abrir el navegador con CDP dinamico a mano
npx browser-ipc-cdp --clean # perfil limpio para testing
En WSL ademas hace falta el portproxy + firewall de la seccion "Conexion desde WSL" (el instalador los configura solo).
Control remoto de navegadores Chromium (Brave, Chrome, Edge) via IPC + CDP dinamico. Un comando para conectar Claude Code a tu navegador real.
{ "mcpServers": { "browser-ipc-cdp": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}Herramientas
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
Este registro no indica ninguna variable de entorno obligatoria.
Browser Ipc Cdp se ejecuta localmente por stdio.
Última comprobación: 2026-11-17. Control remoto de navegadores Chromium (Brave, Chrome, Edge) via IPC + CDP dinamico. Un comando para conectar Claude Code a tu navegador real.