Browser Automation for Sandboxed Agents

Controls a local browser from a sandboxed remote machine.

You say
Install this skill Read the source first Free Written by browser-use · unverified publisher
Context cost
2k tokensestimated from the bundle, loaded when it triggers
Bundle
1 file · 8.2 kBtext throughout, nothing executable
Licence
MITfree to use
Last change
no release on file
Servers it uses
Noneruns standalone

What it does

Controls a local browser from a sandboxed remote machine. Use when the agent is running in a sandbox (no GUI) and needs to navigate websites, interact with web pages, fill forms, take screenshots, or expose local dev servers via tunnels.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Workflow

Runs a procedure end to end.

browserautomation

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md8.2 kB · 180 lines
--- name: remote-browser description: Controls a local browser from a sandboxed remote machine. Use when the agent is running in a sandbox (no GUI) and needs to navigate websites, interact with web pages, fill forms, take screenshots, or expose local dev servers via tunnels. allowed-tools: Bash(browser-use:*) ---
7# Browser Automation for Sandboxed Agents
8
9This skill is for agents running on **sandboxed remote machines** (cloud VMs, CI, coding agents) that need to control a headless browser.
10
11## Prerequisites
12
13```bash
14browser-use doctor # Verify installation
15```
16
17For setup details, see https://github.com/browser-use/browser-use/blob/main/browser_use/skill_cli/README.md
18
19## Core Workflow
20
211. **Navigate**: browser-use open <url> — starts headless browser if needed
222. **Inspect**: browser-use state — returns clickable elements with indices
233. **Interact**: use indices from state (browser-use click 5, browser-use input 3 "text")
244. **Verify**: browser-use state or browser-use screenshot to confirm
255. **Repeat**: browser stays open between commands
266. **Cleanup**: browser-use close when done
27
28## Browser Modes
29
30```bash
31browser-use open <url> # Default: headless Chromium
32browser-use cloud connect # Provision cloud browser and connect
33browser-use --connect open <url> # Auto-discover running Chrome via CDP
34browser-use --cdp-url ws://localhost:9222/... open <url> # Connect via CDP URL
35```
36
37## Commands
38
39```bash
40# Navigation
41browser-use open <url> # Navigate to URL
42browser-use back # Go back in history
43browser-use scroll down # Scroll down (--amount N for pixels)
44browser-use scroll up # Scroll up
45browser-use tab list # List all tabs with lock status
46browser-use tab new [url] # Open a new tab (blank or with URL)
47browser-use tab switch <index> # Switch to tab by index
48browser-use tab close <index> [index...] # Close one or more tabs
49
50# Page State — always run state first to get element indices
51browser-use state # URL, title, clickable elements with indices
52browser-use screenshot [path.png] # Screenshot (base64 if no path, --full for full page)
53
54# Interactions — use indices from state
55browser-use click <index> # Click element by index
56browser-use click <x> <y> # Click at pixel coordinates
57browser-use type "text" # Type into focused element
58browser-use input <index> "text" # Click element, then type
59browser-use keys "Enter" # Send keyboard keys (also "Control+a", etc.)
60browser-use select <index> "option" # Select dropdown option
61browser-use upload <index> <path> # Upload file to file input
62browser-use hover <index> # Hover over element
63browser-use dblclick <index> # Double-click element
64browser-use rightclick <index> # Right-click element
65
66# Data Extraction
67browser-use eval "js code" # Execute JavaScript, return result
68browser-use get title # Page title
69browser-use get html [--selector "h1"] # Page HTML (or scoped to selector)
70browser-use get text <index> # Element text content
71browser-use get value <index> # Input/textarea value
72browser-use get attributes <index> # Element attributes
73browser-use get bbox <index> # Bounding box (x, y, width, height)
74
75# Wait
76browser-use wait selector "css" # Wait for element (--state visible|hidden|attached|detached, --timeout ms)
77browser-use wait text "text" # Wait for text to appear
78
79# Cookies
80browser-use cookies get [--url <url>] # Get cookies (optionally filtered)
81browser-use cookies set <name> <value> # Set cookie (--domain, --secure, --http-only, --same-site, --expires)
82browser-use cookies clear [--url <url>] # Clear cookies
83browser-use cookies export <file> # Export to JSON
84browser-use cookies import <file> # Import from JSON
85
86# Python — persistent session with browser access
87browser-use python "code" # Execute Python (variables persist across calls)
88browser-use python --file script.py # Run file
89browser-use python --vars # Show defined variables
90browser-use python --reset # Clear namespace
91
92# Session
93browser-use close # Close browser and stop daemon
94browser-use sessions # List active sessions
95browser-use close --all # Close all sessions
96```
97
98The Python browser object provides: browser.url, browser.title, browser.html, browser.goto(url), browser.back(), browser.click(index), browser.type(text), browser.input(index, text), browser.keys(keys), browser.upload(index, path), browser.screenshot(path), browser.scroll(direction, amount), browser.wait(seconds).
99
100## Tunnels
101
102Expose local dev servers to the browser via Cloudflare tunnels.
103
104```bash
105browser-use tunnel <port> # Start tunnel (idempotent)
106browser-use tunnel list # Show active tunnels
107browser-use tunnel stop <port> # Stop tunnel
108browser-use tunnel stop --all # Stop all tunnels
109```
110
111## Command Chaining
112
113Commands can be chained with &&. The browser persists via the daemon, so chaining is safe and efficient.
114
115```bash
116browser-use open https://example.com && browser-use state
117browser-use input 5 "user@example.com" && browser-use input 6 "password" && browser-use click 7
118```
119
120Chain when you don't need intermediate output. Run separately when you need to parse state to discover indices first.
121
122## Common Workflows
123
124### Exposing Local Dev Servers
125
126```bash
127python -m http.server 3000 & # Start dev server
128browser-use tunnel 3000 # → https://abc.trycloudflare.com
129browser-use open https://abc.trycloudflare.com # Browse the tunnel
130```
131
132Tunnels are independent of browser sessions and persist across browser-use close.
133
134## Multi-Agent (--connect mode)
135
136Multiple agents can share one browser via --connect. Each agent gets its own tab — other agents can't interfere.
137
138**Setup**: Register once, then pass the index with every --connect command:
139
140```bash
141INDEX=$(browser-use register) # → prints "1"
142browser-use --connect $INDEX open <url> # Navigate in agent's own tab
143browser-use --connect $INDEX state # Get state from agent's tab
144browser-use --connect $INDEX click <element> # Click in agent's tab
145```
146
147- **Tab locking**: When an agent mutates a tab (click, type, navigate), that tab is locked to it. Other agents get an error if they try to mutate the same tab.
148- **Read-only access**: state, screenshot, get, and wait commands work on any tab regardless of locks.
149- **Agent sessions expire** after 5 minutes of inactivity. Run browser-use register again to get a new index.
150
151## Global Options
152
153| Option | Description |
154|--------|-------------|
155| --headed | Show browser window |
156| --connect | Auto-discover running Chrome via CDP |
157| --cdp-url <url> | Connect via CDP URL (http:// or ws://) |
158| --session NAME | Target a named session (default: "default") |
159| --json | Output as JSON |
160
161## Tips
162
1631. **Always run state first** to see available elements and their indices
1642. **Sessions persist** — browser stays open between commands until you close it
1653. **Tunnels are independent** — they persist across browser-use close
1664. **tunnel is idempotent** — calling again for the same port returns the existing URL
167
168## Troubleshooting
169
170- **Browser won't start?** browser-use close then retry. Run browser-use doctor to check.
171- **Element not found?** browser-use scroll down then browser-use state
172- **Tunnel not working?** which cloudflared to check, browser-use tunnel list to see active tunnels
173
174## Cleanup
175
176```bash
177browser-use close # Close browser session
178browser-use tunnel stop --all # Stop tunnels (if any)
179```
180
In the file
SKILL.md1,060 words
Files1
LicenceMIT
Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈80
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
1,970
on trigger
The instruction body, read only when the skill fires.
1.0%
of a 200k window
Ten skills this size would take about 10% of the window before you open a file.
050k100k150k200k context window

2k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Middling. Fine to keep on in a project where you use it weekly, worth unloading in one where you never do.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption
Installsnone yet
Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for
Writes filesno
Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

What is in the bundle

1 file, 8.2 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

  • SKILL.md8.2 kB
What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 1 file you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

# Browser Automation for Sandboxed Agents · 2k tokens when loaded npx mcprush@latest skill add browser-use/browser-automation-for-sandboxed-agents

Writes to .claude/skills/browser-automation-for-sandboxed-agents/ in the current project. Add --global to put it in your home directory instead, for every project.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/
Claude Desktop
ChatGPT
Cursor.cursor/skills/
VS Code.github/skills/
Codex CLI.agents/skills/
Gemini CLI.gemini/skills/
Grok.grok/skills/
Zed.agents/skills/
Windsurf.windsurf/skills/
Agent SDK.claude/skills/
HTTP / API
This release
Versionnot versioned
Publishedno release date on file
PriceFree
Referencebrowser-use/browser-automation-for-sandboxed-agents

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v
  • No earlier releases have been published to the marketplace.
Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

BR
browser-use

Publishes on mcprush.

0 servers listed2 skills listednot claimed
Profile
Publisher
Servers0
Claim this skill