The problem with AI agent payments

Most AI agents today that interact with money do so through centralized APIs — Stripe, PayPal, or bank integrations. That works for fiat. But for on-chain stablecoin payments, it creates a fundamental mismatch: you're using a custodial, permissioned layer to interact with a permissionless network.

The x402 protocol changes that. Instead of "authenticate with an API key and call an endpoint," x402 says: pay with USDC and get access. HTTP 402 — Payment Required — becomes the authentication mechanism itself.

This article shows how to build an agent that does exactly that: sends USDC payments via Coinbase AgentKit, and verifies them via PayWatcher MCP — fully autonomous, fully on-chain.

The stack

Three components, each with a clear responsibility:

Coinbase AgentKit gives your agent on-chain capabilities: a CDP wallet, USDC transfers, token swaps, contract interactions. It's the agent's hands.

x402 defines the payment protocol. When an agent calls a resource, the server responds with HTTP 402 + a payment descriptor (amount, asset, recipient, network). The agent pays, retries with proof, and gets access. No API key exchange, no account creation.

PayWatcher MCP is the verification layer. When a payment happens on-chain, PayWatcher confirms it — checking the tx_hash, amount, recipient, and network. It exposes this as an MCP tool, so agents can call it directly from their workflow.

Together:

Agent (AgentKit) → calls verify_payment
→ PayWatcher returns HTTP 402 + payment descriptor
→ AgentKit auto-pays $0.05 USDC on Base
→ Agent retries with X-PAYMENT header
→ PayWatcher verifies → returns { verified: true }

The code

Install dependencies:

bash

npm install @x402/mcp @x402/evm @modelcontextprotocol/sdk viem dotenv
npm install @coinbase/agentkit

Create the x402-aware MCP client:

typescript

import { createx402MCPClient } from "@x402/mcp"
import { ExactEvmScheme } from "@x402/evm/exact/client"
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
import { privateKeyToAccount } from "viem/accounts"

const signer = privateKeyToAccount(process.env.EVM_PRIVATE_KEY as `0x${string}`)

const paywatcher = createx402MCPClient({
  name: "my-agent",
  version: "1.0.0",
  schemes: [
    { network: "eip155:84532", client: new ExactEvmScheme(signer) },
  ],
  autoPayment: true,
})

const transport = new StreamableHTTPClientTransport(
  new URL("https://api.paywatcher.dev/mcp")
)
await paywatcher.connect(transport)

Verify a payment:

typescript

const result = await paywatcher.callTool("verify_payment", {
  tx_hash: "0xabc123...",
  network: "base-sepolia",
  amount: "1.00",
  to: "0xRecipientAddress...",
})

// { verified: true, status: "confirmed" }

That's it. When callTool hits the 402, @x402/mcp handles the payment automatically — signs the USDC transfer, attaches the proof header, retries. Your code just sees the result.

Why this matters

The traditional API model assumes a human set up an account, got an API key, and configured billing. That works for web apps. It breaks for autonomous agents.

x402 + MCP removes that assumption entirely. An agent can:

1. Discover available tools via tools/list

2. Call a tool

3. Pay automatically if required

4. Get the result

No onboarding. No account. No human in the loop.

For payment verification specifically, this creates a new possibility: agents that can trustlessly confirm a payment happened before releasing a resource, executing a contract, or continuing a workflow — all in a single automated loop.

Try it

• Docs: paywatcher.dev/docs/agentkit

• Example repo: github.com/masem-at/paywatcher-agentkit-example

• MCP Server: api.paywatcher.dev/mcp

• Testnet: Base Sepolia (no real funds needed)

The example repo runs end-to-end on Base Sepolia with testnet USDC from the Circle faucet. Clone, configure .env, run — the full x402 flow works out of the box.

What's next

PayWatcher is building toward a fully x402-native stack: every API endpoint behind x402, no API keys required at all. AgentKit is the first integration — more frameworks coming.

If you're building with AgentKit, x402, or stablecoin payments and want to connect — find me on Farcaster (@paywatcher) or X (@PayWatcher_dev).

Mario Semper — masemIT e.U., Austria. Building PayWatcher in public.