x402

Browser Use Cloud — pagar com x402 (carteira cripto)

Este é um fluxo roteirizado. Siga os passos em ordem. x402 só funciona através do SDK (browser-use-sdk para Python, o pacote browser-use npm para TS) — não há comando browser-use CLI para ele, então cada etapa executa um pequeno script SDK.

Como usar este roteiro

• Linhas sob Diga: são ditas ao usuário palavra por palavra. Não parafraseie, adicione nem remova nada.
• <assim> dentro de um bloco Diga é um preenchimento — substitua pelo valor real, mantenha o resto exato.
• Linhas sob Pergunte: usam a ferramenta AskUserQuestion. Use a pergunta e o texto das opções exatamente como escritos.
• Para mostrar uma explicação antes de uma pergunta, coloque-a dentro do campo question do AskUserQuestion (ela aparece acima das opções). Não a envie como texto separado no chat antes de chamar a ferramenta — esse texto é perdido quando a interface da pergunta abre. Portanto: explicação + a pergunta real vão no campo question, em uma única chamada de ferramenta.
• Linhas sob Faça: são suas ações. Não as leia em voz alta.
• Acompanhe dois fatos ao longo do processo: SETUP (A ou B, do Passo 1) e MODE (A ou B, do Passo 2).
• SETUP, MODE e os nomes Caminho A/B/C são rótulos internos só para você. Nunca os diga ao usuário. Descreva as escolhas em palavras simples (por exemplo, "recarregue sua conta" / "carteira sem conta"), nunca "Modo B" ou "Caminho A".

---

Passo 1 — Abrir e escolher a configuração

Pergunte: (cabeçalho: Usar x402) — coloque a explicação e a pergunta no campo question, exatamente:

x402 é um protocolo da Coinbase que, em vez de apresentar uma chave de API, permite que você use cripto para pagar por requisições de API. x402 permite pagar o Browser Use por requisição a partir de uma carteira cripto com USDC na Base — sem cadastro, chave de API ou cartão de crédito, apenas uma carteira. A configuração leva alguns minutos: obter ou criar uma carteira, adicionar fundos, salvar a chave no .env e testar.

Como você quer usar o x402?

• Só usar — Executar tarefas do Browser Use, pagas pela sua carteira, aqui no terminal ao me pedir. Eu configuro a carteira e a chave.
• Integrar no projeto — Você está codificando um app e quer o x402 nele. Vou ajudar a instalar o SDK, salvar a chave no .env do seu projeto e adicionar código.

Faça: "Só usar" → SETUP = A. "Integrar no projeto" → SETUP = B.

---

Passo 2 — Encontrar a conta (verifique antes de perguntar)

Faça: Procure por uma chave de API do Browser Use existente, nesta ordem. Não diga nada ainda.

1. BROWSER_USE_API_KEY no ambiente
2. uma linha BROWSER_USE_API_KEY= em ./.env
3. ~/.browser-use/config.json (salvo por browser-use cloud login / signup)
4. saída de browser-use doctor, se a CLI estiver instalada

Se nenhuma chave for encontrada:

Diga:

Nenhuma chave do Browser Use encontrada, então vou configurar isso sem conta: a carteira é sua identidade, e o primeiro pagamento cria um projeto com o nome dela.

Faça: MODE = A. Vá para o Passo 3.

Se uma chave for encontrada:

Pergunte: (cabeçalho: Conta) — pergunta: Encontrei uma chave de API do Browser Use em <local>. Para onde devem ir os créditos USDC?

• Recarregue essa conta — Os créditos vão para o projeto da sua chave de API existente. Bom se seus créditos gratuitos acabaram, ou se você prefere pagar com cripto em vez de cartão.
• Carteira sem conta — A carteira é uma identidade separada. O primeiro pagamento cria um novo projeto com o nome da carteira, separado da sua conta existente.

Faça: "Recarregue essa conta" → MODE = B. "Carteira sem conta" → MODE = A.

---

Passo 3 — Carteira

Pergunte: (cabeçalho: Carteira) — pergunta: Você tem uma carteira pronta, ou devo configurar uma?

• Tenho uma carteira com fundos — Uma carteira EVM (MetaMask, Rabby, Coinbase Wallet, Frame, Phantom, …) com USDC na Base mainnet.
• Me guie pelo processo — Vou orientar você a criar uma carteira, adicionar a Base e comprar USDC.
• Criar uma nova — Vou gerar uma carteira descartável para automação. Você ainda precisará financiá-la.

Ramo conforme a resposta.

Caminho A — "Tenho uma carteira com fundos"

Faça: Verifique se .env está em .gitignore; adicione se estiver faltando.

Pergunte: (cabeçalho: Adicionar chave) — coloque a observação e a pergunta no campo question:

