Browser Use Cloud — mit x402 bezahlen (Krypto-Wallet)

Dies ist ein skriptgesteuerter Ablauf. Folge den Schritten der Reihe nach. x402 funktioniert nur über das SDK (browser-use-sdk für Python, das browser-use npm-Paket für TS) – es gibt keinen browser-use CLI-Befehl dafür, daher wird jeder Schritt mit einem kurzen SDK-Skript ausgeführt.

So verwendest du dieses Skript

Zeilen unter Sag: werden dem Benutzer wortwörtlich gesagt. Paraphrasiere nichts, füge nichts hinzu und lass nichts weg.
<wie dies> innerhalb eines Sag-Blocks ist ein Platzhalter – ersetze ihn mit dem tatsächlichen Wert, der Rest bleibt exakt.
Zeilen unter Frage: verwenden das AskUserQuestion-Tool. Verwende die Frage und den Optionstext genau wie geschrieben.
Um vor einer Frage eine Erklärung zu zeigen, setze sie in das question-Feld von AskUserQuestion (es wird über den Optionen angezeigt). Sende sie nicht als separaten Chat-Text vor dem Aufruf des Tools – dieser Text wird verworfen, wenn die Frage-UI geöffnet wird. Also: Erklärung + die eigentliche Frage kommen beide in das question-Feld, in einem einzigen Tool-Aufruf.
Zeilen unter Tu: sind deine Aktionen. Lies sie nicht vor.
Verfolge zwei Fakten während des Ablaufs: SETUP (A oder B, aus Schritt 1) und MODE (A oder B, aus Schritt 2).
SETUP, MODE und die Pfadnamen A/B/C sind interne Bezeichnungen nur für dich. Nenne sie niemals dem Benutzer. Beschreibe Entscheidungen stattdessen in einfachen Worten (z. B. „Konto aufladen“ / „Wallet ohne Konto“), niemals „Modus B“ oder „Pfad A“.

Schritt 1 — Öffnen und Setup auswählen

Frage: (Kopfzeile: x402 verwenden) – setze die Erklärung und die Frage beide in das question-Feld, exakt:

x402 ist ein Protokoll von Coinbase, das anstelle eines API-Schlüssels die Nutzung von Krypto zur Bezahlung von API-Anfragen ermöglicht. x402 lässt dich Browser Use pro Anfrage aus einer Krypto-Wallet mit USDC auf Base bezahlen – keine Anmeldung, kein API-Schlüssel, keine Kreditkarte nötig, nur eine Wallet. Die Einrichtung dauert ein paar Minuten: Wallet erstellen oder vorhandene nutzen, Geld einzahlen, den Schlüssel in .env speichern und testen.

Wie möchtest du x402 verwenden?

Einfach nutzen – Führe Browser-Use-Aufgaben aus, bezahlt aus deiner Wallet, hier im Terminal, indem du mich fragst. Ich richte die Wallet und den Schlüssel ein.
Einbauen – Du programmierst eine App und möchtest x402 darin verwenden. Ich helfe dir, das SDK zu installieren, den Schlüssel in deinem Projekt-.env zu speichern und Code hinzuzufügen.

Tu: „Einfach nutzen“ → SETUP = A. „Einbauen“ → SETUP = B.

Schritt 2 — Konto finden (vor dem Fragen prüfen)

Tu: Suche nach einem vorhandenen Browser Use API-Schlüssel, in dieser Reihenfolge. Sage noch nichts.

BROWSER_USE_API_KEY in der Umgebung
eine BROWSER_USE_API_KEY=-Zeile in ./.env
~/.browser-use/config.json (gespeichert durch browser-use cloud login / signup)
browser-use doctor-Ausgabe, falls die CLI installiert ist

Wenn kein Schlüssel gefunden wird:

Sag:

Kein Browser Use-Schlüssel gefunden, daher richte ich das ohne Konto ein: Die Wallet ist deine Identität, und die erste Zahlung erstellt ein nach ihr benanntes Projekt.

Tu: MODE = A. Gehe zu Schritt 3.

Wenn ein Schlüssel gefunden wird:

Frage: (Kopfzeile: Konto) – Frage: Ich habe einen Browser Use API-Schlüssel in <Ort> gefunden. Wohin sollen die USDC-Guthaben gehen?

