# Integration von AgentCore Zahlungen mit dem Browser-Tool
<a name="payments-browser"></a>

Es gibt zwei Möglichkeiten, wie Ihr Agent auf kostenpflichtige x402-Inhalte zugreifen kann: über das [Browser-Tool](browser-tool.md) oder über Standard-HTTP-Aufrufe.

## Integration des Browser-Tools (Playwright)
<a name="payments-agent-integration-browser-playwright"></a>

Das AgentCore Browser-Tool bietet Ihrem Agenten innerhalb der Runtime eine verwaltete Headless-Chromium-Browsersitzung. AgentCore Ihr Agent stellt WebSocket mithilfe des DevTools Chrome-Protokolls (CDP) eine Verbindung her, sodass er auf Netzwerkebene durch Seiten navigieren JavaScript, HTTP-Antworten ausführen und abfangen kann. Informationen zu den ersten Schritten finden Sie im Leitfaden zum [Browser-Onboarding](browser-tool.md).

Diese Option verwendet das Strands SDK zusammen mit dem Browser-Tool und dem Zahlungstool, um Websites zu durchsuchen und Zahlungen zu verarbeiten. Wenn ein Agent das Browser-Tool zum Navigieren auf Websites verwendet, verwendet er die Funktionen zum Abfangen von Antworten von Playwright, um Paywall-Websites automatisch zu erkennen:

1.  **Browser-Navigation** — Der Agent verwendet ein von Playwright `browse_with_payment` bereitgestelltes Tool.

1.  **Automatische 402-Erkennung** — Playwright fängt alle HTTP-Antworten ab und veranlasst den Response-Handler des Agenten, 402-Statuscodes zu erkennen.

1.  **x402-Extraktion** — Zahlungstools analysieren automatisch die X402-Zahlungsdetails anhand der Antwort. headers/body Dies kann auch durch die Geschäftslogik der Agenten erfolgen.

1.  **Zahlungsabwicklung** — Der AgentCore Zahlungsabwickler erstellt Kryptosignaturen mithilfe konfigurierter CDP-Wallets.

1.  **Erneut versuchen** — Zahlungstools fügen Autorisierungsheader ein und wiederholen die Anfrage in derselben Browsersitzung.

```
from agentcore.payments import PaymentClient
from agentcore.browser import browser_tool

@tool
async def browse_with_payment(url: str, auto_pay: bool = True) -> dict:
    payment_requirements = None

    async def handle_response(response):
        nonlocal payment_requirements
        if response.status == 402:
            payment_requirements = await extract_x402_requirements(response)

    async def add_payment_header(route, request):
        headers = {**request.headers, **payment_result["authorization"]}
        await route.continue_(headers=headers)

    async with async_playwright() as p:
        # 1. Browser setup
        browser = await p.chromium.connect_over_cdp(AGENTCORE_BROWSER_WS_URL)
        page = await browser.contexts[0].new_page()

        # 2. Register response interceptor
        page.on("response", handle_response)

        # 3. Initial navigation (handle_response runs automatically here)
        response = await page.goto(url)

        # 4. Payment processing logic (runs AFTER navigation completes)
        if response.status == 402 and payment_requirements and auto_pay:
            payment_result = payment_client.process_payment(
                payment_session,
                payment_instrument,
                payment_requirements=payment_requirements
            )

            if payment_result["success"]:
                await page.route("**/*", add_payment_header)
                response = await page.goto(url)  # Retry with payment
            else:
                raise PaymentError(f"Payment failed: {payment_result['error_message']}")

        # 5. Capture content, cleanup, and return
        content = await page.content()
        await browser.close()
        return {"content": content, "status": response.status}
```

## Non-browser HTTP-Integration
<a name="payments-agent-integration-browser-http"></a>

Für direkte API-Aufrufe und Headless-Szenarien können Entwickler mithilfe des Strands SDK zusammen mit einer standardmäßigen HTTP-Anforderungsbibliothek benutzerdefinierte Toollogik schreiben, um Zahlungen mit x402-Erkennung zu verarbeiten:

1. Der Agent verwendet ein benutzerdefiniertes Tool für direkte HTTP-Aufrufe.

1. Das Tool überwacht die Statuscodes der HTTP-Antwort, um 402 zu erkennen.

1. Das Tool extrahiert die x402-Anforderungen und verarbeitet die Zahlung.

1. Das Tool wiederholt die HTTP-Anfrage mit Headern zur Zahlungsautorisierung.

```
@tool
async def make_payment(method, url, headers, body) -> dict:
    # Make initial HTTP request
    response = requests.request(method, url, headers=headers, data=body)

    # Check for 402 Payment Required
    if response.status_code == 402:
        payment_requirements = extract_x402_requirements(response)
        payment_result = payment_client.process_payment(
            payment_session,
            payment_instrument,
            payment_requirements=payment_requirements
        )

        if payment_result["success"]:
            # Retry request with payment authorization
            headers.update(payment_result["authorization"])
            response = requests.request(method, url, headers=headers, data=body)
        else:
            raise PaymentError(f"Payment failed: {payment_result['error_message']}")
```