Constructing brokers that transact with Anchor Browser and AgentCore funds

AI brokers more and more have to entry internet sources which are priced per request. For instance, premium datasets cost by the question, analysis APIs meter by the decision, and paywalled publishers gate content material behind fee. When an AI agent encounters one in all these sources, the server returns HTTP 402 Fee Required. The agent has no built-in fee mechanism, no finances hooked up to the session, and no programmatic strategy to fulfill the request. The duty stalls and requires handbook intervention.

Anchor Browser with Agentic Funds handles machine-to-machine fee workflows on behalf of the agent. Developed in collaboration with the AWS Generative AI Innovation Heart Accomplice Agent Manufacturing facility, it’s now out there on AWS Market. This publish covers how Anchor Browser integrates with Amazon Bedrock AgentCore funds in order that AI brokers pays for x402-protected pages and APIs autonomously. The x402 protocol is an open commonplace for HTTP-based machine-to-machine funds. A server responds with 402 Fee Required together with the quantity, accepted fee strategies, and fee tackle that the agent makes use of to finish the transaction.

Anchor Browser is a cloud-based browser automation answer purpose-built for AI brokers. Every agent session runs inside a managed browser setting that maintains authentication state, handles navigation, captures community requests, and offers a stay view of web page interactions.

Amazon Bedrock AgentCore offers capabilities to construct, join, and optimize brokers at scale. Amazon Bedrock AgentCore funds is a totally managed functionality inside AgentCore that AI brokers can use to find, entry, and pay for APIs, Mannequin Context Protocol (MCP) servers, and internet content material autonomously. AgentCore funds manages pockets connectivity, enforces configurable spending limits on the infrastructure layer, and processes funds by the x402 protocol. It additionally offers observability into fee makes an attempt, approvals, denials, and settlements by Amazon CloudWatch.

When an agent operating in Anchor Browser encounters a 402 response, AgentCore funds authorizes and completes the transaction inside the configured finances. The workflow continues with out interruption.

Challenges

When an autonomous agent encounters an x402-protected useful resource, the workflow stalls. The agent makes a request, similar to fetching a premium analysis report or calling a paid knowledge enrichment API, and the server responds with HTTP 402 Fee Required. With out a mechanism to pay, the duty that was presupposed to run autonomously now requires human intervention.

At present, builders should construct your complete fee stack. This effort spans 4 classes of complexity:

Fee protocol dealing with

Detecting and parsing the 402 problem from the HTTP response, and distinguishing payment-required responses from different 4xx errors.
Setting up the right fee header with the cryptographic proof within the actual format the service provider expects.
Supporting a number of fee schemes (actual, upto, and protocol variants) with out hardcoding vendor-specific logic into the agent.
Sustaining compatibility throughout x402 service provider implementations that may range in problem format, supported stablecoins, or settlement timing.

Safety and key administration

Storing a personal key to signal funds, requiring safe key storage inside an setting uncovered to untrusted inputs.
Managing pockets lifecycle operations, together with key rotation, credential refresh, and supplier failover.

Operational resilience

Resubmitting the unique request with the fee header whereas preserving session state, cookies, and request context.
Offering idempotency, which is crucial for pockets operations.
Imposing per-session and per-transaction spend limits with real-time finances monitoring throughout concurrent agent executions.

Observability and compliance

Capturing each fee try, approval, denial, and settlement in audit logs for compliance and reconciliation.

With out a managed fee service, the agent should internalize your complete fee stack. On each x402-protected name that returns a 402 response, the agent should orchestrate the complete fee move internally, together with:

Signing the proof.
Attaching the right header.
Retrying the request.
Settling the transaction.
Logging the outcome.

Every of those steps requires customized code that builders should construct, safe, and keep. Determine 1 illustrates this structure. The agent accommodates eight tightly coupled parts (Pockets, Personal Keys, Price range Controls, Signal Proof, Connect Header, Retry Logic, Settle Fee, and Logging). The agent connects to an x402 API with a 402 problem flowing again and a retry flowing ahead.

