Browser Use

import os, httpx

BU = httpx.AsyncClient(
    base_url="https://api.browser-use.com/api/v4",
    headers={"X-Browser-Use-API-Key": os.environ["BROWSER_USE_API_KEY"]},
)

browser_session = (await BU.post("/browsers", json={"proxyCountryCode": "us"})).json()
# For an agent run's browser: (await BU.get(f"/browsers/{browser_id}")).json()
cdp_url = browser_session["cdpUrl"]

# Your agent shops and stops at the payment step.

import asyncio

NATURAL = httpx.AsyncClient(
    base_url="https://api.natural.com",
    headers={"Authorization": f"Bearer {os.environ['NATURAL_API_KEY']}", "X-Instance-ID": instance_id},
)

async def natural(method, path, **kwargs):
    response = await NATURAL.request(method, path, **kwargs)
    response.raise_for_status()
    return response.json()

session = await natural(
    "POST",
    "/card-sessions",
    headers={"Idempotency-Key": f"card-session-{task_id}"},
    json={
        "data": {
            "attributes": {
                "cardId": card_id,  # eac_* from GET /card-external-accounts
                "allowedHosts": ["api.stripe.com"],
                "purchase": {"merchantName": "Acme Store", "amount": 4999, "currency": "USD"},
                "reference": task_id,
            }
        }
    },
)
if session.get("warning"):
    raise RuntimeError(session["warning"])  # Known checkout that encrypts the card in the browser

await send_to_user(session["approvalUrl"])

status = session["status"]
while status == "pending_approval":
    await asyncio.sleep(3)
    status = (await natural("GET", f"/card-sessions/{session['sessionId']}"))["status"]
if status != "approved":
    raise RuntimeError(f"Card session {status}")

import ssl, certifi

claim = await natural(
    "POST",
    f"/card-sessions/{session['sessionId']}/claim",
    headers={"Idempotency-Key": f"card-claim-{task_id}"},
)

ca_bundle = certifi.contents() + (await httpx.AsyncClient().get(claim["proxy"]["caBundleUrl"])).text
tls = ssl.create_default_context(cadata=ca_bundle)

p = claim["proxy"]
relay = httpx.AsyncClient(
    proxy=httpx.Proxy(f"https://{p['username']}:{p['password']}@{p['host']}:{p['port']}", ssl_context=tls),
    verify=tls,
    timeout=30,
)

from playwright.async_api import async_playwright

DROP_REQUEST = {"host", "content-length", "connection", "accept-encoding"}
DROP_RESPONSE = {"content-encoding", "content-length", "transfer-encoding", "connection"}

async def through_natural(route):
    request = route.request
    if request.method == "OPTIONS":  # CORS preflight, no card data
        return await route.continue_()
    headers = {
        k: v for k, v in (await request.all_headers()).items()
        if k.lower() not in DROP_REQUEST and not k.startswith(":")
    }
    response = await relay.request(request.method, request.url, headers=headers, content=request.post_data_buffer)
    response_headers = {k: v for k, v in response.headers.items() if k.lower() not in DROP_RESPONSE}
    if cookies := response.headers.get_list("set-cookie"):
        response_headers["set-cookie"] = "\n".join(cookies)  # Playwright splits Set-Cookie on newlines
    await route.fulfill(status=response.status_code, headers=response_headers, body=response.content)

pw = await async_playwright().start()
browser = await pw.chromium.connect_over_cdp(cdp_url)
context = browser.contexts[0]
for host in claim["allowedHosts"]:
    await context.route(f"https://{host}/**", through_natural)

try:
    for host in claim["allowedHosts"]:
        try:
            await relay.get(f"https://{host}/")
        except httpx.HTTPError as error:
            raise RuntimeError(f"Proxy routing to {host} failed. Don't submit the card.") from error

    # Your agent fills in claim["card"], claim["card"]["holderName"] and claim["billingAddress"]
    # on the payment page, then submits once.
finally:
    for host in claim["allowedHosts"]:
        await context.unroute(f"https://{host}/**")
    await relay.aclose()
    await pw.stop()  # Disconnects CDP; the Browser Use browser keeps running