Dieses Konto aufladen – Guthaben gehen zum Projekt deines vorhandenen API-Schlüssels. Gut, wenn dein kostenloses Guthaben aufgebraucht ist oder du lieber mit Krypto als mit Karte bezahlen möchtest.
Wallet ohne Konto – Die Wallet ist eine separate Identität. Die erste Zahlung erstellt ein neues Projekt, benannt nach der Wallet, getrennt von deinem vorhandenen Konto.

Tu: „Dieses Konto aufladen“ → MODE = B. „Wallet ohne Konto“ → MODE = A.

Schritt 3 — Wallet

Frage: (Kopfzeile: Wallet) – Frage: Hast du eine bereite Wallet, oder soll ich eine einrichten?

Ich habe eine finanzierte Wallet – Eine EVM-Wallet (MetaMask, Rabby, Coinbase Wallet, Frame, Phantom, …) mit USDC auf Base Mainnet.
Führe mich durch – Ich leite dich durch die Erstellung einer Wallet, das Hinzufügen von Base und den Kauf von USDC.
Eine neue erstellen – Ich generiere eine Wegwerf-Wallet für die Automatisierung. Du musst sie noch finanzieren.

Verzweige je nach Antwort.

Pfad A — „Ich habe eine finanzierte Wallet“

Tu: Prüfe, ob .env in .gitignore ist; füge es hinzu, falls es fehlt.

Frage: (Kopfzeile: Schlüssel hinzufügen) – setze den Hinweis und die Frage beide in das question-Feld:

Der private Schlüssel deiner Wallet muss in .env. Du kannst ihn hier einfügen und ich füge ihn für dich hinzu, oder du fügst ihn selbst hinzu. Achtung: Alles, was im Chat eingefügt wird, wird im Transkript gespeichert. Für eine wertvolle Wallet ist es daher etwas sicherer, ihn selbst hinzuzufügen. Wie möchtest du vorgehen?

Hier einfügen – Füge deinen privaten Schlüssel im Chat ein und ich schreibe ihn für dich in .env.
Ich füge ihn selbst hinzu – Du fügst ihn zu .env hinzu und sendest mir dann nur deine öffentliche Adresse.

Wenn „Hier einfügen“:

Tu: Schreibe BROWSER_USE_X402_PRIVATE_KEY=<eingefügter Schlüssel> in .env (erstelle die Datei bei Bedarf; stelle sicher, dass .env gitignored ist). Gib den Schlüssel niemals zurück oder drucke ihn irgendwo aus.

Sag:

Deinen Schlüssel in .env gespeichert – ich werde ihn nicht zurückgeben.

Tu: Gehe zu Schritt 4.

Wenn „Ich füge ihn selbst hinzu“:

Sag:

Füge diese Zeile zu deiner .env hinzu und sende mir dann die öffentliche Adresse deiner Wallet (die 0x…-Adresse – sicher zu teilen):
BROWSER_USE_X402_PRIVATE_KEY=<dein privater Schlüssel>

Tu: Wenn sie die Adresse senden, überprüfe, ob sie ^0x[0-9a-fA-F]{40}$ entspricht.

Sag:

Erhalten: <Adresse>. Das ist eine gültige Adresse.

Tu: Gehe zu Schritt 4.

Pfad B — „Führe mich durch“

Sag:

Installiere MetaMask (oder Rabby, Coinbase Wallet, Frame, Trust Wallet, Phantom, …) nur von der offiziellen Seite: https://metamask.io. Erstelle eine Wallet, speichere die Seed-Phrase offline, setze ein Passwort.

Füge Base als Netzwerk hinzu. Öffne https://chainlist.org/chain/8453 → „Connect Wallet“ → „Add to MetaMask“, bestätige dann in deiner Wallet.

Klicke in deiner Wallet auf „Kaufen“. Wähle USDC, Netzwerk Base, bezahle mit Karte / Apple Pay / Bank. Das USDC landet direkt in deiner Wallet.

Hole den privaten Schlüssel: Kontomenü → Kontodetails → Privaten Schlüssel anzeigen → Passwort eingeben → kopieren.

Füge ihn zu deiner .env hinzu (stelle sicher, dass .env gitignored ist):
BROWSER_USE_X402_PRIVATE_KEY=<dein privater Schlüssel>
Sende mir die öffentliche Adresse deiner Wallet (die 0x…-Adresse), damit ich sie überprüfen kann.

Tu: Folge dann Pfad A ab der Adressüberprüfung.

Pfad C — „Eine neue erstellen“