A chave privada da sua carteira precisa ir para o .env. Você pode colá-la aqui e eu a adicionarei para você, ou adicioná-la você mesmo. Atenção: qualquer coisa colada no chat é salva no histórico da conversa, então para uma carteira de alto valor, adicionar você mesmo é um pouco mais seguro. Como você quer fazer?

• Colar aqui — Cole sua chave privada no chat e eu a escrevo no .env para você.
• Eu mesmo adiciono — Você adiciona ao .env e depois me envia apenas seu endereço público.

Se "Colar aqui":

Faça: Escreva BROWSER_USE_X402_PRIVATE_KEY=<chave colada> no .env (crie o arquivo se necessário; verifique se .env está no gitignore). Nunca ecoe a chave de volta nem a imprima em lugar nenhum.

Diga:

Salvei sua chave no .env — não vou imprimi-la de volta.

Faça: Vá para o Passo 4.

Se "Eu mesmo adiciono":

Diga:

Adicione esta linha ao seu .env e depois me envie o endereço público da sua carteira (o que começa com 0x… — seguro de compartilhar):

BROWSER_USE_X402_PRIVATE_KEY=<sua chave privada>

Faça: Quando eles enviarem o endereço, verifique se corresponde a ^0x[0-9a-fA-F]{40}$.

Diga:

Recebido: <endereço>. Esse é um endereço válido.

Faça: Vá para o Passo 4.

Caminho B — "Me guie pelo processo"

Diga:

1. Instale o MetaMask (ou Rabby, Coinbase Wallet, Frame, Trust Wallet, Phantom, …) apenas do site oficial: https://metamask.io. Crie uma carteira, salve a frase semente offline, defina uma senha.
2. Adicione a Base como rede. Acesse https://chainlist.org/chain/8453 → "Connect Wallet" → "Add to MetaMask", depois aprove na sua carteira.
3. Clique em "Comprar" na sua carteira. Escolha USDC, rede Base, pague com cartão / Apple Pay / banco. O USDC cai direto na sua carteira.
4. Obtenha a chave privada: menu da conta → Detalhes da conta → Mostrar chave privada → digite a senha → copie.
5. Adicione ao seu .env (verifique se .env está no gitignore):

BROWSER_USE_X402_PRIVATE_KEY=<sua chave privada>

6. Envie-me o endereço público da sua carteira (o que começa com 0x…) para eu verificar.

Faça: Em seguida, siga o Caminho A a partir da verificação do endereço.

Caminho C — "Criar uma nova"

Faça: Gere uma carteira. Salve a chave no .env. Mostre apenas o endereço.

Python:

pip install eth-account

from eth_account import Account
acc = Account.create()
print("Endereço:", acc.address)
print("Chave privada:", acc.key.hex())

TypeScript:

npm install viem

import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
const key = generatePrivateKey();
console.log("Endereço:", privateKeyToAccount(key).address);
console.log("Chave privada:", key);

Diga:

Carteira criada. Seu endereço público é <endereço>, e salvei a chave privada no .env. Agora precisa de fundos.

Faça: Vá para o Passo 4 (financiamento).

---

Passo 4 — Adicionar fundos

Se Caminho A ou B (já financiada):

Diga:

Sua carteira já tem fundos, então vamos pular para o teste.

Faça: Vá para o Passo 5.

Se Caminho C:

Diga:

Duas maneiras de colocar USDC na sua carteira na Base:

• Botão Comprar na carteira (mais fácil): clique em "Comprar", escolha USDC, defina a rede como Base, pague com cartão. Nenhuma exchange necessária.
• De uma exchange: envie USDC para <endereço> e escolha "Base" como rede — não Ethereum, que custa $5–$20 de taxas.

Adicione pelo menos $20: isso cobre o teste de $1 mais algumas tarefas reais. Vou monitorar o saldo e avisar quando cair.

Faça: Verifique o saldo on-chain a cada 5s com o RPC público da Base:

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

Leia result como um número hexadecimal; divida por 1_000_000 (USDC tem 6 casas decimais). Pare quando for $20 ou mais.

Diga:

Financiado — vejo $ na Base. Agora, um teste rápido.

---

Passo 5 — Teste (~$1)

Faça: Se SETUP = A, certifique-se de que o SDK está instalado onde você executará scripts (Python padrão). Se SETUP = B, instale-o no projeto na linguagem do projeto — descubra a linguagem pelo cwd (package.json/tsconfig.json → TypeScript; pyproject.toml/requirements.txt/*.py → Python; pergunte apenas se não conseguir identificar):

# Python (precisa de 3.10+ para o extra x402)
pip install "browser-use-sdk[x402]"
# TypeScript
npm install browser-use-sdk @x402/fetch @x402/evm viem

Pergunte: (cabeçalho: Teste) — pergunta: Pronto para testar? Isso gasta exatamente $1 USDC da sua carteira para verificar pagamento + execução de ponta a ponta.

• Usar a tarefa padrão — "Vá para example.com e me diga o texto do cabeçalho." (~5 segundos, barato)
• Vou dar uma tarefa — Diga uma tarefa curta para executar.
• Pular o teste — Pule o teste e vá direto para usar o x402.

Faça:

• "Vou dar uma tarefa" → Diga: Qual é a tarefa? Mantenha curta. Aguarde.
• "Pular o teste" → vá para o Passo 6.
• Caso contrário, use a tarefa padrão.

Faça: Execute o teste. Use o cliente x402 bruto com max_value de $1.50 para que ele pague $1, não os $5 que o SDK usa por padrão:

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 limita o gasto por requisição — escolhe a opção de $1 em vez do padrão $5.
    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": "<a tarefa>"},
        )
        print(resp.status_code, resp.json())

asyncio.run(main())

Se MODE = B, adicione o cabeçalho da chave de API, caso contrário o $1 vai para um novo projeto de carteira em vez da conta a ser recarregada:

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:
    ...

Se a biblioteca x402 instalada não tiver max_value, Diga: Essa versão do x402 não pode forçar uma cobrança de $1, então o teste custará $5. Quer que eu prossiga? — aguarde um sim antes de executar.

Diga:

Pago. Prova on-chain: https://basescan.org/address/<endereço>#tokentxns — procure uma transferência USDC de saída de exatamente $1.000000.

Faça: Leia o saldo. Se MODE = A (precisa de browser-use-sdk ≥ 3.8.0; se mais antigo, diga para executar pip install -U "browser-use-sdk[x402]" ou pule isso):

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())

Se MODE = B, pule get_wallet_balance (retorna 404 — os créditos ficam no projeto da chave de API, é normal, não mostre como erro) e leia da maneira normal:

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)

Diga:

Concluído. Seu saldo do Browser Use agora é $ (o teste custou cerca de $). As tarefas consomem deste saldo, e o SDK adiciona mais $5 quando acabar.

---

Passo 6 — Finalização

Se SETUP = A:

Diga:

Tudo pronto. Peça-me para executar qualquer tarefa de navegador e eu a executarei pelo SDK, pago pela sua carteira.

Faça: Quando pedirem uma tarefa, escreva um script descartável (em /tmp, ou um job em segundo plano para tarefas longas), execute-o, relate o resultado e o delete — não deixe arquivos no cwd. O SDK lê BROWSER_USE_X402_PRIVATE_KEY e encontra o endpoint x402 sozinho:

import asyncio, os
from browser_use_sdk.v3 import AsyncBrowserUse

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

asyncio.run(main())

Se SETUP = B:

Diga:

Tudo pronto. Aqui está o cliente para usar no seu código — ele lê a chave e o endpoint do seu .env:

Faça: Adicione o cliente na linguagem do projeto e aponte para a skill cloud / documentação do SDK para o restante:

from browser_use_sdk.v3 import AsyncBrowserUse

client = AsyncBrowserUse()                                  # Modo A (sem conta)
# client = AsyncBrowserUse(api_key="bu_...")                # Modo B (recarregar conta existente)

(x402 precisa do cliente async — o BrowserUse síncrono não funciona quando a variável de ambiente x402 está configurada.)

---

Equivalentes TypeScript

Python	TypeScript
from browser_use_sdk.v3 import AsyncBrowserUse	import { BrowserUse } from "browser-use-sdk/v3"
AsyncBrowserUse()	new BrowserUse()
await client.run(task=...) → .output	await client.run({ task }) → .output
get_wallet_balance(key)	getWalletBalance(key) (from "browser-use-sdk/v3")
pip install "browser-use-sdk[x402]"	npm install browser-use-sdk @x402/fetch @x402/evm viem

Ambos SDKs leem BROWSER_USE_X402_PRIVATE_KEY do ambiente.

Regras

• Siga o roteiro em ordem. Diga os blocos Diga palavra por palavra.
• Nunca gaste os USDC do usuário sem um sim claro (a pergunta do Passo 5 é esse sim).
• Sempre ofereça ambas as formas de adicionar a chave: colar no chat (você escreve no .env) ou o usuário adicionar sozinho. Se colarem, escreva diretamente no .env e nunca ecoe de volta nem armazene em outro lugar.
• Adicione .env ao .gitignore antes de salvar chaves.
• Carteiras guardam dinheiro real. Mantenha chaves fora de controle de versão, logs e capturas de tela; adicione apenas o que puder perder se vazar.

Referência

• Documentação do usuário x402: https://docs

…

[truncado para tradução]