Pagos de Agentes: Protocolos AP2, Stripe MPP y x402

1. Por Qué los Agentes Necesitan Protocolos de Pago

Los flujos de pago tradicionales asumen un humano haciendo clic en botones: seleccionando artículos, llenando datos de tarjeta, revisando un total y presionando "Pagar". Los agentes AI operan diferente. Ejecutan tareas de forma autónoma, frecuentemente cuando el usuario está dormido o no disponible, a través de docenas de servicios en un solo flujo de trabajo. Un agente reservando un vuelo, un hotel y un auto de alquiler necesita hacer tres pagos separados a tres comerciantes diferentes sin ninguna confirmación humana en cada paso. Las páginas de checkout existentes, CAPTCHAs y banners de consentimiento de cookies están diseñados para verificar presencia humana -- activamente previenen transacciones iniciadas por máquinas.

La brecha fundamental es la delegación de autorización. Un humano debe poder otorgar a un agente un permiso acotado, auditable y limitado en tiempo para gastar dinero en su nombre -- con límites claros sobre qué, cuánto y con quién. Sin un protocolo estandarizado para esto, cada par agente-comerciante necesitaría una integración a medida, creando un problema de interoperabilidad N-por-M idéntico al que enfrentaron las APIs REST antes de OpenAPI. Tres protocolos han surgido para resolver esto: Google AP2 (autorización basada en mandatos), Stripe MPP (pagos en streaming basados en sesión) y x402 (micropagos en stablecoin nativos de HTTP).

Las apuestas son significativas. Para 2026, se proyecta que el comercio agéntico maneje miles de millones en volumen de transacciones a medida que los agentes AI pasan de asistentes de investigación a actores económicos autónomos. Los protocolos cubiertos en esta guía definen las capas de confianza, autorización y liquidación que hacen esto posible.

2. Google AP2: El Modelo de Mandatos

El Agent Payments Protocol (AP2), anunciado por Google el 16 de septiembre de 2025 y donado a la FIDO Alliance en abril de 2026, es un protocolo abierto para asegurar pagos liderados por agentes entre plataformas. AP2 lanzó con más de 60 socios incluyendo Mastercard, PayPal, Adyen, Coinbase, American Express, Revolut, UnionPay International, Worldpay, Etsy, Intuit, JCB, Mysten Labs, Salesforce, ServiceNow y Forter. El 28 de abril de 2026 Google entregó AP2 (y el estándar Verifiable Intent co-desarrollado con Mastercard) a la FIDO Alliance para que la especificación siga siendo agnóstica de plataforma y dirigida por la comunidad, y publicó ese mismo día AP2 v0.2, que agrega flujos Human Not Present para transacciones totalmente autónomas. El protocolo es agnóstico al método de pago -- soporta tarjetas tradicionales, transferencias bancarias, métodos alternativos y stablecoins vía su extensión x402.

La pieza central de AP2 es su arquitectura de mandatos, construida sobre Credenciales Verificables (VCs) -- contratos digitales firmados criptográficamente que definen exactamente lo que un agente AI tiene permitido hacer en nombre del usuario. Los mandatos son a prueba de manipulación, legibles por máquinas y criptográficamente vinculados tanto a la identidad del usuario como a la del agente. Sirven como la capa de autorización entre el humano (que aprueba) y el agente (que ejecuta).

// AP2 Cart Mandate structure (simplified)
{
  "@context": ["https://www.w3.org/2018/credentials/v1", "https://ap2-protocol.org/v1"],
  "type": ["VerifiableCredential", "CartMandate"],
  "issuer": "did:key:z6Mkuser...",           // User's DID
  "credentialSubject": {
    "agent": "did:key:z6MkagentClaude...",   // Agent's DID
    "merchant": "did:web:shop.example.com",
    "cart": {
      "items": [{"sku": "RAZOR-X100", "qty": 1, "maxPrice": {"amount": 10000, "currency": "USD"}}],
      "maxTotal": {"amount": 10000, "currency": "USD"}
    },
    "validUntil": "2026-04-16T23:59:59Z"
  },
  "proof": {
    "type": "Ed25519Signature2020",
    "verificationMethod": "did:key:z6Mkuser...#key-1",
    "proofPurpose": "assertionMethod",
    "created": "2026-04-16T10:00:00Z"
  }
}

3. Stripe Machine Payments Protocol (MPP)

