Mit Chrome DevTools MCP bekommt dein KI-Coding-Agent einen echten Browser

Lass deinen KI-Coding-Agenten Chrome öffnen, Konsolenfehler lesen und Performance-Traces aufzeichnen. Installation, Konfigurationen und Lösungen für Chrome DevTools MCP.

Graphic of a browser window connected to a terminal prompt reading mcp, for a guide to Chrome DevTools MCP

KI-Coding-Agenten können eine Webseite schreiben, aber die meisten sehen nicht, was diese Seite tut, sobald sie im Browser läuft. Chrome DevTools MCP, ein Open-Source-Server des Chrome-DevTools-Teams, ändert das: Ein Agent wie Claude Code, Cursor, Copilot oder Gemini CLI kann damit Chrome öffnen, die Konsole lesen, Netzwerkanfragen untersuchen, Screenshots machen und Performance-Traces aufzeichnen. Diese Anleitung zeigt dir, wie du den Server installierst, einen ersten Test machst, ihn mit einem bereits geöffneten Chrome-Fenster verbindest und die häufigsten Einrichtungsprobleme löst.

Stand 14. November 2026 ist Version 1.13.0 vom 11. November die neueste Version, und das Projekt stand diese Woche auf der täglichen Trending-Liste von GitHub.

Was Chrome DevTools MCP macht

MCP (Model Context Protocol) ist ein Standard, über den KI-Assistenten externe Tools aufrufen. Das Paket chrome-devtools-mcp ist ein MCP-Server: Dein Agent schickt ihm Anfragen wie „öffne diese URL“ oder „zeig mir die Konsolenfehler“, und der Server führt sie mit Chrome DevTools und Puppeteer in einem echten Chrome-Browser aus.

Die Tools sind in Kategorien aufgeteilt. Eingabeautomatisierung (klicken, ausfüllen, tippen, Datei hochladen), Navigation, Emulation, Performance-Tracing, Netzwerkanalyse und Debugging (Konsolenmeldungen, Screenshots, Seiten-Snapshots, Lighthouse-Audits) sind standardmäßig aktiv. Zusätzliche Kategorien wie Netzwerk-Mocks, Erweiterungen und Progressive Web Apps bleiben aus, bis du sie per Flag einschaltest. Version 1.13.0 hat Logpoints und seitenbezogene Netzwerk-Mocks hinzugefügt.

Im selben Paket steckt außerdem das Kommandozeilen-Tool chrome-devtools, mit dem du den Browser auch ganz ohne Agent aus dem Terminal steuern kannst.

Was du brauchst

  • Node.js in einer LTS-Version. Stand 14. November 2026 nennt das npm-Paket Unterstützung für Node ^20.19.0 || ^22.12.0 || >=23.
  • npm (kommt mit Node).
  • Google Chrome in der aktuellen stabilen Version oder neuer. Offiziell unterstützt das Projekt nur Google Chrome und Chrome for Testing; andere Chromium-Browser können funktionieren, das ist aber nicht garantiert.
  • Einen MCP-fähigen Agenten oder Editor, zum Beispiel Claude Code, Cursor, VS Code mit Copilot, Gemini CLI oder Codex.

Prüf zuerst deine Node-Version:

Terminal
node --version

Schritt 1: Prüfen, ob der Server läuft

Bevor du die Einstellungen deines Agenten anfasst, stell sicher, dass das Paket auf deinem Rechner startet. Der offizielle Troubleshooting-Guide empfiehlt diesen Test:

Terminal
npx chrome-devtools-mcp@latest --help

Du solltest eine Liste von Optionen wie --headless, --isolated und --browser-url sehen. Wenn hier schon ein Fehler kommt, behebe ihn, bevor du weitermachst (siehe den Abschnitt zu Fehlern weiter unten).

Schritt 2: Zum Agenten hinzufügen

Die meisten MCP-Clients akzeptieren denselben JSON-Block. Das ist die Standardkonfiguration aus dem README des Projekts:

Code
{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest"]
    }
  }
}

Mit @latest holt sich dein Client neue Versionen automatisch.

Für mehrere Tools gibt es zusätzlich eine Installation per Einzeiler. Die Befehle stammen aus dem Client-Konfigurationsguide des Projekts.

Claude Code:

Code
claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest

Gemini CLI:

Code
gemini mcp add chrome-devtools npx chrome-devtools-mcp@latest

OpenAI Codex:

Code
codex mcp add chrome-devtools -- npx chrome-devtools-mcp@latest

VS Code (macOS und Linux):

Code
code --add-mcp '{"name":"io.github.ChromeDevTools/chrome-devtools-mcp","command":"npx","args":["-y","chrome-devtools-mcp"],"env":{}}'

In Cursor gehst du laut Guide zu Cursor Settings (Cursor-Einstellungen), dann zu MCP, dann zu New MCP Server (neuer MCP-Server) und fügst die Standardkonfiguration ein. Menünamen können sich zwischen Versionen ändern; wenn du den Pfad nicht findest, schau in Cursors eigene MCP-Dokumentation.

Optional: Als Plugin mit Skills installieren

Das Projekt liefert auch „Skills“ mit, kurze Anleitungsdateien, die deinem Agenten beibringen, die Tools gut zu nutzen. In Claude Code installierst du Server und Skills zusammen, indem du /plugin marketplace add ChromeDevTools/chrome-devtools-mcp und danach /plugin install chrome-devtools-mcp@chrome-devtools-plugins ausführst und Claude Code anschließend neu startest. Wenn Skills neu für dich sind, erklärt unsere Anleitung, wie du Agent Skills in Claude Code installierst und nutzt, wie sie funktionieren.

Schritt 3: Den ersten Prompt ausführen

Starte deinen Agenten neu, damit er den neuen Server lädt, und gib dann den Test-Prompt ein, den das Projekt vorschlägt:

Code
Check the performance of https://developers.chrome.com

Erwartetes Ergebnis: Ein Chrome-Fenster öffnet sich, die Seite lädt, und dein Agent berichtet über einen Performance-Trace. Der Browser startet erst, wenn der Agent zum ersten Mal ein Tool nutzt, das ihn braucht; das bloße Verbinden des Servers öffnet Chrome also noch nicht.

Wenn das klappt, probier Prompts aus, die zu deiner eigenen Arbeit passen:

Code
Open http://localhost:3000, list any console errors, and tell me which network requests failed.
Code
Take a screenshot of http://localhost:3000 at a mobile viewport and check the page for accessibility problems.

Standardmäßig startet der Server Chrome mit einem eigenen Profil, das unter macOS und Linux in $HOME/.cache/chrome-devtools-mcp/chrome-profile liegt. Dieses Profil bleibt zwischen den Durchläufen erhalten, Logins dort bleiben also bestehen.

Schritt 4: Ändern, wie Chrome startet (optional)

Das Verhalten steuerst du, indem du Flags zum Array args hinzufügst. Dieses Beispiel startet Chrome ohne Fenster, nutzt ein temporäres Profil, das danach gelöscht wird, und schaltet Googles Nutzungsstatistiken ab, die standardmäßig erhoben werden:

Code
{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": [
        "-y",
        "chrome-devtools-mcp@latest",
        "--headless=true",
        "--isolated=true",
        "--no-usage-statistics"
      ]
    }
  }
}

Zwei weitere Datenschutz-Einstellungen solltest du kennen. Die Performance-Tools können Trace-URLs an Googles Chrome UX Report (CrUX) API senden, um Daten echter Nutzer abzurufen; mit --no-performance-crux verhinderst du das. Wenn du nur einfaches Browsen brauchst, stellt --slim einen reduzierten Satz von drei Tools bereit.

Schritt 5: Mit einem Chrome-Fenster verbinden, das du schon nutzt (optional)

Manchmal soll der Agent in deinem eigenen Browser arbeiten, etwa auf einer Website, bei der du schon angemeldet bist. Stand 14. November 2026 braucht dieser „Auto Connect“-Modus Chrome 144 oder neuer.

  1. Ruf in Chrome chrome://inspect/#remote-debugging auf und folge dem Dialog, um eingehende Debugging-Verbindungen zu erlauben.
  2. Füge --autoConnect zu deiner Konfiguration hinzu:
Code
{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["chrome-devtools-mcp@latest", "--autoConnect"]
    }
  }
}
  1. Lass Chrome laufen und schick einen Prompt. Chrome fragt nach der Erlaubnis; klick auf Allow (Zulassen).

