Agentes de IA que pagam por recursos web: como o Anchor Browser se integra ao AgentCore Payments

O problema: agentes que travam diante de um HTTP 402

Agentes de Inteligência Artificial (IA) cada vez mais precisam acessar recursos web que têm preço por requisição. Conjuntos de dados premium cobram por consulta, Interfaces de Programação de Aplicação (APIs) de pesquisa medem o uso por chamada, e publishers fechados exigem pagamento para liberar conteúdo. Quando um agente encontra um desses recursos, o servidor devolve um HTTP 402 Payment Required — e o agente simplesmente trava.

Sem um mecanismo de pagamento embutido, sem orçamento vinculado à sessão e sem uma forma programática de satisfazer a cobrança, a tarefa que deveria rodar de forma autônoma passa a exigir intervenção manual. É exatamente esse gap que a AWS buscou endereçar com a integração entre o Anchor Browser e o Amazon Bedrock AgentCore Payments.

O que é o protocolo x402

O x402 é um padrão aberto para pagamentos máquina a máquina via HTTP. Quando um servidor responde com 402 Payment Required, ele inclui no payload o valor cobrado, os métodos de pagamento aceitos e o endereço de destino. O agente usa essas informações para completar a transação e obter acesso ao recurso. Esse padrão é o núcleo de toda a integração descrita neste artigo.

Anchor Browser e AgentCore Payments: o que cada um faz

O Anchor Browser é uma solução de automação de navegador baseada em nuvem, construída especificamente para agentes de IA. Cada sessão de agente roda dentro de um ambiente de navegador gerenciado que mantém estado de autenticação, lida com navegação, captura requisições de rede e oferece uma visualização ao vivo das interações na página. A solução foi desenvolvida em colaboração com o AWS Generative AI Innovation Center Partner Agent Factory e está disponível no AWS Marketplace.

O Amazon Bedrock AgentCore Payments é uma capacidade totalmente gerenciada dentro do AgentCore. Ele permite que agentes de IA descubram, acessem e paguem por APIs, servidores de Protocolo de Contexto de Modelo (MCP) e conteúdo web de forma autônoma. O serviço gerencia a conectividade com carteiras digitais, aplica limites de gasto configuráveis na camada de infraestrutura e processa pagamentos via protocolo x402. Toda a observabilidade — tentativas de pagamento, aprovações, negações e liquidações — é entregue pelo Amazon CloudWatch.

Quando um agente rodando no Anchor Browser encontra uma resposta 402, o AgentCore Payments autoriza e completa a transação dentro do orçamento configurado. O fluxo de trabalho continua sem interrupção.

Por que construir tudo do zero é um problema sério

Sem uma solução gerenciada, os desenvolvedores precisam construir toda a pilha de pagamento internamente. Esse esforço se divide em quatro categorias de complexidade:

• Tratamento do protocolo de pagamento: detectar e interpretar o desafio 402 na resposta HTTP, construir o cabeçalho de pagamento com prova criptográfica no formato exato esperado pelo comerciante, e suportar múltiplos esquemas de pagamento sem hardcodar lógica específica de fornecedor no agente.
• Segurança e gerenciamento de chaves: armazenar uma chave privada para assinar pagamentos em um ambiente exposto a entradas não confiáveis, gerenciar o ciclo de vida da carteira, incluindo rotação de chaves e atualização de credenciais.
• Resiliência operacional: reenviar a requisição original com o cabeçalho de pagamento preservando estado de sessão, cookies e contexto; garantir idempotência nas operações de carteira; e aplicar limites de gasto por sessão e por transação com rastreamento em tempo real.
• Observabilidade e conformidade: capturar cada tentativa de pagamento, aprovação, negação e liquidação em logs de auditoria para fins de conformidade e reconciliação.

Além do esforço de engenharia, há riscos de segurança relevantes. Sem limites rígidos de gasto aplicados na infraestrutura, um bug, um loop de retry, uma injeção de prompt ou um acesso inadvertido pode disparar pagamentos não intencionais. E quando chaves privadas residem dentro do runtime do agente, elas compartilham o ambiente de execução com páginas web não confiáveis, ferramentas de terceiros e dependências externas — vetores que podem expor as credenciais que controlam fundos reais.

A solução: mover toda a pilha de pagamento para a infraestrutura

