How to Build X402 Payment Intents for AI Agent Micropayments on Base Using Coinbase

In the fast-evolving world of AI agents, enabling autonomous micropayments is no longer a futuristic dream- it’s happening now on Base with Coinbase’s x402 protocol. Imagine your AI agent querying an API, negotiating a tiny USDC fee as low as $0.001, and settling the transaction over HTTP without logins or sessions. That’s the power of X402 payment intents Base, designed specifically for Coinbase X402 AI agents handling micropayments AI agents Base. As Coinbase Global Inc (COIN) trades at $165.79, up $0.67 or and 0.41% in the last 24 hours with a high of $166.64 and low of $159.36, the momentum behind x402 reflects broader market confidence in infrastructure for agentic economies.

x402 leverages the long-dormant HTTP 402 ‘Payment Required’ status code to make payments as native to the web as a 200 OK response. It’s stateless, HTTP-native, and developer-friendly, perfect for AI agents on Base that need instant, reliable X402 stablecoin micropayments developers. No more clunky web3 wallets or multi-step auth- just direct on-chain USDC flows via Coinbase’s tools. Recent advancements like x402 Bazaar, launched in September 2025, index pay-per-request services, acting as a discovery engine for agents. Pair it with integrations like Google’s Agentic Payments Protocol, and you’ve got seamless AI-to-AI transactions.

Why Base Stands Out for X402 Micropayments

Base, Coinbase’s layer-2 network, combines Ethereum security with low fees and high throughput, making it ideal for HTTP 402 payment integration Coinbase. Micropayments thrive here because gas costs are negligible, enabling fees under a cent without eroding value. Platforms like Pay2Agent further simplify this, offering protocol-agnostic infrastructure for agents trading data or compute in real-time. I’ve seen countless trading setups, and x402’s approach mirrors the precision needed in swing trading- quick entries, minimal friction, immediate settlement.

Building AI-to-AI Payments with x402 for AI Hackathons (Source: Lablab. ai)

This setup isn’t hype; it’s battle-tested on Base Sepolia testnet, as guides from QuickNode demonstrate with simple HTML/JS apps backed by Express. For AI agents using XMTP chats or Swarms frameworks, x402 unlocks monetization via FastAPI endpoints that demand crypto upfront. The protocol’s CAIP-2 network support ensures cross-chain potential, but Base’s native USDC liquidity keeps it focused and efficient.

[tweet]

Coinbase Developer Platform🛡️
✓

@CoinbaseDev
·
Dec 18, 2025

What’s next for x402? We’re developing the x402 Foundation alongside @Cloudflare and other partners to ensure the standard remains open and can be used fairly by any company in the world.

Learn more: https://t.co/nMJSnxLU7S https://t.co/z8xvgs0FGo

💬
3


🔁
5


❤️
36


👁️
3.5K

Essential Prerequisites Before Coding

Before diving into code, stock your toolkit. You’ll need Node. js or Python (FastAPI for agent-heavy flows), a Base wallet like Coinbase Wallet, and testnet USDC from faucets. Familiarize with Coinbase Developer Docs at docs. cdp. coinbase. com/x402- they cover SDKs and extensions for service discovery. Set up a Base Sepolia RPC endpoint via QuickNode or Alchemy for reliable testnet access. If you’re building for production, grab a funded Base mainnet wallet, but start on testnet to avoid burning real funds.

1. Install Node. js v20 and or Python 3.12.
2. Create a Coinbase Developer account for API keys.
3. Fund your testnet wallet with Sepolia ETH and USDC.
4. Clone example repos from Base docs or Kye Gomez’s Medium tutorial on Swarms and x402.

Pro tip: Use VS Code with web3 extensions for syntax highlighting on payment intents. This foundation prevents common pitfalls like network mismatches or invalid CAIP identifiers.

Configuring Your X402 Payment Intent Server

Let’s bootstrap the backend. For a Node. js/Express setup mirroring QuickNode’s paywall example, create an app that responds to requests with a 402 unless paid. Install dependencies: express, @coinbase/x402-sdk, and viem for Base interactions.

require('dotenv').config();
const express = require('express');
const cors = require('cors');
const { createPublicClient, http } = require('viem');
const { baseSepolia } = require('viem/chains');

const app = express();
const port = process.env.PORT || 3000;

app.use(cors());
app.use(express.json());

const client = createPublicClient({
  chain: baseSepolia,
  transport: http(process.env.BASE_SEPOLIA_RPC_URL || 'https://sepolia.base.org'),
});

app.post('/create-x402-intent', async (req, res) => {
  try {
    const { amount, resource, agentId } = req.body; // amount in ETH, resource to pay for, agent ID

    // In a real implementation, this would:
    // 1. Create a unique payment request or hashlock
    // 2. Interact with a smart contract or paymaster via Coinbase Smart Wallet
    // For now, generate a mock intent for basic setup

    const intentId = `x402_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    
    // Example payment URI for X402 (scheme for Base micropayments)
    const paymentUri = `base:${baseSepolia.id}/pay?intent=${intentId}&amount=${amount}&to=0xYourPaymentContractAddress`;

    const intent = {
      id: intentId,
      amount,
      currency: 'ETH',
      network: 'base-sepolia',
      status: 'requires_payment',
      payment_uri: paymentUri,
      resource,
      agent_id: agentId,
    };

    res.json(intent);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Failed to create payment intent' });
  }
});

app.listen(port, () => {
  console.log(`X402 Payment Intent Server running on port ${port}`);
});

Here’s the skeleton:

const express = require('express'); const { X402 } = require('@coinbase/x402-sdk'); const app = express(); const x402 = new X402({ network: 'base-sepolia' }); app. use(express. raw({ type: 'application/x402 and json' })); app. post('/api/micropay', async (req, res) = and gt; { const payment = await x402. createIntent({ amount: '0.001', currency: 'USDC', wallet: req. body. wallet }); res. set('Payment-Intent', JSON. stringify(payment)); res. status(402). end(); }); app. listen(3000);

This endpoint generates a payment intent for $0.001 USDC. Agents hit it, receive the intent, sign and submit via their wallet, then retry for 200 OK with service response. Test with curl or a simple buyer script. Next, we’ll hook in AI agent logic for autonomous discovery via x402 Bazaar.

Check out detailed steps in this integration guide for USDC specifics on Base.

Now that your server demands payment, build the buyer side: an AI agent that discovers services via x402 Bazaar, generates intents, and pays autonomously. This flips the script from manual APIs to self-sustaining economies on Base, where agents query, pay, and consume data like micropayments AI agents Base in a living marketplace.

import asyncio
import requests
from swarms import Agent, Swarm
from coinbase.x402 import X402Handler  # pip install @coinbase/x402-sdk (Python wrapper)
from web3 import Web3
import os

# Configuration
BASE_RPC_URL = "https://mainnet.base.org"
w3 = Web3(Web3.HTTPProvider(BASE_RPC_URL))

# Load private key securely (use environment variable in production)
private_key = os.getenv('COINBASE_WALLET_PRIVATE_KEY')
if not private_key:
    raise ValueError("Set COINBASE_WALLET_PRIVATE_KEY environment variable")
account = w3.eth.account.from_key(private_key)

USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"  # USDC on Base
BASE_CHAIN_ID = 8453

class AutonomousBuyerAgent(Agent):
    def __init__(self):
        super().__init__(
            name="X402BuyerAgent",
            llm="openai",  # Configure your preferred LLM
            description="Scans X402 Bazaar, handles micropayments, unlocks content",
        )
        self.x402_handler = X402Handler(w3, account)

    async def scan_bazaar(self) -> str:
        """Scan X402 Bazaar for services like data feeds or compute."""
        response = requests.get("https://bazaar.x402.dev/services?type=data,compute")
        response.raise_for_status()
        services = response.json()
        # Simple selection logic (enhance with LLM reasoning)
        service = next(s for s in services["services"] if "data" in s["tags"])
        print(f"Selected service: {service['name']} at {service['endpoint']}")
        return service["endpoint"]

    async def handle_payment_intent(self, endpoint: str) -> str:
        """Send request, parse 402 Payment-Intent, submit USDC payment on Base."""
        response = requests.get(endpoint)
        if response.status_code != 402:
            raise ValueError(f"Unexpected status: {response.status_code}")

        intent = response.json()
        amount_wei = int(float(intent["amount"]) * 10**6)  # USDC 6 decimals
        recipient = intent["recipient"]
        payment_ref = intent["payment_ref"]

        print(f"Payment intent: ${intent['amount']} USDC to {recipient[:10]}...")

        # Sign and submit via Coinbase X402 SDK
        tx_hash = await self.x402_handler.submit_micropayment(
            token_address=USDC_BASE,
            recipient=recipient,
            amount=amount_wei,
            chain_id=BASE_CHAIN_ID,
            payment_ref=payment_ref,
        )
        print(f"Payment tx: https://basescan.org/tx/{tx_hash.hex()}")
        return payment_ref

    async def stateless_retry_unlock(self, endpoint: str, payment_ref: str, max_retries: int = 10) -> dict:
        """Idempotent retries with exponential backoff until 200 response."""
        for attempt in range(max_retries):
            headers = {"X-Payment-Ref": payment_ref}  # Stateless idempotency
            response = requests.get(endpoint, headers=headers)
            if response.status_code == 200:
                print("Content unlocked successfully!")
                return response.json()
            print(f"Retry {attempt + 1}/{max_retries}: {response.status_code}")
            await asyncio.sleep(2 ** attempt)  # Exponential backoff
        raise Exception("Max retries exceeded - payment may not be confirmed yet")

async def run_buyer_agent():
    """Main swarm execution for the autonomous buyer agent."""
    agent = AutonomousBuyerAgent()
    swarm = Swarm(agents=[agent])

    # Autonomous flow
    endpoint = await agent.scan_bazaar()
    payment_ref = await agent.handle_payment_intent(endpoint)
    content = await agent.stateless_retry_unlock(endpoint, payment_ref)

    print("Final unlocked content:", json.dumps(content, indent=2))

if __name__ == "__main__":
    asyncio.run(run_buyer_agent())

Here’s agent code using @coinbase/x402-sdk:

from swarms import Agent, Swarm
from x402 import X402Client
import os

# Set up environment variables
PRIVATE_KEY = os.getenv('PRIVATE_KEY')
RPC_URL = 'https://sepolia.base.org'  # Base Sepolia RPC

# Initialize X402 client for Base Sepolia
x402_client = X402Client(
    private_key=PRIVATE_KEY,
    rpc_url=RPC_URL,
    chain_id=84532  # Base Sepolia chain ID
)

# Define a simple AI agent using Swarms
agent = Agent(
    name="PaymentAgent",
    llm="openai",  # or your preferred LLM
    x402_client=x402_client
)

# Swarm orchestration
def micropayment_task():
    # Step 1: Discover the service endpoint
    service_url = "https://example-x402-service.on.base Sepolia"  # Replace with actual service
    service = agent.discover_service(service_url)
    
    # Step 2: Create payment intent for $0.001 USDC
    intent = service.create_payment_intent(
        amount=0.001,
        currency="USDC",
        description="Micropayment for AI service"
    )
    print(f"Payment Intent ID: {intent.id}")
    
    # Step 3: Execute payment
    tx_hash = agent.pay(intent)
    print(f"Payment Transaction Hash: {tx_hash}")
    
    return intent

# Run the task
if __name__ == "__main__":
    result = micropayment_task()
    print("Micropayment completed successfully!")

import asyncio from swarms import Agent from coinbase. x402 import X402 async def micropay_agent(): x402 = X402(network="base-sepolia") agent = Agent( llm="gpt-4o", wallet="0xYourAgentWallet" ) # Discover via Bazaar services = await agent. query_bazaar("data api") for service in services: response = await agent. http_post(service. url) if response. status == 402: intent = x402. parse_intent(response. headers

            
Autonomous AI Agent Handling X402 Payment Required
            
Here's a practical JavaScript example using Viem and a Coinbase Smart Wallet private key (fund it via Coinbase Developer Platform). The agent detects HTTP 402, parses the Payment-Intent header, transfers 0.001 USDC on Base Sepolia, and retries seamlessly.
            
import { createPublicClient, createWalletClient, http, parseUnits } from 'viem';
import { baseSepolia, base } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';
import { usdcAddress } from './config'; // Base Sepolia: 0x036CbD53842c5426634e7929541eC2318f3dCF7e
const USDC_ABI = [
  'function transfer(address to, uint256 amount) public returns (bool)'
] as const;

const account = privateKeyToAccount('0xYOUR_COINBASE_SMART_WALLET_PRIVATE_KEY'); // Use Coinbase Smart Wallet for autonomy
const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});
const walletClient = createWalletClient({
  account,
  chain: baseSepolia,
  transport: http(),
});

async function autonomousAgentRequest(endpoint: string, payload: any) {
  console.log('🤖 AI Agent: Thinking... Initiating request.');
  let response = await fetch(endpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });

  if (response.status === 402) {
    console.log('💰 AI Agent: Payment Required detected. Parsing Payment-Intent header...');
    const paymentIntentHeader = response.headers.get('Payment-Intent');
    if (!paymentIntentHeader) throw new Error('No Payment-Intent header');

    // Parse X402 Payment-Intent (JSON string with recipient, amount, etc.)
    const intent = JSON.parse(paymentIntentHeader);
    const amount = parseUnits('0.001', 6); // 0.001 USDC (6 decimals)

    console.log(`📤 AI Agent: Paying ${intent.amount || '0.001'} USDC to ${intent.recipient} on Base...`);

    // Execute transfer via Coinbase-integrated wallet
    const hash = await walletClient.writeContract({
      address: usdcAddress as `0x${string}`,
      abi: USDC_ABI,
      functionName: 'transfer',
      args: [intent.recipient as `0x${string}`, amount],
    });

    await publicClient.waitForTransactionReceipt({ hash });
    console.log('✅ Payment confirmed. Retrying request...');

    // Retry the original request
    response = await fetch(endpoint, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });
  }

  console.log('🎉 AI Agent: Request complete!');
  return response;
}

// Usage
await autonomousAgentRequest('https://your-x402-service.com/api/endpoint', { query: 'AI micropayment demo' });
This agent thinks, pays, iterates—pure autonomy. Test on Sepolia first; real USDC micropayments at fractions of a cent thanks to Base.

Testing and Debugging the Full Flow
Fire up your stack: server on localhost: 3000, agent script running. Curl the endpoint first- expect 402. Use a test wallet to pay, confirm 200. Monitor Base explorer for txs. Common snags? Mismatched networks or invalid CAIP-2 strings; always double-check docs. cdp. coinbase. com/x402. Integrate Pay2Agent for sub-cent precision if scaling to production agent swarms. 

Pre-Deployment Checklist: X402 Micropayments on Base

Verify Base Sepolia RPC connection is active and responsive🔗
Fund test wallets with sufficient USDC and ETH💰
Test 402 → Payment → 200 flow end-to-end 10 times successfully🔄
Audit wallet permissions for minimal required access🔒
Scan for reentrancy vulnerabilities in payment intents🛡️
Confirm x402 Bazaar indexing for your service📋

Checklist complete! Your X402 Payment Intents are prepped and ready for secure deployment on Base. 🚀

Scale to mainnet by swapping networks and funding real USDC. Coinbase's extensions system lets you add metadata for agent discovery, boosting visibility in the Bazaar. I've traded volatile swings where timing is everything; x402 delivers that edge for agents, settling faster than any CEX order book. 
For deeper Node. js flows tailored to X402 payment intents Base, see this Node. js guide. Pair with Google's AP2 for agent-to-agent handshakes, and you're building the plumbing for tomorrow's decentralized services. With COIN steady at $165.79 amid x402's rise, the infrastructure is primed. Deploy, monitor, iterate- your agents will thank you with autonomous revenue streams. 
Platforms like Base and tools from Coinbase turn Coinbase X402 AI agents into economic actors. Experiment on testnet, launch on mainnet, and watch micropayments fuel the next wave of on-chain intelligence. 
      


          
    

      

        
        About the Author
        
      
    


          

              

                                
              

                  

                      
                          Aiden Merrick                      
                  
                                        

                          Author                      
                                    

                      Aiden Merrick is a swing trader and technical chartist with 7 years of experience navigating crypto and stocks. His balanced approach blends momentum indicators with market sentiment to find short- and medium-term opportunities. Aiden is known for his clear, step-by-step trading guides and pragmatic risk management.                  

                  

                                        
                          
                              Author's website                          
                    
                  
                  
                      Author's posts