Agent payment stack with eight embedded components connecting to an x402 API, showing a 402 challenge returning and a retry sent forward

Determine 1: Agent fee stack

The safety issues prolong past the engineering effort.

Uncontrolled spending. With out arduous spending limits enforced on the infrastructure stage, a bug, retry loop, immediate injection, or inadvertent entry can set off unintended funds. An agent retrying a paid endpoint in a loop continues to authorize funds till handbook intervention happens.

Key publicity. When non-public keys reside contained in the agent runtime, they share an execution setting with untrusted internet pages, third-party instruments, and exterior dependencies. These vectors would possibly inadvertently disclose the credentials that management actual funds.

Signing move publicity. If the signing infrastructure is accessible from the runtime, a menace actor can try and entry the important thing or redirect funds to an tackle beneath unauthorized management. Efficient mitigation requires that the important thing doesn’t enter the runtime within the first place.

Browser-based brokers introduce an extra constraint: the fee should happen inside the identical browser session. In any other case, session recordings and stay view now not match what really executed.

Resolution

Anchor Browser and AgentCore funds tackle this complexity by shifting your complete fee stack into managed infrastructure.

Not like a stateless software name, Anchor Browser offers an actual cloud browser with persistent identification, repeatable and deterministic workflows, and the session context wanted to log in, navigate, and end duties reliably. Authentication, navigation, community requests, recordings, and stay view occur inside the identical browser session. When a fee is required, the transaction occurs inside that session. The recording captures the complete sequence from request to 402 to fee to content material supply. Anchor brokers embody a built-in x402 software that handles paid API calls natively inside the browser context. The built-in software requires no adjustments to current Playwright, Puppeteer, or Chrome DevTools Protocol-based workflows.

AgentCore funds serves because the fee layer. On the heart of the service is the Fee Supervisor, the top-level useful resource that coordinates fee operations for the AWS account. Making a Fee Supervisor requires specifying an authorizer kind and an IAM position. AgentCore then provisions a corresponding workload identification in Amazon Bedrock AgentCore Id.

The remaining parts join the Fee Supervisor to exterior pockets infrastructure:

A PaymentConnector integrates the Fee Supervisor with an exterior pockets supplier, both Coinbase Developer Platform (Coinbase CDP) or Stripe Privy.
A PaymentCredentialProvider shops pockets supplier credentials securely in AgentCore Id.
A PaymentInstrument identifies the precise pockets tackle from which funds are drawn.

Anchor Browser units up wallets by AgentCore funds utilizing a supported pockets supplier, with out putting pockets secrets and techniques or non-public keys contained in the agent runtime. AgentCore funds handles pockets operations by the configured supplier. For endpoint discovery, AgentCore offers a curated Coinbase x402 Bazaar MCP server by Amazon Bedrock AgentCore Gateway, so brokers can uncover out there pay-per-use x402 endpoints programmatically.

AgentCore funds restructures the fee structure. Delicate operations transfer out of the agent runtime and right into a managed service layer. The Anchor Agent holds solely two payment-related parts: a finances session and the x402 software. The infrastructure, together with authentication, pockets secrets and techniques, fee limits, observability, and fee proof signing, resides within the AgentCore funds layer. Determine 2 exhibits the Anchor Agent connecting to the AgentCore funds managed layer, which handles pockets supplier integration with Coinbase CDP or Stripe Privy.

Anchor Agent connecting to the AgentCore payments managed layer, which integrates with Coinbase CDP or Stripe Privy wallet providers

Determine 2: Anchor Browser integrates with AgentCore funds

How the fee move works

The next steps describe what occurs finish to finish, from the second a browser session encounters an x402-protected useful resource to the second the agent receives the response and continues the duty.