A integração entre Anchor Browser e AgentCore Payments resolve essa complexidade movendo toda a pilha de pagamento para infraestrutura gerenciada. O agente passa a ter apenas dois componentes relacionados a pagamento: uma sessão de orçamento e a ferramenta x402 embutida. Autenticação, segredos de carteira, limites de pagamento, observabilidade e assinatura de provas ficam na camada do AgentCore Payments.

No centro do serviço está o Payment Manager, o recurso de nível superior que coordena as operações de pagamento para a conta AWS. Ao criar um Payment Manager, é necessário especificar um tipo de autorizador e uma função do Gerenciamento de Identidade e Acesso (IAM). O AgentCore então provisiona uma identidade de carga de trabalho correspondente no Amazon Bedrock AgentCore Identity. Os demais componentes conectam o Payment Manager à infraestrutura de carteira externa:

• Um PaymentConnector integra o Payment Manager com um provedor de carteira externo — Coinbase Developer Platform (Coinbase CDP) ou Stripe Privy.
• Um PaymentCredentialProvider armazena as credenciais do provedor de carteira com segurança no AgentCore Identity.
• Um PaymentInstrument identifica o endereço de carteira específico do qual os fundos serão debitados.

Para descoberta de endpoints, o AgentCore disponibiliza um servidor MCP do Coinbase x402 Bazaar através do Amazon Bedrock AgentCore Gateway, permitindo que agentes descubram programaticamente endpoints x402 disponíveis para uso por requisição.

Como o fluxo de pagamento funciona na prática

O fluxo completo, do momento em que o navegador encontra um recurso protegido por x402 até o agente receber a resposta e continuar a tarefa, funciona assim:

• O Anchor Browser cria uma PaymentSession dedicada no AgentCore para a sessão de navegador, vinculando-a ao instrumento de pagamento configurado e ao orçamento definido.
• O agente navega para uma URL ou faz uma requisição fetch ou XMLHttpRequest (XHR). O servidor responde com um desafio 402 especificando valor, métodos aceitos e endereço de pagamento.
• O Anchor Browser lê o payload do desafio 402 e verifica compatibilidade com o método de pagamento vinculado à PaymentSession.
• O AgentCore Payments valida que o valor está dentro do limite de gasto da sessão, assina a transação usando o provedor de carteira configurado (Coinbase CDP ou Stripe Privy) e retorna a prova criptográfica. Nenhum material de chave entra no navegador ou no runtime do agente.
• O navegador reenvia a requisição original com o cabeçalho de pagamento — PAYMENT-SIGNATURE para x402 v2 ou X-PAYMENT para x402 v1.
• O comerciante valida a prova criptográfica, liquida a transação on-chain e entrega o conteúdo protegido. O agente continua a tarefa normalmente.

Configurando pagamentos x402 automáticos no Anchor Browser

Configurar pagamentos agênticos no Anchor Browser exige apenas uma propriedade de sessão: definir session.x402 como true. O valor padrão é false. Quando habilitado, a sessão de navegador passa a acessar automaticamente sites protegidos por x402, com pagamentos assinados pelo AgentCore Payments e reenvios dentro da mesma sessão.

Atenção: habilitar session.x402 autoriza o navegador a realizar pagamentos reais a partir do instrumento de pagamento configurado.

Os exemplos abaixo mostram como criar uma sessão habilitada para pagamento via cURL e JavaScript:

cURL:

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

JavaScript:

const response = await fetch('https://api.anchorbrowser.io/v1/sessions', {
  method: 'POST',
  headers: {
    'anchor-api-key': process.env.ANCHOR_API_KEY,
    'content-type': 'application/json',
  },
  body: JSON.stringify({ session: { x402: true } }),
});

const { data: session } = await response.json();
console.log(session.cdp_url);

Após conectar via Protocolo Chrome DevTools (CDP), o agente navega normalmente. Não é necessário incluir chave de carteira ou cabeçalho de pagamento no código de automação. O navegador trata os desafios 402, a assinatura do pagamento e os reenvios de forma transparente para requisições de navegação, fetch e XHR.

O código de automação permanece inalterado. O exemplo abaixo demonstra que nenhum código específico de pagamento é necessário:

const { chromium } = require('playwright');

// Connect to the x402-enabled session via CDP
const browser = await chromium.connectOverCDP(session.cdp_url);
const page = await browser.newPage();

// Navigate to an x402-protected resource exactly as with a free page
await page.goto('https://premium-research.example.com/market-report');

// The page loaded, the payment was handled automatically
// Extract content as normal
const content = await page.textContent('article');