Stripe lanzó el Machine Payments Protocol (MPP) el 18 de marzo de 2026, co-creado con Tempo. MPP es un estándar abierto, nativo de internet, para pagos agente-a-servicio. Mientras AP2 define la capa de autorización (quién tiene permitido pagar), MPP define la capa de ejecución de pagos (cómo se mueve el dinero realmente). MPP se construye sobre la infraestructura existente de Stripe -- Payment Intents, detección de fraude Radar, cálculo de impuestos y stack de cumplimiento -- haciéndolo inmediatamente listo para producción para negocios que ya están en Stripe.

El modelo mental principal: cuando un agente solicita un recurso pago, el servidor retorna una respuesta HTTP 402 Payment Required conteniendo detalles del pago (monto, moneda, métodos aceptados, ID del payment intent de Stripe). El agente autoriza usando un Shared Payment Token (SPT), reintenta el request con el token y recibe el recurso junto con un recibo. Los SPTs soportan fiat (tarjetas, compra-ahora-paga-después) y stablecoins, haciendo de MPP un protocolo híbrido que conecta rieles de pago tradicionales y cripto.

// Merchant server: MPP-enabled endpoint (Node.js + Express)
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

app.get('/api/browser-session', async (req, res) => {
  const spt = req.headers['x-payment-token'];

  if (!spt) {
    // Step 2: Return 402 with payment details
    const pi = await stripe.paymentIntents.create({
      amount: 50, currency: 'usd',  // $0.50 per session
      metadata: { type: 'browser_session', agent: req.headers['x-agent-id'] }
    });
    return res.status(402).json({
      payment_intent: pi.client_secret,
      amount: 50,
      currency: 'usd',
      methods: ['card', 'spt', 'x402']
    });
  }

  // Step 5: Verify SPT and fulfill
  const verified = await stripe.paymentTokens.verify(spt);
  if (verified.status === 'succeeded') {
    const session = await createBrowserSession();
    res.set('X-Payment-Receipt', verified.payment_intent);
    return res.json({ session_id: session.id, ws_url: session.wsUrl });
  }
  res.status(402).json({ error: 'payment_failed' });
});

4. Protocolo x402

x402 es un protocolo de pago abierto creado por Coinbase que habilita pagos instantáneos y automáticos directamente sobre HTTP. Revive el código de estado HTTP 402 ("Payment Required"), largamente inactivo, que fue reservado en la especificación HTTP/1.1 en 1997 pero nunca estandarizado -- hasta ahora. El protocolo tiene licencia Apache 2.0 y es gobernado por la x402 Foundation, bajo la Linux Foundation, cuya intención de lanzamiento se anunció el 2 de abril de 2026 y que entró en operación el 14 de julio de 2026 con 40 organizaciones miembro -- entre los miembros premier están Google, AWS, Cloudflare, Stripe, Visa, Mastercard, American Express, Adyen, Circle, Coinbase, Fiserv, Ripple, Shopify, MoonPay y las fundaciones Solana y Stellar.

El flujo es elegantemente simple. Un cliente (agente AI o app) solicita un recurso pago. El servidor retorna una respuesta 402 Payment Required con detalles del pago (precio, tokens aceptados, dirección del destinatario). El cliente firma un payload de pago usando su clave privada de wallet y reenvía el request con el payload firmado en un header HTTP. El Facilitador x402 de Coinbase verifica y liquida el pago onchain, y el servidor entrega el recurso. Todo el intercambio se liquida en menos de 2 segundos con costos de transacción de aproximadamente $0.0001 en Base. x402 v2, lanzado en enero 2026, introdujo identidad basada en wallet, soporte multi-chain y fiat vía CAIP (Chain Agnostic Improvement Proposals), y destinatarios dinámicos para pagos divididos y escenarios de marketplace.

La Coinbase Developer Platform (CDP) provee un servicio de facilitador hospedado que procesa pagos en Base, Polygon, Solana y Etherlink (agregado en marzo 2026) con un tier gratuito de 1,000 transacciones por mes. Soporte para USDT fue agregado en abril 2026 vía una asociación con Utexo, complementando USDC como la segunda stablecoin soportada. Desde su lanzamiento en mayo 2025, x402 ha liquidado más de 158 millones de transacciones onchain moviendo más de $41 millones en volumen de stablecoins en siete cadenas hasta julio 2026, con un pago promedio de alrededor de $0.32. Visa lanzó Visa CLI, integrando pagos basados en wallet con MPP. Cloudflare integró x402 nativamente, permitiendo que cualquier Cloudflare Worker se convierta en una API paga con unas pocas líneas de configuración.

// x402 client: AI agent paying for API access
import { createWalletClient, http } from 'viem';
import { base } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY);
const wallet = createWalletClient({ account, chain: base, transport: http() });

async function callPaidAPI(url) {
  // Step 1: Request the resource
  const res = await fetch(url);
  if (res.status !== 402) return res.json();

  // Step 2: Parse payment details from 402 response
  const paymentDetails = JSON.parse(res.headers.get('X-Payment-Details'));
  // { amount: "100000", token: "USDC", recipient: "0xmerchant...", network: "base" }

  // Step 3: Sign the payment payload
  const payload = {
    amount: paymentDetails.amount,
    token: paymentDetails.token,
    recipient: paymentDetails.recipient,
    nonce: Date.now().toString()
  };
  const signature = await wallet.signMessage({ message: JSON.stringify(payload) });

  // Step 4: Retry with payment
  const paidRes = await fetch(url, {
    headers: {
      'X-Payment': JSON.stringify({ ...payload, signature }),
      'X-Payment-Protocol': 'x402'
    }
  });
  // X-Payment-Response header confirms settlement
  return paidRes.json();
}

5. Firma de un Payment Intent con Claude Agent SDK

El Claude Agent SDK permite construir agentes que pueden interactuar con protocolos de pago a través de tool use. El agente no mantiene fondos ni claves privadas directamente -- en cambio, delega operaciones de pago a herramientas que se conectan con infraestructura de pago segura. Esto sigue el principio de menor privilegio: el agente razona sobre qué comprar, la herramienta de pago maneja la firma criptográfica y el movimiento de fondos.

En la práctica, defines herramientas de pago que el agente puede invocar. Para Stripe MPP, la herramienta crea un Payment Intent y retorna el SPT. Para x402, la herramienta firma un payload de pago usando una clave de wallet almacenada en un enclave seguro o servicio de gestión de claves. Para AP2, la herramienta genera una solicitud de mandato y la presenta al usuario para firma (Mandato de Carrito) o la valida contra un Mandato de Intención pre-autorizado.

// Claude Agent SDK: Payment-capable agent with MPP tool
import Anthropic from '@anthropic-ai/sdk';
import Stripe from 'stripe';

const anthropic = new Anthropic();
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

const paymentTools = [{
  name: 'pay_with_mpp',
  description: 'Pay for a resource using Stripe MPP. Returns a Shared Payment Token.',
  input_schema: {
    type: 'object',
    properties: {
      payment_intent_secret: { type: 'string', description: 'The client_secret from the 402 response' },
      payment_method: { type: 'string', description: 'Payment method ID (pm_...)' }
    },
    required: ['payment_intent_secret', 'payment_method']
  }
}, {
  name: 'pay_with_x402',
  description: 'Pay for a resource using x402 USDC on Base. Signs and submits payment.',
  input_schema: {
    type: 'object',
    properties: {
      amount: { type: 'string', description: 'Amount in USDC smallest unit' },
      recipient: { type: 'string', description: 'Recipient wallet address' }
    },
    required: ['amount', 'recipient']
  }
}];

// Agent loop
async function runPaymentAgent(task) {
  let messages = [{ role: 'user', content: task }];

  while (true) {
    const response = await anthropic.messages.create({
      model: 'claude-sonnet-5',
      max_tokens: 4096,
      tools: paymentTools,
      messages
    });

    if (response.stop_reason === 'tool_use') {
      const toolCall = response.content.find(b => b.type === 'tool_use');

      let result;
      if (toolCall.name === 'pay_with_mpp') {
        const pi = await stripe.paymentIntents.confirm(
          toolCall.input.payment_intent_secret.split('_secret_')[0],
          { payment_method: toolCall.input.payment_method }
        );
        result = { status: pi.status, receipt: pi.id };
      }
      // ... handle other payment tools

      messages.push({ role: 'assistant', content: response.content });
      messages.push({ role: 'user', content: [{
        type: 'tool_result', tool_use_id: toolCall.id,
        content: JSON.stringify(result)
      }]});
      continue;
    }
    return response.content[0].text;
  }
}

6. Flujo de Verificación del Comerciante

Los comerciantes que reciben pagos de agentes deben verificar tres cosas: (1) el pago fue autorizado por un humano real (o una pre-autorización válida), (2) el pago se liquidó exitosamente, y (3) el agente solicitante es quien dice ser. Cada protocolo maneja la verificación de manera diferente.

7. Riesgo, Fraude y Manejo de Reembolsos

Los agentes autónomos introducen nuevos vectores de fraude para los que los sistemas de pago tradicionales no fueron diseñados. Un agente comprometido podría agotar el presupuesto de un usuario a través de miles de transacciones pequeñas. Un agente malicioso podría hacerse pasar por uno legítimo y enviar mandatos fraudulentos. Ataques de prompt injection podrían engañar a un agente para hacer compras no autorizadas. Cada protocolo aborda estos riesgos de manera diferente.

8. Postura Regulatoria (PCI DSS, PSD2)

Los pagos de agentes heredan las obligaciones regulatorias de los rieles de pago subyacentes. PCI DSS aplica a cualquier sistema que toque datos de tarjeta. PSD2 (UE) requiere Autenticación Fuerte del Cliente (SCA) para pagos electrónicos. La pregunta regulatoria para agentes es: ¿quién es el "cliente" que se autentica y cómo funciona la delegación dentro de estos marcos?

9. Integración AP2 + A2A

AP2 fue diseñado para funcionar como extensión del protocolo Agent-to-Agent (A2A) de Google. En A2A, los agentes se descubren mutuamente vía Agent Cards, intercambian tareas y colaboran a través de formatos de mensaje estandarizados. AP2 agrega una capa de pago a esto: cuando el Agente A delega una tarea de compra al Agente B (un agente de compras especializado), el Agente B necesita autoridad de pago para ejecutar la transacción. Los mandatos AP2 proveen exactamente esto -- una autorización acotada y verificable que viaja con la delegación de tarea.

La integración funciona a través de la Extensión de Mandatos AP2 para A2A (especificación versión 2026-01-11). Cuando una tarea A2A involucra un pago, el agente delegante adjunta un Mandato de Intención al payload de la tarea. El agente receptor valida el mandato, ejecuta la compra dentro de sus límites y retorna el recibo como parte de la completación de la tarea. Esto habilita cadenas de suministro multi-agente: un agente de adquisiciones descubre un agente de proveedores vía A2A, negocia términos y delega la compra real a un agente de pagos -- todo con autorización criptográfica fluyendo a través de cada paso.

// A2A task with AP2 payment delegation
{
  "jsonrpc": "2.0",
  "method": "tasks/send",
  "params": {
    "id": "task_purchase_supplies",
    "message": {
      "role": "user",
      "parts": [{
        "type": "text",
        "text": "Purchase 50 boxes of A4 paper from approved vendor"
      }]
    },
    "extensions": {
      "ap2": {
        "mandate": {
          "type": "IntentMandate",
          "scope": {
            "merchantCategory": "office_supplies",
            "maxAmount": {"amount": 50000, "currency": "USD"},
            "validUntil": "2026-04-17T00:00:00Z"
          },
          "credential": "eyJhbGciOiJFZERTQSIs..."  // Signed VC (base64)
        }
      }
    }
  }
}

10. Construcción de un Agente Capaz de Pagar: Tutorial End-to-End

Este tutorial construye un agente Claude Agent SDK que puede navegar productos, comparar precios y pagar usando Stripe MPP o x402 dependiendo de los protocolos soportados por el comerciante. El agente respeta un presupuesto de gasto, registra todas las transacciones y solicita aprobación humana para compras por encima de un umbral.

// Full payment agent: MPP + x402 dual-protocol support
import Anthropic from '@anthropic-ai/sdk';
import Stripe from 'stripe';
import { createWalletClient, http, parseUnits } from 'viem';
import { baseSepolia } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

const anthropic = new Anthropic();
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
const wallet = createWalletClient({
  account: privateKeyToAccount(process.env.AGENT_WALLET_KEY),
  chain: baseSepolia,
  transport: http()
});

// Budget tracker
const budget = { maxUsd: 100_00, spentUsd: 0, txCount: 0, maxPerTx: 25_00 };
const txLog = [];

const tools = [
  {
    name: 'check_budget',
    description: 'Check remaining budget and transaction history',
    input_schema: { type: 'object', properties: {} }
  },
  {
    name: 'pay_mpp',
    description: 'Pay via Stripe MPP. Use when merchant returns 402 with Stripe payment intent.',
    input_schema: {
      type: 'object',
      properties: {
        merchant_url: { type: 'string' },
        amount_cents: { type: 'number' },
        description: { type: 'string' }
      },
      required: ['merchant_url', 'amount_cents', 'description']
    }
  },
  {
    name: 'pay_x402',
    description: 'Pay via x402 USDC on Base. Use when merchant supports x402 protocol.',
    input_schema: {
      type: 'object',
      properties: {
        merchant_url: { type: 'string' },
        amount_usdc: { type: 'string' },
        description: { type: 'string' }
      },
      required: ['merchant_url', 'amount_usdc', 'description']
    }
  }
];

async function handleToolCall(name, input) {
  if (name === 'check_budget') {
    return {
      remaining: (budget.maxUsd - budget.spentUsd) / 100,
      spent: budget.spentUsd / 100,
      transactions: txLog.length,
      maxPerTransaction: budget.maxPerTx / 100
    };
  }

  if (name === 'pay_mpp') {
    if (input.amount_cents > budget.maxPerTx)
      return { error: 'Exceeds per-transaction limit. Request human approval.' };
    if (budget.spentUsd + input.amount_cents > budget.maxUsd)
      return { error: 'Exceeds total budget.' };

    const pi = await stripe.paymentIntents.create({
      amount: input.amount_cents,
      currency: 'usd',
      payment_method: process.env.AGENT_PAYMENT_METHOD,
      confirm: true,
      metadata: { agent: 'payment-agent-v1', description: input.description }
    });

    budget.spentUsd += input.amount_cents;
    budget.txCount++;
    txLog.push({ protocol: 'mpp', amount: input.amount_cents, id: pi.id, ts: Date.now() });
    return { status: 'paid', receipt: pi.id, amount: input.amount_cents };
  }

  if (name === 'pay_x402') {
    const amountCents = Math.round(parseFloat(input.amount_usdc) * 100);
    if (amountCents > budget.maxPerTx)
      return { error: 'Exceeds per-transaction limit.' };

    // Sign and send x402 payment (simplified)
    const payload = { amount: input.amount_usdc, recipient: 'merchant_address', nonce: Date.now() };
    const sig = await wallet.signMessage({ message: JSON.stringify(payload) });

    budget.spentUsd += amountCents;
    txLog.push({ protocol: 'x402', amount: amountCents, sig, ts: Date.now() });
    return { status: 'paid', protocol: 'x402', amount: input.amount_usdc };
  }
}

// Run the agent
const response = await anthropic.messages.create({
  model: 'claude-sonnet-5',
  max_tokens: 4096,
  system: `You are a purchasing agent with a $${budget.maxUsd/100} budget.
    Use pay_mpp for Stripe-enabled merchants, pay_x402 for crypto-native APIs.
    Always check_budget before paying. Log every transaction.
    Request human approval for any single purchase over $${budget.maxPerTx/100}.`,
  tools,
  messages: [{ role: 'user', content: 'Purchase 10 headless browser sessions from Browserbase' }]
});

Stripe Agent Toolkit MCP, ACP y Blockchain Tempo

El Stripe Agent Toolkit ahora viene en formato MCP (abril 2026), exponiendo operaciones de pago como herramientas MCP estandarizadas que cualquier agente compatible con MCP puede descubrir y llamar. Las herramientas incluyen create_payment_intent, confirm_payment, create_customer, create_subscription, issue_refund y list_invoices. El transporte MCP soporta SSE y Streamable HTTP, habilitando integración con Claude Code, Claude Desktop y frameworks de agentes personalizados. La configuración solo requiere una API key de Stripe y una lista opcional de operaciones permitidas para scoping de seguridad.

El Agentic Commerce Protocol (ACP) define una capa estandarizada de descubrimiento y negociación para interacciones agente-a-merchant. Un merchant compatible con ACP publica un catálogo legible por máquina (precios, términos, métodos de pago, opciones de envío) en una URL bien conocida. El agente comprador recupera este catálogo, selecciona ítems, negocia términos programáticamente y completa el pago usando AP2, Stripe MPP o x402. ACP separa la lógica de comercio de los rieles de pago, permitiendo que el mismo agente compre en diferentes merchants usando diferentes protocolos de pago.

La blockchain Tempo está ahora en vivo en mainnet para liquidación de pagos agente-a-agente. Tempo provee finalidad sub-segundo para transferencias USDC/USDT con comisiones de transacción por debajo de $0.001, haciéndolo práctico para liquidación de micropagos de alta frecuencia entre agentes cooperantes. A diferencia de x402 que es HTTP-nativo y peer-to-peer, Tempo agrega una capa de liquidación para transacciones multi-parte entre agentes donde se necesita un paso de escrow o arbitraje. Los smart contracts de Tempo soportan pagos condicionales, escrow con bloqueo temporal y autorización multi-firma para despliegues de agentes empresariales.