Chromeflow vs Playwright
Playwright is the best browser-automation library ever shipped. It's also the wrong tool for AI agents that need to log in. Here's why, and where each one genuinely wins.
Capability matrix
| Chromeflow | Playwright | |
|---|---|---|
| Runs in your real Chrome with sessions intact | Yes | No — launches a fresh profile |
| Inherits your existing logins (Stripe, GitHub, Canvas, AWS…) | Yes — they're already there | No — you script the login from scratch each run |
| Handles 2FA / passkeys without re-engineering | Yes — pauses for you | No — 2FA breaks every script |
| One-command install as an MCP plugin | /plugin install chromeflow | Library — wire your own MCP server |
| Native integration with Claude Code & Codex CLI | Yes (28 MCP tools) | DIY — wrap with custom MCP server |
Captures API keys → .env | Yes (write_to_env) | No |
| Privileged fetch (bypasses page CSP, includes Chrome cookies) | Yes (fetch_url, download_file, read_attachment) | CDP route exists but no built-in tool |
| Authenticated file downloads (Canvas, Stripe, etc.) | One call | Possible but DIY |
Parses .docx attachments in-browser | Yes (read_attachment) | No |
| Visual handoff for human-in-the-loop (passwords, 2FA, payment) | Yes (highlight + wait_for_click) | No |
| Multi-agent parallelism in one Chrome | Up to 11 sessions, one popup view | Spawn multiple processes manually |
| Mature for non-agent use (CI, scraping, testing) | No — agent-first | Yes — the gold standard |
| Cross-browser (Chromium, Firefox, WebKit) | Chromium only | All three |
| Headless mode | Headed only (it's your Chrome) | Yes |
| License & cost | Free, MIT | Free, Apache 2.0 |
Where Playwright wins
CI test suites. If your job is "run a test that logs into our staging site with hard-coded creds and checks that the checkout button still works", Playwright is the right choice. The fresh-profile model is a feature here — each test starts from a known clean state. Cross-browser testing across Chromium + Firefox + WebKit is solid. The maintainership behind it (Microsoft) is durable.
Headless scraping of public content. No login? No problem. Playwright runs headless, scales horizontally, and has battle-tested rate-limit handling. For scraping Reddit search, Wikipedia, public Stack Overflow, or any logged-out content, Playwright outperforms a real-Chrome approach because you don't need browser visibility.
Browser automation as a library inside larger applications. Playwright is a library you call from Node or Python; Chromeflow is an MCP plugin you install once. If you're building a SaaS product that needs to render PDFs server-side from arbitrary HTML, Playwright is the building block.
Where Chromeflow wins
Agentic workflows behind a login. The moment an AI agent's task starts with "open Stripe and grab the secret key" or "download the assignment file from Canvas", Playwright fails — the agent hits a login screen with no credentials and no way past 2FA. Chromeflow runs in your Chrome where those sessions already exist. The agent automates the boring parts (clicks, fills, captures); you handle the parts that need a human (passwords, 2FA, payment).
Native MCP integration for Claude Code and Codex CLI. Chromeflow ships as a plugin. /plugin marketplace add NeoDrew/chromeflow followed by /plugin install chromeflow is the entire install. With Playwright you'd build your own MCP server, wire the tools, write the schemas, deal with WebSocket plumbing — a week of work that's already done in Chromeflow.
Credential capture to .env. When the agent surfaces an API key (Stripe secret, Supabase service role, OpenAI key), write_to_env writes it to the project's .env file in one call. With Playwright the agent would have to page.textContent() the value, then ship a tool call back to your editor, then write the file separately.
Privileged fetch that respects auth. Chromeflow's fetch_url, download_file, and read_attachment run in the extension's background service worker with full host permissions — they include your Chrome cookies and bypass page CSP. Pulling an authenticated PDF from Canvas, an invoice PDF from Stripe, or a private GitHub release tarball is a single tool call. Playwright has CDP access but no built-in equivalent — you'd assemble it yourself.
The decision rule
Look at the next 10 things your agent needs to do in a browser. If more than two of them require a session you've already authenticated — pick Chromeflow. If it's pure public-content automation or CI testing — pick Playwright. If it's a mix, install both: Chromeflow for the interactive setup phase (capturing keys, configuring dashboards, downloading attachments) and Playwright in CI once everything's wired.
"But Playwright has --use-existing-browser…"
Playwright's connectOverCDP can attach to a running Chrome with --remote-debugging-port. In theory this gives you a real-session approach. In practice: you have to launch Chrome with the debug port enabled from the command line (you can't attach to a Chrome you opened normally), the attach often fails on the latest Chrome versions when DevTools is also open, the agent has no native visual handoff, and you've still got no write_to_env / no read_attachment / no MCP integration. It's a workaround for one specific scenario, not a competitive feature with Chromeflow's first-class real-Chrome integration.
Performance and reliability
- Latency: Playwright runs in its own process and pays a per-command IPC cost. Chromeflow runs as a Chrome extension talking over a local WebSocket — slightly faster per-action. Both are dominated by Chrome's own render time (~100–300 ms per click).
- Reliability: Playwright's auto-waiting is the best in the business. Chromeflow exposes
until_url_contains,until_selector,until_text_contains, andexpect_submitonclick_elementso every action has a verifiable post-condition. - Resource cost: Playwright spawns a browser per test (or pools them). Chromeflow uses the Chrome that's already running on your machine — zero new processes, zero new memory.
Using both together
This is the under-appreciated pattern: Chromeflow for the interactive setup phase, Playwright in CI for headless verification. Use Chromeflow once to walk through Stripe's onboarding, capture the secret key to .env, and verify webhook reachability. Then use Playwright in your CI pipeline to assert the integration keeps working — no human in the loop, hard-coded test credentials, isolated browser instance. Different parts of the same lifecycle.