# Browser Use Cloud

> Browser Use Cloud — anti-detect cloud browser with Playwright direct control (no LLM cost) and Agent mode (LLM-powered). Features: stealth browsing, 195+ country proxies, MP4 recording, screenshots, CAPTCHA bypass. Auto-registers for free API keys. Triggers: browser-use, cloud browser, stealth browser, anti-detect, screen recording, remote browser.

- **Type:** Skill
- **Install:** `agentstack add skill-yrzhe-claude-skills-browser-use-cloud`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Yrzhe](https://agentstack.voostack.com/s/yrzhe)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Yrzhe](https://github.com/Yrzhe)
- **Source:** https://github.com/Yrzhe/claude-skills/tree/main/plugins/browser-use-cloud/skills/browser-use-cloud

## Install

```sh
agentstack add skill-yrzhe-claude-skills-browser-use-cloud
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Browser Use Cloud

Anti-detect cloud browser platform. Provides AI agents with a controllable cloud Chrome instance featuring stealth fingerprinting, proxy rotation, and video recording.

## API Key — Auto-Registration (No Hardcoded Keys)

This skill does **not** store API keys. Instead, it auto-registers a fresh free account each time credits run out.

### How It Works

Browser Use allows AI agents to self-register via a challenge-response flow:

1. `POST /cloud/signup` — request a math challenge
2. Solve the obfuscated math problem using LLM reasoning (answer as `"xxx.xx"`)
3. `POST /cloud/signup/verify` — submit answer, receive `api_key`

Each free account gets ~$0.10 in credits (~100 Browser-mode sessions).

### Registration Flow

```bash
# Step 1: Request challenge
curl -s -X POST https://api.browser-use.com/cloud/signup \
  -H "Content-Type: application/json" \
  -d '{"name": "auto-agent"}'

# Returns: {"challenge_id": "xxx", "challenge_text": "...obfuscated math..."}
# The challenge contains symbol noise and CJK numerals (e.g. 삼=3, 오=5, 십=10, 구=9)

# Step 2: Solve with LLM — answer as string with 2 decimal places, e.g. "144.00"

# Step 3: Verify and get key
curl -s -X POST https://api.browser-use.com/cloud/signup/verify \
  -H "Content-Type: application/json" \
  -d '{"challenge_id": "xxx", "answer": "144.00"}'

# Returns: {"api_key": "bu_xxx"}
```

### When to Re-Register

When you see `402: You need at least $0.10 in credits`, the current key is exhausted. Run the registration flow above to get a fresh key.

### Cost-Saving Rules

1. **Always use Browser mode** (Playwright direct) — ~$0.001/session, no LLM cost
2. **Avoid Agent mode** — burns $0.05-0.10 per call (LLM inference)
3. **Always stop sessions** — `await client.browsers.stop(browser.id)`
4. **One free key lasts ~100 Browser-mode sessions**

---

## Two Modes

### 1. Browser Mode — Playwright Direct Control (Recommended, Cheapest)

You control the browser directly via Playwright/CDP. No LLM involved, no LLM cost.

```python
import asyncio, os
from browser_use_sdk.v3 import AsyncBrowserUse
from playwright.async_api import async_playwright

os.environ["BROWSER_USE_API_KEY"] = "YOUR_API_KEY"  # from auto-registration

async def main():
    client = AsyncBrowserUse()

    # Create cloud browser
    browser = await client.browsers.create(
        proxy_country_code="us",    # 195+ countries available
        enable_recording=True,      # MP4 video recording
        timeout=60,                 # minutes, max 240
    )
    print(f"Live view: {browser.live_url}")

    # Control with Playwright (zero LLM cost)
    async with async_playwright() as p:
        pw = await p.chromium.connect_over_cdp(browser.cdp_url)
        page = pw.contexts[0].pages[0]
        await page.goto("https://example.com")
        await page.screenshot(path="screenshot.png", full_page=True)
        title = await page.title()
        content = await page.evaluate("document.body.innerText")
        print(f"Title: {title}")
        await pw.close()

    # Stop and get recording
    stopped = await client.browsers.stop(browser.id)
    print(f"Recording: {stopped.recording_url}")  # MP4 URL, valid 1 hour
    print(f"Cost: ${stopped.browser_cost}")        # ~$0.001

asyncio.run(main())
```

### 2. Minimal Playwright via WebSocket (One-Liner)

```python
from playwright.async_api import async_playwright

WSS = "wss://connect.browser-use.com?apiKey=YOUR_API_KEY&proxyCountryCode=us"

async with async_playwright() as p:
    browser = await p.chromium.connect_over_cdp(WSS)
    page = browser.contexts[0].pages[0]
    await page.goto("https://example.com")
    await page.screenshot(path="shot.png")
    await browser.close()
```

### 3. Agent Mode — LLM-Powered Automation (Expensive, Use Sparingly)

The cloud LLM navigates autonomously. Useful for complex tasks but burns credits fast.

```python
os.environ["BROWSER_USE_API_KEY"] = "YOUR_API_KEY"

async def main():
    client = AsyncBrowserUse()
    result = await client.run(
        "Go to https://example.com and extract the main heading",
        model="gemini-3-flash",       # cheapest: $0.60/$3.60 per 1M tokens
        # model="claude-sonnet-4.6",  # recommended: $3.60/$18.00 per 1M tokens
        enable_recording=True,
    )
    print(result.output)
    print(f"Cost: ${result.session.total_cost_usd}")  # ~$0.03-0.10 per call

asyncio.run(main())
```

---

## Core Features

### Screenshots

```python
# Browser mode — Playwright screenshots (recommended)
await page.screenshot(path="full.png", full_page=True)

# Agent mode — auto-generated screenshot URL
print(result.session.screenshot_url)
```

### Video Recording (MP4)

```python
# Enable when creating browser
browser = await client.browsers.create(enable_recording=True)

# After stopping, get MP4 download URL (valid 1 hour)
stopped = await client.browsers.stop(browser.id)
print(stopped.recording_url)  # https://...s3...recording.mp4?...

# Download recording
import urllib.request
urllib.request.urlretrieve(stopped.recording_url, "recording.mp4")
```

Use cases: product demos, tutorial recordings, bug reproduction videos.

### Persistent Login (Profiles)

```python
# Create profile — saves cookies/localStorage
profile = await client.profiles.create(name="my-account")

# First login — complete 2FA manually via live_url
session = await client.sessions.create(profile_id=profile.id)
print(f"Login here: {session.live_url}")
# ... complete login manually ...
await client.sessions.stop(session.id)  # saves session state

# Future sessions — auto-logged-in
browser = await client.browsers.create(profile_id=profile.id)
```

### AgentMail (Built-in Email)

Each session gets a disposable email (e.g. `finehand661@mail.bu.app`) for signup verification and 2FA codes.

```python
result = await client.run("Sign up on example.com", agentmail=True)
print(result.session.agentmail_email)
```

### Structured Output

```python
from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float

class Products(BaseModel):
    items: list[Product]

result = await client.run(
    "Go to amazon.com, search 'keyboard', get top 5",
    output_schema=Products
)
```

### Cached Scripts (Pay Once, Rerun Free)

```python
# First call: agent explores and caches script (~$0.10, ~60s)
result = await client.run(
    "Get top @{{5}} stories from https://news.ycombinator.com as JSON",
    workspace_id=str(ws.id)
)

# Subsequent calls: cached execution ($0 LLM, ~5s)
result2 = await client.run(
    "Get top @{{10}} stories from https://news.ycombinator.com as JSON",
    workspace_id=str(ws.id)
)
```

---

## MCP Server Integration

Add to Claude Code for direct tool access:

```bash
claude mcp add -t http -s user \
  -H "x-browser-use-api-key: YOUR_API_KEY" \
  -- browser-use https://api.browser-use.com/v3/mcp
```

Available MCP tools:
- `run_session` — create and run a task
- `get_session` — check status and cost
- `send_task` — follow-up task to idle session
- `stop_session` — stop task or session
- `list_sessions` — list recent sessions

Update key when expired:
```bash
claude mcp remove browser-use
claude mcp add -t http -s user \
  -H "x-browser-use-api-key: NEW_KEY" \
  -- browser-use https://api.browser-use.com/v3/mcp
```

---

## Cost Comparison

| Mode | LLM | Browser | Total per Session | Free Key Sessions |
|------|-----|---------|-------------------|-------------------|
| Browser (Playwright) | $0 | ~$0.001 | **~$0.001** | **~100** |
| Agent (gemini-flash) | ~$0.03 | ~$0.001 | ~$0.03 | ~3 |
| Agent (sonnet) | ~$0.07 | ~$0.001 | ~$0.07 | ~1 |

## Use Cases

| Scenario | Recommended Approach |
|----------|---------------------|
| Screenshot a webpage | Browser mode + `page.screenshot()` |
| Record product demo / tutorial | Browser mode + `enable_recording=True` |
| Bypass Cloudflare / anti-bot | Browser mode + proxy |
| Access region-locked content | Browser mode + `proxy_country_code` |
| Auto-fill forms / login | Browser mode + Playwright |
| Complex multi-step scraping | Agent mode (but costs credits) |

## vs Local Browser Automation

| | Local (agent-browser / Playwright) | Browser Use Cloud |
|---|---|---|
| Runs on | Local machine | Cloud |
| Anti-detection | None | Cloudflare/CAPTCHA bypass |
| Proxy IPs | None | 195+ countries |
| Recording | None | MP4 video |
| Cost | Free | ~$0.001/session |
| Best for | Daily automation | Anti-bot, geo-access, demos |

## Installation

```bash
pip install browser-use-sdk playwright
python3 -m playwright install chromium
# or
npm install browser-use-sdk
```

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Yrzhe](https://github.com/Yrzhe)
- **Source:** [Yrzhe/claude-skills](https://github.com/Yrzhe/claude-skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-yrzhe-claude-skills-browser-use-cloud
- Seller: https://agentstack.voostack.com/s/yrzhe
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.