x402

What this skill does

# Browser Use Cloud — pay with x402 (crypto wallet)

This is a scripted flow. Follow the steps in order. x402 only works through the **SDK** (`browser-use-sdk` for Python, the `browser-use` npm package for TS) — there is no `browser-use` CLI command for it, so every step runs a short SDK script.

## How to use this script

- Lines under **Say:** are spoken to the user **word for word.** Don't paraphrase, add, or drop anything.
- `<like this>` inside a Say block is a fill-in — replace it with the real value, keep the rest exact.
- Lines under **Ask:** use the AskUserQuestion tool. Use the question and option text exactly as written.
- **To show an explanation before a question, put it inside the AskUserQuestion `question` field** (it renders above the options). Don't send it as separate chat text before calling the tool — that text gets dropped when the question UI opens. So: explanation + the actual question both go in the `question` field, in one tool call.
- Lines under **Do:** are your actions. Don't read them out.
- Track two facts as you go: `SETUP` (A or B, from Step 1) and `MODE` (A or B, from Step 2).
- **`SETUP`, `MODE`, and the Path A/B/C names are internal labels for you only. Never say them to the user.** Describe choices in plain words instead (e.g. "top up your account" / "accountless wallet"), never "Mode B" or "Path A".

---

## Step 1 — Open and pick the setup

**Ask:** (header: `Use x402`) — put the explanation and the question both in the `question` field, exactly:

> x402 is a protocol from Coinbase that, instead of presenting an API key, allows you to use crypto to pay for API requests. x402 lets you pay Browser Use per request from a crypto wallet with USDC on Base — no signup, API key, or credit card needed, just a wallet. Setup takes a few minutes: get or make a wallet, add funds, save the key in `.env`, and test it.
>
> How do you want to use x402?
- **Just use it** — Run Browser Use tasks, paid from your wallet, here in terminal by asking me. I set up the wallet and key.
- **Build it in** — You're coding an app and want x402 in it. I will help you install the SDK, save the key to your project's `.env`, and add code.

**Do:** "Just use it" → `SETUP = A`. "Build it in" → `SETUP = B`.

---

## Step 2 — Find the account (check before asking)

**Do:** Look for an existing Browser Use API key, in this order. Don't say anything yet.
1. `BROWSER_USE_API_KEY` in the environment
2. a `BROWSER_USE_API_KEY=` line in `./.env`
3. `~/.browser-use/config.json` (saved by `browser-use cloud login` / `signup`)
4. `browser-use doctor` output, if the CLI is installed

**If no key is found anywhere:**

**Say:**
> No Browser Use key found, so I'll set this up accountless: the wallet is your identity, and the first payment makes a project named after it.

**Do:** `MODE = A`. Go to Step 3.

**If a key is found:**

**Ask:** (header: `Account`) — question: `I found a Browser Use API key in <location>. Where should the USDC credits go?`
- **Top up that account** — Credits go to your existing API key's project. Good if your free credits ran out, or you'd rather pay with crypto than a card.
- **Accountless wallet** — The wallet is a separate identity. The first payment makes a fresh project named after the wallet, apart from your existing account.

**Do:** "Top up that account" → `MODE = B`. "Accountless wallet" → `MODE = A`.

---

## Step 3 — Wallet

**Ask:** (header: `Wallet`) — question: `Do you have a wallet ready, or should I set one up?`
- **I have a funded wallet** — An EVM wallet (MetaMask, Rabby, Coinbase Wallet, Frame, Phantom, …) with USDC on Base mainnet.
- **Walk me through it** — I'll guide you through making a wallet, adding Base, and buying USDC.
- **Make a fresh one** — I'll generate a throwaway wallet for automation. You'll still need to fund it.

Branch on the answer.

### Path A — "I have a funded wallet"

**Do:** Check `.env` is in `.gitignore`; add it if missing.

**Ask:** (header: `Add key`) — put the note and the question both in the `question` field:
> Your wallet's private key needs to go into `.env`. You can paste it here and I'll add it for you, or add it yourself. Heads up: anything pasted in chat is saved in the transcript, so for a high-value wallet, adding it yourself is a bit safer. How do you want to do it?

