• 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".

Use x402

question

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.

SETUP = A

SETUP = B

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

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.

MODE = A

Account

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.

MODE = B

MODE = A

Wallet

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.

.env

.gitignore

Add key

question

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.

BROWSER_USE_X402_PRIVATE_KEY=<pasted key>

.env

.env

Saved your key to

.env

— I won't print it back.

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>

^0x[0-9a-fA-F]{40}$

Got it:

<address>

. That's a valid address.

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>

1. Send me your wallet's public address (the

   0x…

   one) so I can check it.

.env

pip install eth-account

from eth_account import Account
acc = Account.create()
print("Address:", acc.address)
print("Private key:", acc.key.hex())

npm install viem

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

Made a fresh wallet. Your public address is

<address>

, and I've saved the private key to

.env

. Now it needs funds.

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

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.

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}"

result

1_000_000

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

**Ask:** (header: `Test run`) — question: `Ready to test? This spends exactly $1 USDC from your wallet to check payment + run work end to end.`
- **Use the default task** — "Go to example.com and tell me the heading text." (~5 seconds, cheap)
- **I'll give you a task** — Tell me a short task to run instead.
- **Skip the test** — Skip the test and go straight to using x402.

**Do:**
- "I'll give you a task" → **Say:** `What's the task? Keep it short.` Wait for it.
- "Skip the test" → go to Step 6.
- Otherwise use the default task.

**Do:** Run the test. Use the raw x402 client with `max_value` of $1.50 so it pays $1, not the $5 the SDK uses by default:
```python
import asyncio, os
from decimal import Decimal
from x402 import x402Client
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client
from eth_account import Account

async def main():
    client = x402Client()
    register_exact_evm_client(
        client,
        EthAccountSigner(Account.from_key(os.environ["BROWSER_USE_X402_PRIVATE_KEY"])),
    )
    # max_value caps the spend per request — picks the $1 option over the $5 default.
    async with x402HttpxClient(client, max_value=Decimal("1.5"), timeout=180.0) as http:
        resp = await http.post(
            "https://x402.api.browser-use.com/api/v3/sessions",
            json={"task": "<the task>"},
        )
        print(resp.status_code, resp.json())

asyncio.run(main())

MODE = B

async with x402HttpxClient(
    client, max_value=Decimal("1.5"), timeout=180.0,
    headers={"X-Browser-Use-API-Key": os.environ["BROWSER_USE_API_KEY"]},
) as http:
    ...

x402

max_value

That x402 version can't force a $1 charge, so the test will cost $5 instead. Want me to go ahead?

Paid. On-chain proof: https://basescan.org/address/<address>#tokentxns — look for a USDC transfer out of exactly $1.000000.

MODE = A

browser-use-sdk

pip install -U "browser-use-sdk[x402]"

import asyncio, os
from browser_use_sdk.v3 import get_wallet_balance

async def main():
    bal = await get_wallet_balance(os.environ["BROWSER_USE_X402_PRIVATE_KEY"])
    print(bal['total_credits_usd'])

asyncio.run(main())

MODE = B

get_wallet_balance

from browser_use_sdk.v3 import AsyncBrowserUse
client = AsyncBrowserUse(api_key=os.environ["BROWSER_USE_API_KEY"])
acct = await client.billing.account()
print(acct.total_credits_balance_usd)

Done. Your Browser Use balance is now $<balance> (the test cost about $<cost>). Tasks draw from this, and the SDK adds another $5 when it runs out.

SETUP = A

All set. Ask me to run any browser task and I'll run it through the SDK, paid from your wallet.

/tmp

BROWSER_USE_X402_PRIVATE_KEY

import asyncio, os
from browser_use_sdk.v3 import AsyncBrowserUse

async def main():
    client = AsyncBrowserUse()  # Mode B: AsyncBrowserUse(api_key=os.environ["BROWSER_USE_API_KEY"])
    result = await client.run(task="<the task>")
    print(result.output)

asyncio.run(main())

SETUP = B

All set. Here's the client to use in your code — it reads the key and endpoint from your

.env

:

cloud

from browser_use_sdk.v3 import AsyncBrowserUse

client = AsyncBrowserUse()                                  # Mode A (accountless)

• Follow the script in order. Say the Say blocks word for word.
• Never spend the user's USDC without a clear yes (the Step 5 question is that yes).
• Always offer both ways to add the key: paste it in chat (you write it to

  .env

  ) or the user adds it themselves. If they paste it, write it straight to

  .env

  and never echo it back or store it anywhere else.
• Add

  .env

  to

  .gitignore

  before saving keys.
• Wallets hold real money. Keep keys out of source control, logs, and screenshots; only add what you can afford to lose if it leaks.

• x402 user docs: https://docs.browser-use.com/cloud/guides/x402
• Claude Code + Browser Use Cloud: https://docs.browser-use.com/cloud/tutorials/integrations/claude-code
• x402 protocol: https://www.x402.org
• USDC on Base contract:

  0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913

• Base RPC: https://mainnet.base.org · Basescan: https://basescan.org