Skip to main content
skill CX Codex

openai-playwright — Claude Code skill for browser automation

openai-playwright is a Claude Code skill that controls a real browser from the terminal. It runs for page navigation, form entry, data collection, screenshots, and UI debugging.

Apache-2.0 ★ 540 updated 2026-07-14

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add trailofbits/skills-curated
/plugin install openai-playwright@skills-curated
Open on GitHub

What openai-playwright does

openai-playwright drives a browser with playwright-cli: it opens pages, interacts with page elements, and captures screenshots, PDFs, or traces. It takes a page snapshot to identify elements before using them. After navigation or major UI changes, it takes another snapshot because old element references can go stale.

The wrapper requires npx, which comes with Node.js/npm. If npx is missing, the skill asks for Node.js/npm to be installed; a global playwright-cli installation is optional. This workflow uses CLI commands rather than generating @playwright/test specs, unless those are explicitly requested. In this repository, captured artifacts go in output/playwright/.

What it helps with

  • navigate through a page and interact with its controls
  • fill in and submit a web form
  • capture a page screenshot or PDF
  • collect data from a browser page
  • record a UI flow for debugging

Example prompts for the agent

  • Open the page and show me its snapshot.
  • Fill out the form on this page and submit it.
  • Record this UI flow and save a screenshot.

How to install openai-playwright

1Plugin marketplace

/plugin marketplace add trailofbits/skills-curated
/plugin install openai-playwright@skills-curated

This installs the whole openai-playwright plugin with all its skills

2Skills CLI (Vercel)

npx skills add trailofbits/skills-curated --skill openai-playwright -a claude-code

3Manually: put the files in place

~/.claude/skills/openai-playwright/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/openai-playwright/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about openai-playwright

How do I install openai-playwright in Claude Code?

Add the marketplace with /plugin marketplace add trailofbits/skills-curated, then install the skill with /plugin install openai-playwright@skills-curated.

What does openai-playwright do?

It controls a browser from the terminal through playwright-cli. It can navigate pages, fill forms, collect data, and capture screenshots or traces.

What does openai-playwright need to run?

Its wrapper needs npx, provided by Node.js/npm. A global playwright-cli install is an optional alternative.

Source text

SKILL.md · Apache-2.0
---
name: openai-playwright
description: Use when the task requires automating a real browser from the terminal (navigation, form
  filling, snapshots, screenshots, data extraction, UI-flow debugging) via `playwright-cli` or the bundled
  wrapper script. Originally from OpenAI's curated skills catalog.
allowed-tools:
- Bash
- Read
- Grep
- Glob
- Write
- Edit
---

# Playwright CLI Skill

Drive a real browser from the terminal using `playwright-cli`. Prefer the bundled wrapper script so the CLI works even when it is not globally installed.
Treat this skill as CLI-first automation. Do not pivot to `@playwright/test` unless the user explicitly asks for test files.

## Prerequisite check (required)

Before proposing commands, check whether `npx` is available (the wrapper depends on it):

```bash
command -v npx >/dev/null 2>&1
```

If it is not available, pause and ask the user to install Node.js/npm (which provides `npx`). Provide these steps verbatim:

```bash
# Verify Node/npm are installed
node --version
npm --version

# If missing, install Node.js/npm, then:
npm install -g @playwright/cli@latest
playwright-cli --help
```

Once `npx` is present, proceed with the wrapper script. A global install of `playwright-cli` is optional.

Scripts and references are located under `{baseDir}/`.

## Quick start

Use the wrapper script:

```bash
"$PWCLI" open https://playwright.dev --headed
"$PWCLI" snapshot
"$PWCLI" click e15
"$PWCLI" type "Playwright"
"$PWCLI" press Enter
"$PWCLI" screenshot
```

If the user prefers a global install, this is also valid:

```bash
npm install -g @playwright/cli@latest
playwright-cli --help
```

## Core workflow