Sem lógica de carteira, sem construção de cabeçalho de pagamento, sem código de retry. O agente navega para a URL. Se o servidor retornar 402, o Anchor Browser coordena com o AgentCore Payments para assinar a prova de pagamento, reenvia a requisição com o cabeçalho apropriado e entrega o conteúdo à página. O código de automação recebe a página final renderizada sem nenhuma indicação de que um pagamento ocorreu.

Chamadas de API pagas com a ferramenta x402 embutida

Recursos pagos não se limitam a páginas web. Muitos são APIs que esperam métodos POST, PUT ou outros. Exemplos comuns incluem serviços de enriquecimento de dados, endpoints de inferência premium e APIs de conteúdo licenciado.

Para esses casos, os agentes do Anchor Browser incluem uma ferramenta x402 embutida que funciona como uma chamada HTTPS padrão dentro do contexto do navegador. Se o servidor retornar um desafio 402, o navegador coordena a assinatura do pagamento via AgentCore Payments e reenvia a requisição com o cabeçalho assinado. O código recebe a resposta como se o endpoint fosse gratuito.

// Fetch call to a paid API endpoint within the x402-enabled session
const response = await page.evaluate(async () => {
  const res = await fetch('https://data-enrichment.example.com/api/v1/enrich', {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ company_domain: 'example.com' }),
  });
  return res.json();
});

// If the API returned 402, AgentCore handled payment automatically
// The response contains the enriched data
console.log(response);

Para consultar os limites específicos de gasto e expiração por sessão, a documentação técnica do Anchor Browser traz os detalhes atualizados. Se a resposta do comerciante for malformada, nenhum método de pagamento compatível for oferecido, o orçamento estiver esgotado ou o AgentCore Payments rejeitar o pagamento, o navegador devolve a resposta 402 original ao código de automação, que pode tratá-la como um erro HTTP padrão.

Principais benefícios da integração

• Sem infraestrutura de pagamento para construir: nenhum SDK de carteira para integrar, nenhum parser de resposta 402 para escrever, nenhum loop de retry para implementar e nenhum log de auditoria customizado para manter. O AgentCore Payments gerencia toda a pilha.
• Sem alterações nas ferramentas existentes: scripts Playwright, automações Puppeteer, comandos CDP e fluxos de agentes no Anchor Browser continuam funcionando exatamente como antes. Pagamento é uma capacidade de sessão, não uma modificação na lógica do agente.
• Chaves privadas fora do runtime: assinatura e liquidação acontecem dentro do AgentCore Payments. O serviço se comunica com Coinbase CDP ou Stripe Privy através de armazenamento seguro de credenciais no AgentCore Identity. O runtime do agente não tem acesso a material de chave que movimenta fundos.
• Orçamentos aplicados na infraestrutura: cada sessão opera dentro de limites de gasto definidos que o AgentCore aplica antes de autorizar qualquer pagamento. Quando uma sessão atinge o limite, o AgentCore Payments nega o pagamento. A observabilidade completa é entregue via Amazon CloudWatch.
• Faturamento consolidado: o Anchor Browser liquida cobranças x402 de terceiros em créditos na mesma fatura que o tempo de sessão do navegador. Não há custódia de criptomoeda separada para gerenciar, nem saldo de USDC para monitorar.

Conclusão

A integração entre Anchor Browser e AgentCore Payments equipa agentes de IA para lidar com desafios de pagamento x402 de forma autônoma — tanto para páginas web pagas quanto para endpoints de API pagos. As credenciais de carteira ficam fora do código do agente, e nenhuma infraestrutura de pagamento customizada é necessária.

À medida que mais da web migra para precificação por requisição, agentes sem mecanismo de pagamento simplesmente não conseguem completar tarefas envolvendo recursos pagos. Essa integração endereça esse gap: os agentes completam fluxos de trabalho pagos de ponta a ponta, operando dentro de orçamentos definidos, com observabilidade completa e sem material criptográfico no runtime.

Para começar, a AWS disponibiliza os seguintes recursos:

• Pagamentos x402 automáticos no Anchor Browser
• Guia do desenvolvedor do AgentCore Payments
• AgentCore Payments com integração de navegador
• Anchor Browser no AWS Marketplace

Fonte

Building agents that transact with Anchor Browser and AgentCore payments (https://aws.amazon.com/blogs/machine-learning/building-agents-that-transact-with-anchor-browser-and-agentcore-payments/)