# Chrome DevTools MCP vs Playwright MCP: elige según el trabajo en el navegador

> Chrome DevTools MCP vs Playwright MCP: compara las herramientas de depuración, los perfiles de navegador y el coste de contexto medido antes de conectar uno a Claude Code o Codex.

Necesitas que un agente inspeccione una página rota o repita un flujo en el navegador. Elige según si necesitas depuración en Chrome, cobertura multi-navegador o compartir el estado de la cuenta.

**Respuesta corta:** elige el servidor Chrome DevTools MCP cuando el trabajo dependa de la depuración en Chrome: trazas de rendimiento, Lighthouse, instantáneas del heap, reglas CSS o detalles de red. Elige el servidor Playwright MCP cuando necesites cobertura de Chromium, Firefox o WebKit, código Playwright reutilizable o capacidades explícitas orientadas a testing. En nuestra medición con Claude Code de dos ejecuciones del 8 de noviembre de 2026, Chrome DevTools MCP 1.12.0 expuso 32 definiciones de herramientas diferidas con un coste de 10,972 tokens; Playwright MCP 0.0.84 expuso 25 con un coste de 6,747. Eso cuenta solo las definiciones, no las instantáneas de página ni los resultados de herramientas que devuelve tu tarea.

## ¿Qué hace Chrome DevTools MCP en comparación con Playwright MCP?

Chrome DevTools MCP se centra en la interfaz de depuración de Chrome; Playwright MCP expone la API de automatización de navegador de Playwright en varios motores.