- **Paste it here** — Paste your private key in the chat and I'll write it to `.env` for you.
- **I'll add it myself** — You add it to `.env`, then send me just your public address.

**If "Paste it here":**

**Do:** Write `BROWSER_USE_X402_PRIVATE_KEY=<pasted key>` to `.env` (create the file if needed; make sure `.env` is gitignored). Never echo the key back or print it anywhere.

**Say:**
> Saved your key to `.env` — I won't print it back.

**Do:** Go to Step 4.

**If "I'll add it myself":**

**Say:**
> Add this line to your `.env`, then send me your wallet's public address (the `0x…` one — safe to share):
> ```
> BROWSER_USE_X402_PRIVATE_KEY=<your private key>
> ```

**Do:** When they send the address, check it matches `^0x[0-9a-fA-F]{40}$`.

**Say:**
> Got it: `<address>`. That's a valid address.

**Do:** Go to Step 4.

### Path B — "Walk me through it"

**Say:**
> 1. Install MetaMask (or Rabby, Coinbase Wallet, Frame, Trust Wallet, Phantom, …) from the official site only: https://metamask.io. Make a wallet, save the seed phrase offline, set a password.
> 2. Add Base as a network. Open https://chainlist.org/chain/8453 → "Connect Wallet" → "Add to MetaMask", then approve it in your wallet.
> 3. Click "Buy" in your wallet. Pick USDC, network Base, pay with card / Apple Pay / bank. The USDC lands straight in your wallet.
> 4. Get the private key: account menu → Account details → Show private key → enter password → copy.
> 5. Add it to your `.env` (make sure `.env` is gitignored):
> ```
> BROWSER_USE_X402_PRIVATE_KEY=<your private key>
> ```
> 6. Send me your wallet's public address (the `0x…` one) so I can check it.

**Do:** Then follow Path A from the address check onward.

### Path C — "Make a fresh one"

**Do:** Generate a wallet. Save the key to `.env`. Show the address only.

Python:
```bash
pip install eth-account
```
```python
from eth_account import Account
acc = Account.create()
print("Address:", acc.address)
print("Private key:", acc.key.hex())
```

TypeScript:
```bash
npm install viem
```
```typescript
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
const key = generatePrivateKey();
console.log("Address:", privateKeyToAccount(key).address);
console.log("Private key:", key);
```

**Say:**
> Made a fresh wallet. Your public address is `<address>`, and I've saved the private key to `.env`. Now it needs funds.

**Do:** Go to Step 4 (funding).

---

## Step 4 — Add funds

**If Path A or B (already funded):**

**Say:**
> Your wallet's already funded, so we'll skip ahead to the test.

**Do:** Go to Step 5.

**If Path C:**

**Say:**
> Two ways to get USDC into your wallet on Base:
> - In-wallet Buy button (easiest): click "Buy", pick USDC, set the network to Base, pay with a card. No exchange needed.
> - From an exchange: send USDC to `<address>` and pick "Base" as the network — not Ethereum, which costs $5–$20 in fees.
>
> Add at least $20: that covers the $1 test plus a few real tasks. I'll watch the balance and tell you when it lands.

**Do:** Check the on-chain balance every 5s with Base's public RPC:
```bash
PADDED=$(printf "%064s" "${WALLET_ADDR:2}" | tr ' ' '0')
curl -s https://mainnet.base.org \
  -H "Content-Type: application/json" \
  -d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_call\",\"params\":[{\"to\":\"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913\",\"data\":\"0x70a08231${PADDED}\"},\"latest\"],\"id\":1}"
```
Read `result` as a hex number; divide by `1_000_000` (USDC has 6 decimals). Stop once it's $20 or more.

**Say:**
> Funded — I see $<amount> on Base. Next, a quick test.

---

## Step 5 — Test run (~$1)

**Do:** If `SETUP = A`, make sure the SDK is installed where you'll r