Der Server verbindet sich mit deinem Standard-Chrome-Profil und sieht jedes darin geöffnete Fenster. Schließ vorher Tabs mit Onlinebanking, E-Mail oder anderen sensiblen Daten. Der Hinweis des Projekts selbst warnt, dass der Agent alle Daten im Browser einsehen und verändern kann.

Läuft dein Agent in einer Sandbox, kannst du Chrome stattdessen selbst mit einem Debugging-Port und einem separaten Profil starten (hier für macOS; die Doku nennt auch die Pfade für Linux und Windows):

Code
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-profile-stable

Nutze dann "--browser-url=http://127.0.0.1:9222" in args. Solange dieser Port offen ist, kann jede App auf deinem Rechner den Browser steuern, also surf in diesem Fenster nicht auf sensiblen Seiten.

Häufige Fehler und Lösungen

  • Error [ERR_MODULE_NOT_FOUND]: Cannot find module ...: meist eine nicht unterstützte Node-Version oder ein beschädigter npx-Cache. Aktualisiere Node, leere den Cache mit npm cache clean --force und installiere neu. Die Doku schlägt außerdem rm -rf ~/.npm/_npx vor, was aber auch andere zwischengespeicherte npx-Tools entfernt.
  • Target closed: Chrome konnte nicht starten. Stell sicher, dass keine anderen Chrome-Instanzen laufen (schließ sie gegebenenfalls) und dass die neueste stabile Chrome-Version installiert ist.
  • Agent findet den Server nicht, aber der Test im Terminal klappt: Stell sicher, dass dein Editor dasselbe Node und npm nutzt wie dein Terminal.
  • Windows: MCP error -32000: Connection closed: Setz "command": "cmd" und schreib "/c", "npx", "-y", "chrome-devtools-mcp@latest" in args.
  • macOS: --autoConnect scheitert mit EPERM: operation not permitted: Gib deinem Terminal oder Editor Zugriff auf Google Chrome unter System Settings > Privacy & Security > Files & Folders (Systemeinstellungen > Datenschutz & Sicherheit > Dateien und Ordner).
  • --autoConnect läuft in einen Timeout: Prüf, ob Chrome 144+ bereits läuft, Remote-Debugging unter chrome://inspect/#remote-debugging aktiviert ist, du die Abfrage bestätigt hast und nichts anderes denselben Debugging-Port belegt.
  • Chrome startet nicht im Container oder in der CI: Chrome läuft nicht als root. Führ den Server mit einem Benutzer ohne Root-Rechte aus.
  • Arbeiten in einer VM: Chrome lehnt Verbindungen aus der VM unter Umständen ab. Die Doku schlägt einen SSH-Tunnel aus der VM vor, zum Beispiel ssh -N -L 127.0.0.1:9222:127.0.0.1:9222 user@server. Unsere Anleitung zu SSH-Schlüsseln erklärt die Einrichtung, falls du SSH noch nie benutzt hast.

Für alles andere startest du den Server mit einer Logdatei und liest die Fehlermeldung:

Code
NODE_DEBUG=* npx chrome-devtools-mcp@latest --log-file=/tmp/chrome-devtools-mcp.log

Fazit

Mit Chrome DevTools MCP kann dein Agent seine eigene Frontend-Arbeit prüfen, statt zu raten: Seite laden, Fehler lesen, den Netzwerk-Tab ansehen und die Performance messen. Fang mit der Standardkonfiguration und dem Test-Prompt an, nimm --isolated oder --headless dazu, wenn du einen sauberen Wegwerf-Browser willst, und nutz Auto Connect nur in einem Profil, in dem es dich nicht stört, dass eine KI alles sieht. Halte auch Chrome selbst aktuell; unser Erklärstück zu Chrome-Zero-Days zeigt, warum das wichtig ist.

Quellen

Links zuletzt geprüft am 15. November 2026.

Von Mindloop Editorial

The Mindloop Experience editorial team writes clear, carefully sourced explainers and how-tos on tech, science, money and culture, for anyone who likes to know how things actually work.

Über Mindloop Experience

Kommentare

Kommentar schreiben

Mehr von Mindloop Experience

Alle Artikel von Mindloop Experience

Du kannst bis zu 50-mal applaudieren.