| Factor de decisión                 | Chrome DevTools MCP 1.12.0                                                                                                                                          | Playwright MCP 0.0.84                                                                                                                                          |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Control del navegador              | Chrome, controlado a través de Puppeteer según el [README del proyecto](https://github.com/ChromeDevTools/chrome-devtools-mcp)                                      | Driver de Playwright; el navegador puede ser Chromium, Firefox, WebKit o Microsoft Edge                                                                        |
| Estado de la página para el modelo | `take_snapshot` devuelve una instantánea de texto del árbol de accesibilidad con IDs únicos de elemento; hay capturas de pantalla disponibles para el estado visual | `browser_snapshot` devuelve el estado de accesibilidad estructurado con referencias de elemento; hay capturas de pantalla disponibles cuando lo visual importa |
| Herramientas de depuración         | Traza de rendimiento e insights, Lighthouse, instantáneas del heap, reglas CSS aplicadas, consola y detalles de las peticiones de red                               | Herramientas de consola y de red; grupos de capacidades opcionales añaden trazado, aserciones de testing, almacenamiento y más                                 |
| Ventaja solo en automatización     | Acceso a DevTools específico de Chrome, incluido Lighthouse y la inspección del heap                                                                                | Selección de navegador, ejecución de código Playwright, contextos persistentes o aislados y conexión con Playwright Extension                                  |

La lista de herramientas de la tabla depende de la versión. Los recuentos de abajo están fijados a las versiones medidas; las descripciones de capacidades y de flags usan la documentación del proyecto consultada el 8 de noviembre de 2026. La [referencia de herramientas](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/tool-reference.md) de Chrome DevTools MCP nombra las herramientas de traza, auditoría, heap, CSS y red; la [documentación de MCP](https://playwright.dev/docs/getting-started-mcp) de Playwright describe la selección de navegador, las instantáneas y las capacidades opcionales.

Chrome DevTools MCP también activa por defecto las estadísticas de uso de herramientas, y las trazas de rendimiento pueden enviar URLs a la API CrUX de Google. Si no quieres ninguno de los dos comportamientos, añade `--no-usage-statistics` y `--no-performance-crux` a sus argumentos de arranque, como documenta el [README del proyecto](https://github.com/ChromeDevTools/chrome-devtools-mcp).

![Diagrama que compara los caminos del agente al navegador en Chrome DevTools MCP y Playwright MCP, con el almacenamiento de perfiles y los motores de navegador que cada uno puede controlar](/blog/chrome-devtools-mcp/browser-mcp-paths.svg)

Usa la propia representación de estado del navegador como desempate práctico. Para un bug de layout, una captura de pantalla ayuda al agente a ver los píxeles; para navegar por un formulario, una instantánea de accesibilidad le da controles con nombre y referencias. Para una investigación de rendimiento solo en Chrome, inicia una traza e inspecciona sus insights en lugar de pedirle a una herramienta genérica de automatización que aproxime DevTools.

## ¿Cuánto contexto usa cada MCP de navegador?

En un par controlado de ejecuciones, las definiciones de Chrome DevTools MCP usaron 4,225 tokens más que las definiciones de Playwright MCP. Esa diferencia es útil al elegir una superficie de herramientas, pero no es una predicción de los tokens totales de la tarea.

Ejecutamos cada servidor dos veces a través de Claude Code 2.1.319 con un proyecto vacío, el modelo Claude Opus 5.5, un solo servidor configurado y la búsqueda de herramientas activada. Las dos ejecuciones de cada servidor devolvieron valores idénticos:

| Versión del servidor       | Herramientas | Tokens de definiciones diferidas | Definición más grande                 |
| -------------------------- | -----------: | -------------------------------: | ------------------------------------- |
| Chrome DevTools MCP 1.12.0 |           32 |                           10,972 | `emulate`, 943 tokens                 |
| Playwright MCP 0.0.84      |           25 |                            6,747 | `browser_take_screenshot`, 553 tokens |

Las definiciones aparecieron en la fila de MCP diferido de Claude Code, así que estaban disponibles para la búsqueda de herramientas en lugar de cargarse en el contexto inicial del modelo. Contamos los esquemas y las descripciones de las herramientas; no medimos los tokens de resultados, las capturas de pantalla, la latencia ni el éxito de la tarea. Una captura de pantalla o una instantánea larga puede dominar la diferencia de definiciones en una tarea real. Para un método repetible que separe esos costes, mira nuestra [guía de medición de tokens de MCP](/blog/code-execution-with-mcp).

## ¿Cada servidor usa mi perfil de navegador con la sesión iniciada?

Por defecto, ninguno de los dos servidores controla tu ventana de Chrome de todos los días. Cada uno inicia o reutiliza un perfil propio; la conexión a un navegador en ejecución es un modo explícito con consecuencias distintas de estado y de seguridad.

| Modo de perfil                            | Qué pasa con las cookies y el estado                                                                                                 | Cuándo encaja                                                                   |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------- |
| Perfil por defecto de Chrome DevTools MCP | Lanza Chrome con un perfil dedicado en `~/.cache/chrome-devtools-mcp/`; persiste entre ejecuciones y está separado del Chrome normal | Pruebas repetidas en una cuenta estable solo para el agente                     |
| `--isolated` de Chrome DevTools MCP       | Crea un perfil temporal y lo elimina cuando Chrome se cierra                                                                         | Reproducción limpia o ejecuciones tipo CI                                       |
| `--autoConnect` de Chrome DevTools MCP    | Se conecta a un perfil de Chrome 144+ en ejecución después de activar la depuración remota y de que aceptes el aviso de permisos     | Compartir estado entre las pruebas manuales y el agente                         |
| Perfil por defecto de Playwright MCP      | Mantiene un perfil separado por workspace entre sesiones                                                                             | Pruebas repetidas sin usar tu navegador de todos los días                       |
| `--isolated` de Playwright MCP            | Inicia cada sesión con estado limpio; usa `--storage-state` para sembrarlo                                                           | Flujos reproducibles con autenticación controlada                               |
| Modo Playwright Extension                 | Se conecta a las pestañas de un navegador donde la extensión está instalada                                                          | El agente necesita una pestaña del navegador abierta en ese momento y su sesión |

Para Chrome DevTools MCP, [la guía de uso avanzado del proyecto](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/advanced-usage.md) explica el perfil persistente por defecto, `--isolated` y la conexión mediante `--autoConnect` o `--browser-url`. La [guía de configuración de Playwright MCP](https://playwright.dev/docs/getting-started-mcp) documenta sus modos persistente, aislado y de extensión. Si tu objetivo principal es usar Claude dentro de una sesión de Chrome existente, nuestra [guía de Claude in Chrome](/blog/claude-in-chrome) cubre ese flujo de trabajo aparte.

Conectarse a un perfil real de Chrome da al agente acceso a las pestañas y al estado de las cuentas de ese perfil. La guía de Chrome exige un directorio de datos de usuario que no sea el predeterminado para un puerto de depuración remota y advierte de que cualquier aplicación local puede controlar un navegador mientras ese puerto esté abierto. Mantén las cuentas personales fuera de un perfil de depuración y desactiva la depuración remota cuando termine la sesión.

## ¿Cómo añado Chrome DevTools MCP o Playwright MCP a Claude Code o Codex?

Para Claude Code, registra un servidor stdio local con `claude mcp add`; para Codex, añade una tabla `[mcp_servers.<name>]` a `~/.codex/config.toml`. Estos cuatro fragmentos son solo de documentación: se basan en la documentación del cliente y del servidor y no se ejecutaron como parte de nuestra medición.

Las líneas de comando de abajo usan una shell POSIX en macOS o Linux. Fija la versión del paquete si quieres el mismo catálogo de herramientas que medimos. Chrome DevTools MCP requiere Node.js LTS, npm y la versión estable actual de Chrome; la guía de Playwright requiere Node.js 20 o superior y admite Chrome, Firefox, WebKit y Edge. El proyecto de Chrome documenta una configuración aparte para Windows 11 que usa `cmd /c npx` en su [guía de configuración de cliente](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/client-configurations.md).

**Chrome DevTools MCP en Claude Code:**

```sh
claude mcp add --scope user chrome-devtools -- npx -y chrome-devtools-mcp@1.12.0
```

**Playwright MCP en Claude Code:**

```sh
claude mcp add --scope user playwright -- npx -y @playwright/mcp@0.0.84
```

**Chrome DevTools MCP en Codex**, en `~/.codex/config.toml`:

```toml
[mcp_servers.chrome-devtools]
command = "npx"
args = ["-y", "chrome-devtools-mcp@1.12.0"]
```

**Playwright MCP en Codex**, en `~/.codex/config.toml`:

```toml
[mcp_servers.playwright]
command = "npx"
args = ["-y", "@playwright/mcp@0.0.84"]
```

La [referencia de MCP de Claude Code](https://code.claude.com/docs/en/mcp) documenta el patrón `claude mcp add <name> -- <command>`, y la [guía de MCP de Codex](https://developers.openai.com/codex/mcp) documenta los campos TOML. El proyecto Chrome DevTools lista las dos formas de configuración específicas de cada cliente en su [guía de configuración de cliente](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/client-configurations.md).

Después de añadir un servidor, comprueba `claude mcp list` y `/mcp` en Claude Code, o `codex mcp list` en Codex. Un servidor configurado debería aparecer en la lista; luego pídele que navegue a una URL de desarrollo local y lea el título de la página. Si eso funciona, elimínalo con `claude mcp remove <name>` o `codex mcp remove <name>` cuando hayas terminado.

## ¿Qué errores se encuentra la gente al conectar el servidor Chrome DevTools MCP?

La mayoría de los fallos de conexión son un desajuste entre el navegador y el proceso del servidor: el navegador no puede arrancar en su entorno, o el servidor MCP no puede conectarse a la sesión de Chrome prevista.

| Síntoma                                                                         | Causa probable                                                                                                                                            | Solución a probar                                                                                                                                         |
| ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Chrome failed to start` en un contenedor o en un sandbox del sistema operativo | Chrome necesita permisos de sandbox que el proceso MCP no tiene, o el proceso se ejecuta como root                                                        | Ejecuta el servidor como usuario sin privilegios; si el sandbox del cliente MCP bloquea Chrome, inicia Chrome fuera de él y conéctate con `--browser-url` |
| `ProtocolError: Network.enable timed out` con `--autoConnect`                   | Chrome está por debajo de 144, la depuración remota está desactivada, no se aceptó el aviso de consentimiento u otro servidor está usando el mismo puerto | Activa la depuración remota en `chrome://inspect/#remote-debugging`, acepta el aviso y cierra las sesiones MCP duplicadas en ese endpoint                 |
| `MCP client ... failed to start: request timed out`                             | En un reporte de Codex de 2025, el servidor no arrancó con una instalación de Node más antigua                                                            | Comprueba que `npx chrome-devtools-mcp@1.12.0 --help` funciona en la misma terminal; usa una versión actual de Node LTS con soporte y vuelve a conectarte |

Las dos primeras soluciones vienen de la [guía de troubleshooting](https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/troubleshooting.md) de Chrome DevTools MCP. Para el timeout, un [issue reportado en Codex](https://github.com/ChromeDevTools/chrome-devtools-mcp/issues/123) dice que cambiar a Node 22 arregló el fallo de arranque de quien lo reportó; es un reporte con fecha, no una garantía de que cada timeout tenga la misma causa. En un reporte posterior de `Network.enable timed out` ([issue #1763](https://github.com/ChromeDevTools/chrome-devtools-mcp/issues/1763)), el mantenedor señaló pestañas congeladas o descartadas en el Chrome conectado, así que comprueba si hay pestañas dormidas antes de culpar al puerto.

Si Chrome en sí arranca pero faltan tus páginas con la sesión iniciada, comprueba primero el modo de perfil y los argumentos del servidor de Chrome DevTools MCP: usa su perfil persistente dedicado, o conéctate deliberadamente a un navegador en ejecución. Para Playwright MCP, verifica `--browser`, `--user-data-dir`, `--isolated` o `--extension` contra el estado que esperas.

## ¿Qué MCP de navegador debería elegir para depuración o automatización?

Elige según el navegador y la evidencia que necesite tu trabajo. Mantén una suite de tests de Playwright normal para las aserciones repetibles de CI; usa un servidor MCP cuando un agente necesite explorar una página o diagnosticar un estado en vivo.

| Elección                       | Cuándo encaja                                                                                                                             | Contrapartida                                                                                                                                       |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| Chrome DevTools MCP            | Depuración solo en Chrome, trazas de rendimiento, Lighthouse, inspección de la cascada CSS o análisis del heap                            | Específico de Chrome, y sus definiciones diferidas medidas ocuparon 4,225 tokens más que las de Playwright MCP                                      |
| Playwright MCP                 | Comprobaciones multi-navegador, interacción basada en accesibilidad, código Playwright reutilizable o estado de almacenamiento controlado | Los diagnósticos específicos de Chrome DevTools no son su centro de gravedad; activa capacidades extra solo cuando el flujo de trabajo las necesite |
| Un navegador con MCP integrado | El agente necesita trabajar en tu sesión de navegador de todos los días, ya con la sesión iniciada                                        | Se estrecha la elección de navegador y de plataforma; trata la sesión como una superficie de herramientas privilegiada                              |

Nosotros construimos Octoweb, un navegador para macOS con un servidor MCP que controla su propio workspace con la sesión iniciada. La versión 0.21.0 expone 44 herramientas MCP sobre HTTP en loopback; cada workspace conserva sus propias cookies y su almacenamiento local. Es una opción cuando mantener al humano y al agente en el mismo workspace del navegador importa más que elegir Chrome, Firefox o WebKit. Mira [cómo presentamos Octoweb](/blog/introducing-octoweb-keyboard-first-ai-browser).

Para un bug en una web app de Chrome, usa Chrome DevTools MCP y mantén separado su perfil por defecto salvo que necesites compartir una sesión de pruebas. Para una ejecución en Firefox o WebKit, un fragmento de test reutilizable o un flujo de formulario con la accesibilidad por delante, usa Playwright MCP. Para una sesión compartida entre humano y agente, elige un navegador construido alrededor de ese modelo de workspace y limita lo que el agente puede alcanzar.

— Don

---

_Prueba una tarea de depuración representativa con un perfil de navegador dedicado y luego compara la evidencia y el contexto devueltos en tu propio agente. [Abre un issue en GitHub](https://github.com/Muvon) con el flujo de trabajo que quieres que cubramos a continuación._