Tu: Generiere eine Wallet. Speichere den Schlüssel in .env. Zeige nur die Adresse an.

Python:

pip install eth-account

from eth_account import Account
acc = Account.create()
print("Adresse:", acc.address)
print("Privater Schlüssel:", acc.key.hex())

TypeScript:

npm install viem

import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
const key = generatePrivateKey();
console.log("Adresse:", privateKeyToAccount(key).address);
console.log("Privater Schlüssel:", key);

Sag:

Neue Wallet erstellt. Deine öffentliche Adresse ist <Adresse>, und ich habe den privaten Schlüssel in .env gespeichert. Jetzt braucht sie Guthaben.

Tu: Gehe zu Schritt 4 (Finanzierung).

Schritt 4 — Guthaben hinzufügen

Wenn Pfad A oder B (bereits finanziert):

Sag:

Deine Wallet ist bereits finanziert, daher überspringen wir den Test.

Tu: Gehe zu Schritt 5.

Wenn Pfad C:

Sag:

Zwei Wege, um USDC in deine Wallet auf Base zu bekommen:

Kaufen-Button in der Wallet (am einfachsten): Klicke auf „Kaufen“, wähle USDC, stelle das Netzwerk auf Base, bezahle mit einer Karte. Keine Börse nötig.

Von einer Börse: Sende USDC an <Adresse> und wähle „Base“ als Netzwerk – nicht Ethereum, das $5–$20 an Gebühren kostet.

Füge mindestens 20 $ hinzu: das deckt den 1-$-Test plus ein paar echte Aufgaben ab. Ich überwache den Kontostand und sage dir, wann es da ist.

Tu: Überprüfe den On-Chain-Kontostand alle 5 s mit dem öffentlichen RPC von 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}"

Lies result als Hex-Zahl; teile durch 1_000_000 (USDC hat 6 Dezimalstellen). Stoppe, sobald es 20 $ oder mehr sind.

Sag:

Finanziert – ich sehe $ auf Base. Als nächstes ein kurzer Test.

Schritt 5 — Testlauf (~1 $)

