playwright-bot-bypass skill

A skill that runs Playwright in real Chrome with rebrowser patches so automated tests on your own sites are not mistaken for a bot

  • 208 ★ on the repository
  • Last commit
  • MIT
Skill

Broad access

Why this level

  • The tool hides browser automation traces, so use against a site's terms may violate its rules and the law
  • It launches the installed Chrome in a visible window and runs Node.js scripts through which the agent drives pages and input
All reasons and checks

greekr4/playwright-bot-bypass

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/playwright-bot-bypass

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Broad accessThe tool can change data, run commands or handle secrets.

  • The tool hides browser automation traces, so use against a site's terms may violate its rules and the law
  • It launches the installed Chrome in a visible window and runs Node.js scripts through which the agent drives pages and input

This is third-party code. Review the repository files before installing.

What it does

The playwright-bot-bypass skill teaches an agent to run Playwright so that automation is not given away by the usual signs of headless mode. The base is `rebrowser-playwright` with a fix for the CDP `Runtime.enable` leak, real Google Chrome through `channel: 'chrome'` with a visible window, and removal of the `window.__pwInitScripts` trace on every navigation. Version 2.2 dropped `navigator` patches: by the author's measurements each patch created a visible inconsistency in the fingerprint. The kit includes a `createStealthBrowser()` factory, `humanType` and `simulateMouseMovement` helpers, examples (a Google search, reading a public feed) and a script that checks against public detectors. For Python it describes a setup with `undetected-chromedriver`. By measurements from June 10, 2026 on macOS the skill passes eight public fingerprint and automation checks, among them sannysoft, rebrowser, browserscan and creepjs. Plain Playwright is flagged as a bot on the same pages.

Who it is for. QA engineers and researchers who automate their own sites or platforms where testing is permitted and run into false blocks of headless mode.

Good fit when

  • An autotest on your own site fails on bot protection because the page sees headless Chromium: real Chrome in a visible window removes the false trigger
  • An accessibility check must show the page the way an ordinary visitor sees it in Google Chrome
  • Research on public Google, Reddit, YouTube, TikTok and X pages without sign-in hits a bot wall: the author measured that the skill passes it
  • You need to gauge how your site's protection treats automation: `bot-detection-test.mjs` runs detector pages and produces a report
  • A Python project: the skill describes a setup with `undetected-chromedriver` and `uc.Chrome()`

Not a fit when

  • The site is someone else's and its terms forbid automated access: the author permits use only on your own and permitted resources
  • You need to get around paid access or rate limits or collect data against a site's wishes: `SKILL.md` explicitly excludes such use
  • The environment has no screen, for example a server: `headless: false` is required and without a window the stealth is lost
  • Site protection rests on IP reputation, behavioral analysis or CAPTCHAs such as Turnstile, DataDome and Kasada: the skill cannot handle them

Example request

Open our staging in real Chrome through playwright-bot-bypass, go through the sign-in form and save a screenshot of the order page

Limitations

  • Requires Node.js 18 or newer, real Google Chrome (Chromium alone is not enough) and a display: `headless: false` is mandatory.
  • One trace remains, `__playwright_builtins__`, which no current rebrowser version removes.
  • Measurements were made on June 10, 2026 on macOS with an ordinary home IP; on another system or network the result may differ.
  • For enterprise bot managers that inspect CDP there is no guarantee, and pages behind a login (Instagram, Facebook, LinkedIn) stay closed.

How to disable. In Claude Code the plugin is removed through `/plugin`, and a skill installed through `npx skills` is deleted with the `playwright-bot-bypass` folder in the skills directory. The `rebrowser-playwright` package is removed with `npm uninstall rebrowser-playwright`.

FAQ

How do I install playwright-bot-bypass in Claude Code?

Run `/plugin marketplace add greekr4/playwright-bot-bypass`, then `/plugin install playwright-bot-bypass@playwright-bot-bypass`. To run the scripts you will then need `npm install rebrowser-playwright`.

How do I install the skill in Codex or Cursor?

With `npx skills add greekr4/playwright-bot-bypass`: it installs the skill for every detected agent, and the `-a codex` flag keeps only Codex. Call it with the task wording or explicitly through `$playwright-bot-bypass`.

What code does a run need?

Import `createStealthBrowser` from `./scripts/stealth-template.mjs`, get `browser` and `page`, open a page and call `browser.close()` in a `finally` block. Without closing, the process hangs.

Is the playwright-stealth package a fit?

The author advises skipping it: it patches only JavaScript, so WebGL still leaks the SwiftShader software renderer. The skill relies on real Chrome and a real GPU.

Can I use the skill from Python?

Yes, install `pip install undetected-chromedriver` and run `uc.Chrome()`. The driver version must match the Chrome version, which `chrome://version` shows.

Discussion

No questions or reviews yet.

Skills
Official

An MCP and CLI that let an agent control your real Chrome, with its own logins and extensions, through Playwright