Anchor Browser creates a devoted AgentCore PaymentSession for the browser session. When the session begins with x402 turned on, Anchor Browser provisions a PaymentSession by AgentCore funds, linking the browser session to a configured fee instrument and finances.
The browser receives an HTTP 402 Fee Required response. The agent navigates to a URL or makes a fetch or XMLHttpRequest (XHR) request. The service provider responds with a 402 problem specifying the quantity, accepted fee strategies, and fee tackle.
The browser selects a suitable fee technique. Anchor Browser reads the 402 problem payload and matches the requested fee technique in opposition to the instrument linked to the PaymentSession.
AgentCore verifies the session finances and generates the cryptographic fee proof. AgentCore funds validates that the fee quantity falls inside the session spending restrict. The service then indicators the transaction utilizing the configured pockets supplier (Coinbase CDP or Stripe Privy) and returns the cryptographic proof. No key materials enters the browser or agent runtime.
The browser retries the unique request with the fee header. The browser attaches the signed proof as PAYMENT-SIGNATURE for x402 v2 or X-PAYMENT for x402 v1, then retries the unique request precisely as soon as.
The service provider verifies and settles the fee, then returns the protected useful resource. The service provider validates the cryptographic proof, settles the transaction on-chain, and serves the content material. The agent continues the duty.

Pockets credentials stay with AgentCore and the configured pockets supplier all through this move.

Conditions

Earlier than you start, just be sure you have a legitimate Anchor Browser API key (ANCHOR_API_KEY). To create one, see the Anchor Browser Fast Begin information.

Organising automated x402 funds

Organising agentic funds for Anchor Browser requires one session property. Set session.x402 to true. The property defaults to false. When enabled, the browser session can routinely entry x402-protected web sites with funds signed by AgentCore funds and retried inside the identical browser session. Enabling session.x402 authorizes the browser to make actual funds from the configured fee instrument.

The next examples present the right way to create a payment-enabled session for Anchor Browser utilizing cURL and JavaScript:

cURL

curl --request POST
--url https://api.anchorbrowser.io/v1/classes
--header "anchor-api-key: $ANCHOR_API_KEY"
--header "content-type: utility/json"
--data '{"session":{"x402":true}}'

JavaScript

const response = await fetch('https://api.anchorbrowser.io/v1/classes', {
  technique: 'POST',
  headers: {
    'anchor-api-key': course of.env.ANCHOR_API_KEY,
    'content-type': 'utility/json',
  },
  physique: JSON.stringify({ session: { x402: true } }),
});
const { knowledge: session } = await response.json();
console.log(session.cdp_url);

After linked by Chrome DevTools Protocol, the agent navigates usually. You don’t want to incorporate a pockets key or fee header in your automation code. The browser handles 402 challenges, fee signing, and retries transparently for doc navigation, fetch, and XHR requests.

Fee session limits and conduct

Anchor Browser enforces the next guardrails on the session stage by AgentCore funds integration. Every payment-ready browser session operates inside configured spending and time constraints. For particular limits, check with the Anchor Browser technical documentation.

If the service provider response is malformed, no suitable community is obtainable, the finances is exhausted, or AgentCore funds rejects the fee, the browser returns the unique 402 response to the web page unchanged. Your automation code can then deal with the 402 as a typical HTTP error.

The x402 session property controls funds to third-party sources solely. The property doesn’t change Anchor credit and doesn’t pay for the browser session.

Automation code for Anchor Browser

Your automation code for Anchor Browser stays unchanged. The next instance demonstrates that no payment-specific code is required:

const { chromium } = require('playwright');
// Hook up with the x402-enabled session by way of CDP
const browser = await chromium.connectOverCDP(session.cdp_url);
const web page = await browser.newPage();
// Navigate to an x402-protected useful resource precisely as with a free web page
await web page.goto('https://premium-research.instance.com/market-report');
// The web page loaded, the fee was dealt with routinely
// Extract content material as regular
const content material = await web page.textContent('article');