1. Open the page.
2. Snapshot to get stable element refs.
3. Interact using refs from the latest snapshot.
4. Re-snapshot after navigation or significant DOM changes.
5. Capture artifacts (screenshot, pdf, traces) when useful.

Minimal loop:

```bash
"$PWCLI" open https://example.com
"$PWCLI" snapshot
"$PWCLI" click e3
"$PWCLI" snapshot
```

## When to snapshot again

Snapshot again after:

- navigation
- clicking elements that change the UI substantially
- opening/closing modals or menus
- tab switches

Refs can go stale. When a command fails due to a missing ref, snapshot again.

## Recommended patterns

### Form fill and submit

```bash
"$PWCLI" open https://example.com/form
"$PWCLI" snapshot
"$PWCLI" fill e1 "[email protected]"
"$PWCLI" fill e2 "password123"
"$PWCLI" click e3
"$PWCLI" snapshot
```

### Debug a UI flow with traces

```bash
"$PWCLI" open https://example.com --headed
"$PWCLI" tracing-start
# ...interactions...
"$PWCLI" tracing-stop
```

### Multi-tab work

```bash
"$PWCLI" tab-new https://example.com
"$PWCLI" tab-list
"$PWCLI" tab-select 0
"$PWCLI" snapshot
```

## Wrapper script

The wrapper script uses `npx --package @playwright/cli playwright-cli` so the CLI can run without a global install:

```bash
"$PWCLI" --help
```

Prefer the wrapper unless the repository already standardizes on a global install.

## References

Open only what you need:

- CLI command reference: `references/cli.md`
- Practical workflows and troubleshooting: `references/workflows.md`

## Guardrails

- Always snapshot before referencing element ids like `e12`.
- Re-snapshot when refs seem stale.
- Prefer explicit commands over `eval` and `run-code` unless needed.
- When you do not have a fresh snapshot, use placeholder refs like `eX` and say why; do not bypass refs with `run-code`.
- Use `--headed` when a visual check will help.
- When capturing artifacts in this repo, use `output/playwright/` and avoid introducing new top-level artifact folders.
- Default to CLI commands and workflows, not Playwright test specs.

## When to Use

<!-- TODO: review -->

## When NOT to Use

<!-- TODO: review -->

© OpenAI · Apache-2.0 · trailofbits/skills-curated

Similar skills

All skills for Browser and scraping →

From the same set51

The whole set →
grilling The grilling skill questions a plan or design one decision at a time, surfacing unresolved choices and dependencies. Use it before implementation when the details still need agreement. CX Codex +1 ★ 540repo stars openai-yeet openai-yeet takes your changes from a dirty working tree to a draft pull request in one run through GitHub CLI. Handy when the whole chain has to happen at once. CX Codex +1 ★ 540repo stars openai-sentry The openai-sentry Claude Code skill reads Sentry issues and events through the API and summarizes production errors in a compact report. CX Codex +1 ★ 540repo stars python-code-simplifier python-code-simplifier refines recently modified Python code for clarity and maintainability without altering existing program logic or outputs. CX Codex ★ 540repo stars openai-gh-fix-ci openai-gh-fix-ci reads the failing GitHub Actions checks on a pull request, pulls the logs, names the cause and drafts a fix. Edits land only after you approve the plan. CX Codex +1 ★ 540repo stars openai-jupyter-notebook openai-jupyter-notebook is a Claude Code skill that generates, structures, and edits clean Jupyter notebooks (.ipynb) for analytical experiments and step-by-step guides. CX Codex +1 ★ 540repo stars security-awareness The security-awareness skill guides an agent through phishing checks, domain verification, and safer handling of credentials. Use it when an agent works with email, links, or sensitive data. CX Codex +1 ★ 540repo stars openai-netlify-deploy openai-netlify-deploy — a Claude skill that runs a Netlify deploy end to end: sign-in check, site linking or creation, dependency install, then a preview or production release. CX Codex +1 ★ 540repo stars

Project sponsors

Companies that keep this analytics open