MCP serverBroad access4.1KRepository stars

Anti-Detect Browser Skills (AntiBrow)

Anti-Detect Browser Skills

Official

Four AntiBrow skills: browser profiles with a device fingerprint, an MCP mode for agents and data collection with ready recipes

SkillBroad access21Repository stars

BetterWright keeps a persistent Playwright browser for agents with network rules, a credential vault and human handoff of steps.

CLIBroad access350Repository stars

A local Playwright driver for your everyday Chromium browser: the agent works in your live, logged-in profile through an extension and a relay

CLIBroad access498Repository stars

Playwright-based MCP server for browsing sites, clicking, filling forms, taking screenshots and running JavaScript in a browser

MCP serverBroad access297Repository stars

Turns any website into a CLI command and lets an agent drive the user's already logged-in browser via Playwright

CLIBroad access31KRepository stars

Comparison with similar tools

Cards that share the main search query, and how they differ.

ToolOfficialAuthenticationRepository starsMain difference
playwright-bot-bypass (this card)no208
Playwright Skillno3,287writes and runs ordinary Playwright scripts for tests, forms and screenshots without masking automation
agent-browseryesnot required50,530a Rust CLI with accessibility snapshots and an MCP server for agent browser control

README in short

The page opens with a claim about results on public detectors and a note that the tool is for authorized use. It continues with install commands for Claude Code, Codex and Cursor, a quick start in JavaScript and Python, a table of what the skill passes and what it does not touch, a comparison with plain Playwright on three detectors, the three-layer design, requirements and links to the projects it builds on.

README badge

Original SKILL.md

---
name: playwright-bot-bypass
description: This skill should be used when the user asks to "bypass bot detection", "avoid CAPTCHA", "stealth browser automation", "undetected playwright", "bypass Google bot check", "rebrowser-playwright", or needs to automate websites that detect and block bots.
version: 2.2.0
---

# Playwright Bot Bypass

Reduce bot detection using rebrowser-playwright + real headed Chrome. Passes fingerprint checkers (bot.sannysoft.com, areyouheadless) and avoids triggering CAPTCHAs on Google. **Not** a guaranteed bypass for CDP/runtime-aware enterprise bot managers — see "Detection Coverage" for measured results.

> **Authorized use only.** This is for QA, accessibility testing, and research on sites you own or are permitted to test. Respect each site's Terms of Service, `robots.txt`, and applicable law. Do not use it to bypass paywalls, abuse rate limits, or scrape against a site's stated wishes.

## How Detection Is Defeated (and by which layer)

Evasion comes from **three** layers, not one — most of it is the real browser, not hand-written JS:

| Detection Point | Standard Playwright (headless) | Defeated by |
|-----------------|--------------------------------|-------------|
| CDP / `Runtime.enable` leak | Present (headless tell) | **rebrowser + `REBROWSER_PATCHES_RUNTIME_FIX_MODE`** (auto-set) |
| `window.__pwInitScripts` (`isPlaywright`) | Present | **artifact strip** (init script deletes it every nav) |
| `navigator.webdriver` | `true` | **rebrowser** (reports `false`; we do NOT delete it — `undefined` is itself a tell) |
| WebGL Renderer | SwiftShader (software) | **`channel:'chrome'` + headed mode** (real GPU) |
| User Agent | Contains "HeadlessChrome" | **`channel:'chrome'`** (real Chrome UA) — no JS override |
| Canvas fingerprint | Software-rendered tell | **headed real Chrome** (genuine GPU canvas) — no JS noise |
| `navigator.plugins` | Empty array | **headed real Chrome** (genuine PluginArray) — no JS fake |
| `navigator.languages` | `['en-US']` only | **`locale` option** (native, worker-consistent — no JS getter) |

> **Why so little hand-written JS?** Across v2.1/v2.2 the old fake-PluginArray, canvas-noise, hardcoded-`hardwareConcurrency`, permissions-override, `webdriver` delete, and `navigator.languages` getter were all removed — every one created a *detectable inconsistency* (own-property tells, worker mismatches, `undefined` webdriver, an `Illegal invocation` crash). v2.2 keeps exactly **two** active measures: strip Playwright's `__pwInitScripts` artifact, and enable rebrowser's Runtime-fix. Everything else is the genuine, self-consistent real browser. Less faking = more consistent = harder to detect.

## Prerequisites

- **Node.js 18+** with ESM support (`.mjs` files)
- **Google Chrome** installed (not just Chromium)
- **Headed mode** required (`headless: false`) — no display = no stealth

Verify Chrome is installed:
```bash
# macOS
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --version
# Windows
"C:\Program Files\Google\Chrome\Application\chrome.exe" --version
# Linux
google-chrome --version
```

## Quick Start

### 1. Install

```bash
npm init -y && npm install rebrowser-playwright
```

### 2. Create `stealth-test.mjs`

Report a problem