Post cover image

December 18, 2025

Playwriter.dev: The Most Powerful Way to Reverse-Engineer Browser Actions With an LLM

Browser automation is undergoing a quiet revolution — and Playwriter.dev is one of the most exciting tools driving it.

By Civil Learning

3 min read

If you've ever tried to reverse-engineer a private API, analyse network calls, or build automation workflows in your own browser, you know how frustrating traditional tools can be. They're slow, bloated, and often break as soon as they detect automation.

Playwriter flips the script.

It gives you complete Playwright control over your real Chrome browser through a Chrome extension — allowing you to work alongside your AI assistant in the same tab.

This isn't a toy MVP. It's a serious upgrade to the developer workflow.

Let's break it down.

None

What makes Playwriter special?

Most automation agents (BrowserMCP, Antigravity/Jetski, etc.) follow the same limited design:

  • Dozens of narrow browser tools
  • Heavy context window usage
  • Slow round-trip latency
  • New Chrome instances for every task
  • Automation detection everywhere

Playwriter takes the opposite approach:

1. One tool instead of 17+

Instead of exposing a tool for every browser action, Playwriter exposes only one: execute

This means the LLM can write and run real Playwright code, like:

await page.click('#buy-button')
await page.type('#amount', '100')
await page.screenshot({ path: 'trade.png' })

LLMs already understand Playwright extremely well — no need to teach them 17 separate "browser_click", "browser_type", "browser_scroll" tools.

2. Runs inside your existing browser

Playwriter works through a Chrome extension, not a separate Chrome window.

Benefits:

  • Use your normal tabs
  • Keep your extensions (AdBlock, password managers, 2FA tools)
  • Bypass automation detection by disconnecting the extension
  • Solve captchas manually, then let AI continue
  • Save memory and CPU

It's automation that fits into how real people browse.

Reverse-engineering APIs becomes trivial

Here's the magic workflow:

  1. You open a site (like Polymarket).
  2. You act (like placing a trade).
  3. Playwriter monitors the network traffic.
  4. You ask your LLM: "Analyze these requests and build an SDK for them."

The LLM sees the exact:

  • endpoints
  • headers
  • request bodies
  • responses

…and produces code that replays the same behavior.

This workflow used to take hours. Now you do it in minutes.

How to Install Playwriter

1. Install the Chrome Extension

From the Chrome Web Store (or load it unpacked during development).

2. Pin the Extension

Click the puzzle icon — Pin — You'll see the icon in your toolbar.

3. Connect a Tab

Open any tab — Click the Playwriter icon — It turns green.

Icon states:

  • Gray — Not connected
  • Green — Connected
  • Orange (…) — Connecting
  • Red (!) — Error

Once a tab is green, your AI has full Playwright control over it.

Add Playwriter to your MCP Agent

Modify your claude_desktop_config.json like this:

{
  "mcpServers": {
    "playwriter": {
      "command": "npx",
      "args": ["playwriter@latest"]
    }
  }
}

Restart Claude Desktop — you're ready.

Using Playwriter with Playwright

Yes, you can even connect Playwriter to Playwright programmatically:

import { chromium } from 'playwright-core'
import { startPlayWriterCDPRelayServer, getCdpUrl } from 'playwriter'

const server = await startPlayWriterCDPRelayServer()
const browser = await chromium.connectOverCDP(getCdpUrl())
const context = browser.contexts()[0]
const page = context.pages()[0]
await page.goto('https://example.com')
await page.screenshot({ path: 'screenshot.png' })
await browser.close()
server.close()

This is incredibly useful for:

  • debugging real webpages
  • capturing tricky auth flows
  • automating tasks without triggering bot detection

Playwriter vs Playwright MCP

| Feature                     | Playwriter | Playwright MCP        |
| --------------------------- | ---------- | --------------------- |
| Runs in your own browser    | YES         | launches new Chrome |
| Full Playwright API         | YES         | Partial               |
| Use extensions              | YES        | NO                 |
| Bypass automation detection | YES        | NO                    |
| Context window usage        | Very low   | High                  |

The key takeaway: Playwriter is not a competing tool — it's the better architecture.

Playwriter vs BrowserMCP

BrowserMCP exposes tools like:

  • navigate
  • click
  • type
  • hover
  • screenshot
  • wait

Suitable for demos, but limited in complexity.

Playwriter gives you:

await page.route()
await page.evaluate()
await page.locator()
await context.cookies()
await browser.newPage()

No limits. Full API.

Playwriter vs Antigravity (Jetski)

Jetski introduces:

  • 17+ browser tools
  • a separate subagent
  • bloated schemas
  • slow execution

Playwriter solves this with:

  • 1 tool: execute
  • 0 subagents
  • Low latency
  • Full Playwright power

Security: Only You Are in Control

Playwriter is built with strict security boundaries:

  • The WebSocket server only accepts localhost connections
  • Chrome shows an automation banner
  • Only tabs you explicitly connect can be controlled
  • No other tabs or browsing history are accessible

You always stay in charge.

Why Playwriter matters

This tool changes what's possible for developers, researchers, and power users:

  • debugging complex flows
  • testing UI changes
  • reverse-engineering private APIs
  • generating SDKs from your actions
  • automating daily tasks in your own Chrome environment

And because it uses the LLM's built-in knowledge of Playwright, it feels natural and effortless.

The future of browser automation is collaborative

Instead of replacing you, Playwriter lets you and your AI work in the same browser, in the same tab, at the same time.

You take care of the parts automation struggles with. The AI handles the repetitive work. Both of you stay perfectly in sync.

That's the future — and Playwriter is already building it.