Tu: Wenn SETUP = A, stelle sicher, dass das SDK dort installiert ist, wo du Skripte ausführen wirst (Standard Python). Wenn SETUP = B, installiere es in das Projekt in der Sprache des Projekts – ermittle die Sprache aus dem cwd (package.json/tsconfig.json → TypeScript; pyproject.toml/requirements.txt/*.py → Python; frage nur, wenn du es nicht erkennen kannst):

# Python (benötigt 3.10+ für das x402-Extra)
pip install "browser-use-sdk[x402]"
# TypeScript
npm install browser-use-sdk @x402/fetch @x402/evm viem

Frage: (Kopfzeile: Testlauf) – Frage: Bereit zum Testen? Dies gibt genau 1 $ USDC aus deiner Wallet aus, um Zahlung + Arbeit Ende-zu-Ende zu überprüfen.

Standardaufgabe verwenden – „Gehe zu example.com und sage mir den Kopfzeilentext.“ (~5 Sekunden, günstig)
Ich gebe dir eine Aufgabe – Sag mir stattdessen eine kurze Aufgabe, die ausgeführt werden soll.
Test überspringen – Überspringe den Test und gehe direkt zur Verwendung von x402.

Tu:

„Ich gebe dir eine Aufgabe“ → Sag: Was ist die Aufgabe? Halte sie kurz. Warte darauf.
„Test überspringen“ → gehe zu Schritt 6.
Andernfalls verwende die Standardaufgabe.

Tu: Führe den Test aus. Verwende den rohen x402-Client mit max_value von 1,50 $, damit er 1 $ bezahlt, nicht die 5 $, die das SDK standardmäßig verwendet:

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 begrenzt die Ausgabe pro Anfrage – wählt die 1-$-Option über die Standard-5-$-Option.
    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": "<die Aufgabe>"},
        )
        print(resp.status_code, resp.json())

asyncio.run(main())

Wenn MODE = B, füge den API-Schlüssel-Header hinzu, sonst geht der 1-$-Betrag zu einem neuen Wallet-Projekt statt zu dem, das aufgeladen wird:

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

Wenn die installierte x402-Bibliothek kein max_value hat, Sag: Diese x402-Version kann keine 1-$-Gebühr erzwingen, daher kostet der Test stattdessen 5 $. Möchtest du fortfahren? – warte auf ein Ja, bevor du ausführst.

Sag:

Bezahlt. On-Chain-Nachweis: https://basescan.org/address/#tokentxns – suche eine USDC-Überweisung von genau 1,000000 $.

Tu: Lese den Kontostand. Wenn MODE = A (benötigt browser-use-sdk ≥ 3.8.0; wenn älter, sage, pip install -U "browser-use-sdk[x402]" auszuführen oder überspringe dies):

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

Wenn MODE = B, überspringe get_wallet_balance (es gibt 404 zurück – das Guthaben liegt im Projekt des API-Schlüssels, das ist normal, zeige es nicht als Fehler an) und lies es auf normale Weise:

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)

Sag:

Fertig. Dein Browser-Use-Kontostand beträgt jetzt $ (der Test hat etwa $ gekostet). Aufgaben zehren davon, und das SDK fügt weitere 5 $ hinzu, wenn es aufgebraucht ist.

Schritt 6 — Abschluss

Wenn SETUP = A:

Sag:

Alles bereit. Frage mich nach einer beliebigen Browser-Aufgabe, und ich führe sie über das SDK aus, bezahlt aus deiner Wallet.

Tu: Wenn sie nach einer Aufgabe fragen, schreibe ein temporäres Skript (in /tmp oder als Hintergrundjob für lange Aufgaben), führe es aus, berichte das Ergebnis und lösche es – hinterlasse keine Dateien in ihrem cwd. Das SDK liest BROWSER_USE_X402_PRIVATE_KEY und findet den x402-Endpunkt selbstständig:

import asyncio, os
from browser_use_sdk.v3 import AsyncBrowserUse

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

asyncio.run(main())

Wenn SETUP = B:

Sag:

Alles bereit. Hier ist der Client, den du in deinem Code verwenden kannst – er liest den Schlüssel und den Endpunkt aus deiner .env:

Tu: Füge den Client in der Sprache des Projekts hinzu und verweise sie für den Rest auf das cloud-Skill / die SDK-Dokumentation:

from browser_use_sdk.v3 import AsyncBrowserUse

client = AsyncBrowserUse()                                  # Modus A (ohne Konto)
# client = AsyncBrowserUse(api_key="bu_...")                # Modus B (vorhandenes Konto aufladen)

(x402 benötigt den async-Client – der synchrone BrowserUse funktioniert nicht, wenn die x402-Umgebungsvariable gesetzt ist.)

TypeScript-Äquivalente

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`

Beide SDKs lesen BROWSER_USE_X402_PRIVATE_KEY aus der Umgebung.

Regeln

Befolge das Skript der Reihe nach. Sage die Sag-Blöcke wortwörtlich.
Gib niemals das USDC des Benutzers ohne ein klares Ja aus (die Frage in Schritt 5 ist dieses Ja).
Biete immer beide Wege zum Hinzufügen des Schlüssels an: im Chat einfügen (du schreibst ihn in .env) oder der Benutzer fügt ihn selbst hinzu. Wenn sie ihn einfügen, schreibe ihn direkt in .env und gib ihn niemals zurück oder speichere ihn woanders.
Füge .env zu .gitignore hinzu, bevor du Schlüssel speicherst.
Wallets enthalten echtes Geld. Halte Schlüssel aus Quellcode, Logs und Screenshots fern; füge nur hinzu, was du dir leisten kannst zu verlieren, falls es durchsickert.

Referenz

x402-Benutzerdokumentation: https://docs

x402

Was ist x402?

In Ihrer bevorzugten KI fragen

Dokumentation

Browser Use Cloud — mit x402 bezahlen (Krypto-Wallet)

So verwendest du dieses Skript

Schritt 1 — Öffnen und Setup auswählen

Schritt 2 — Konto finden (vor dem Fragen prüfen)

Schritt 3 — Wallet

Pfad A — „Ich habe eine finanzierte Wallet“

Pfad B — „Führe mich durch“

Pfad C — „Eine neue erstellen“

Schritt 4 — Guthaben hinzufügen

Schritt 5 — Testlauf (~1 $)

Schritt 6 — Abschluss

TypeScript-Äquivalente

Regeln

Referenz

Individual skills in this repo

browser-use

browser-use/cloud

browser-use/open-source

browser-use/remote-browser

Verwandte Skills

steipete/bluebubbles

steipete/eightctl

steipete/blucli

steipete/bear-notes

steipete/camsnap

steipete/gifgrep