No pockets logic, no fee header building, and no retry code. The agent navigates to the URL. If the server returns 402, Anchor Browser coordinates with AgentCore funds to signal the fee proof, retries the request with the suitable fee header, and delivers the content material to the web page. Your automation code receives the ultimate rendered web page with no indication {that a} fee occurred.

This sample applies uniformly to paywalled journalism, licensed monetary knowledge, gated API documentation, metered analysis databases, and different sources that gate content material behind a 402 problem.

Paid sources aren’t restricted to internet pages. Many are APIs that anticipate POST, PUT, or different HTTP strategies. Frequent examples embody knowledge enrichment providers, premium inference endpoints, and licensed content material APIs. For these use circumstances, Anchor Browser brokers embody a built-in x402 software that you just name like a typical HTTPS API inside the browser context.

Your agent makes the API name by fetch or XHR. If the server returns a 402 problem, the browser coordinates fee signing by AgentCore funds and retries the request with the signed fee header. Your code receives the response as if the endpoint have been free. The software isn’t tied to a particular vendor, mannequin, or framework. Fee operates as a session-level functionality beneath your current tooling, and no adjustments to agent code are required.

// Fetch name to a paid API endpoint inside the x402-enabled session
const response = await web page.consider(async () => {
  const res = await fetch('https://data-enrichment.instance.com/api/v1/enrich', {
    technique: 'POST',
    headers: { 'content-type': 'utility/json' },
    physique: JSON.stringify({ company_domain: 'instance.com' }),
  });
  return res.json();
});
// If the API returned 402, AgentCore dealt with fee routinely
// The response accommodates the enriched knowledge
console.log(response);

Your automation code doesn’t obtain pockets credentials. Computerized funds can be found solely when session.x402 is about to true and stay topic to the spending and expiration limits described within the earlier part.

Key advantages

This integration strikes fee from utility code to the infrastructure layer:

No fee infrastructure to construct. No pockets SDK to combine, no 402 response parser to put in writing, no retry loop to implement, no header building logic to keep up, and no customized audit logging to construct. AgentCore funds manages your complete fee stack.

No adjustments to current tooling. Playwright scripts, Puppeteer automations, Chrome DevTools Protocol instructions, and agent flows in Anchor Browser proceed to perform precisely as earlier than. Fee is a session functionality hooked up to the browser, not a modification to agent logic, prompts, or software definitions.

Personal keys don’t enter the runtime. Signing and settlement occur inside AgentCore funds. The service communicates with Coinbase CDP or Stripe Privy by safe credential storage in AgentCore Id. The agent runtime doesn’t have entry to key materials that may transfer funds.

Budgets are enforced on the infrastructure stage. Each session operates inside outlined spend limits that AgentCore enforces earlier than authorizing a fee. Amazon Bedrock AgentCore Observability offers full fee audit trails by Amazon CloudWatch. When a session reaches the spending restrict, AgentCore funds denies the fee.

Paid duties full efficiently. Paid GET pages load. Paid API calls return responses. The agent completes the workflow slightly than stopping at a 402 response and requiring handbook intervention.

Billing is consolidated. Anchor Browser settles third-party x402 prices in credit on the identical bill as browser session time. There’s no separate crypto custody to handle, no USDC steadiness to observe, and no on-chain settlement for the finance staff to reconcile.

Conclusion

Anchor Browser, built-in with AgentCore funds, equips AI brokers to deal with x402 fee challenges autonomously for paywalled internet pages and paid API endpoints. Pockets credentials keep out of agent code, and no customized fee infrastructure is required.

As extra of the net strikes to per-request pricing, brokers that lack a fee mechanism can’t full duties involving paid sources. This integration addresses that hole: brokers full paid workflows finish to finish, working inside outlined budgets, with full observability by AgentCore Observability, and with out cryptographic key materials within the runtime.

To get began, discover the next sources: