HTTP 402 sat empty for 28 years. Now $24M moves through it every month.

In 1997, the HTTP specification reserved status code 402 for "Payment Required." The internet got 404 (not found), 500 (server error), 403 (forbidden) — everything except the one that was supposed to give the web a native payment layer.

402 sat empty for 28 years.

AI agents changed the equation. When software makes decisions at machine speed, you can't redirect it to a checkout page. You can't expect it to fill out a form, solve a CAPTCHA, or wait for an OTP. Agents need payments to work at the protocol level.

That infrastructure is being built right now. And unlike most "emerging technology" announcements, the numbers above are real — measured on x402.org over the last 30 days.

This guide maps what's live, what's coming, and what you can actually build today.

The gap the internet was always missing

The internet was designed to move information. Commerce was bolted on top through a series of workarounds: your browser talks HTTPS to the merchant, who talks to a payment gateway, who talks to Visa or ACH, who talks to a bank. The whole chain was built for humans at keyboards.

That's why Simon Taylor's framing in FinTech Brain Food is so sharp: "Agents are a new actor." A software agent making autonomous purchasing decisions doesn't fit anywhere in this stack. It's the wrong shape for every existing piece of payment infrastructure.

The protocols being built today aren't incremental improvements to the old stack. They're building the native payment layer the internet never shipped.

The protocol map — four layers, four problems

The confusing part about agentic payments is that there are five or six protocols all getting press at the same time. They're not all competing. Most of them are solving completely different problems.

Here's the map:

Trust first: before any payment, identity

Before your agent can pay for anything, the party it's paying needs to trust it. This is the layer that gets skipped in most explainers, and it's the one that will bite you in production.

Merchants have spent years blocking bots. Now they need to let the right bots through. Two protocols are emerging to solve this:

ERC-8004 (Trustless Agents)

An Ethereum Improvement Proposal backed by MetaMask, Google, and Coinbase. Creates on-chain registries for agent identity, reputation, and validation. An agent's registration file can list MCP endpoints, A2A agent cards, ENS names, and DIDs together. It's designed to work with existing communication protocols — not replace them.

Still a draft EIP, but the backing organizations give it significant credibility. Worth understanding now before it becomes a compliance requirement.

Visa TAP (Trusted Agent Protocol)

Visa's approach: verifiable cryptographic signatures that prove an agent is acting on behalf of a legitimate cardholder with real commerce intent — not a scraper, not a fraud bot. In development; expect to see this required by major merchants as agentic commerce scales.

Commerce protocols: ACP and UCP

These are for the "agent buys something on your behalf" use case — like asking your AI assistant to reorder office supplies or book a flight.

ACP (Agentic Commerce Protocol) — OpenAI / Stripe

Already live in ChatGPT with Walmart, Etsy, and Instacart. The flow: agent creates a cart, generates a payment token, passes it to the payment processor. Clean, transactional, familiar to anyone who's used Stripe.

Reality check: ACP requires a formal partnership with OpenAI and Stripe to implement on the merchant side. Not something a solo builder can tap into without a commercial agreement.

UCP (Universal Commerce Protocol) — Google / Shopify

Google's answer: merchants publish "capability manifests" that agents discover and negotiate with. Think of it as DNS for commerce — agents find merchants and learn what they can do. Coming to Google Search and Gemini. Shopify's involvement suggests strong merchant adoption when it ships.

x402: the one you can build with today

This is the protocol that matters most for builders right now. No corporate partnership required. No commercial agreement. Open standard. Works today.

The concept is elegant: implement the HTTP status code that was reserved in 1997 but never shipped. When an agent makes an API request and needs to pay for it, the server responds with a 402 — and includes payment details in the response headers. The agent pays in USDC on Base, includes a payment proof in the next request, and gets access.

The flow:

1. Agent sends HTTP request to a paid API
2. Server returns: 402 Payment Required with USDC amount + Base wallet address in headers
3. Agent pays USDC on Base (near-zero gas on Base L2)
4. Agent retries request with transaction hash as proof
5. Server verifies on-chain, grants access

No accounts. No API keys. No signups. Pure protocol.

# x402 payment flow — conceptual implementation
import httpx

def fetch_with_payment(url: str, agent_wallet):
    # First request — may return 402
    response = httpx.get(url)
    
    if response.status_code == 402:
        # Parse payment details from headers
        amount_usdc = float(response.headers.get("X-Payment-Amount"))
        recipient = response.headers.get("X-Payment-Address")
        
        # Agent pays on-chain (Base network, USDC)
        tx_hash = agent_wallet.pay_usdc(
            to=recipient,
            amount=amount_usdc,
            network="base"
        )
        
        # Retry with payment proof
        response = httpx.get(url, headers={
            "X-Payment-Proof": tx_hash
        })
    
    return response

The real-world numbers as of March 2026: 75.41M transactions in 30 days, $24.24M volume, 94,060 unique buyers, 22,000 sellers. This is live, working infrastructure — not a whitepaper.

B2B: the next wave

B2B agentic payments — where one agent pays another for services at invoice scale — are the next frontier. The emerging AP2 standard addresses this, but it's early. The interesting play here: enterprises that automate entire service workflows between AI agents will need a way to settle those transactions. B2B agentic payments could be a significantly larger market than consumer-facing agentic commerce.

The full implementation guide

This free guide maps the protocols. The full Agentic Payments Field Guide covers what actually happens when you implement them — including what blocks you, what the error messages mean, and how to make your agent both a buyer and a seller.

It also includes Hiro's field notes: documented observations from an AI agent navigating real payment infrastructure with $10 of real capital — what the APIs actually return, where the friction is, and what the on-chain mechanics look like from an agent's perspective.

Questions? The Library subscription includes access to all our agentic payments content as it develops. See what's included →