The internet has always had a missing layer. From the earliest days of HTTP, a status code sat dormant in the spec: 402 Payment Required. It was reserved for future use, on the assumption that one day the web would need a native way to handle payments inline at the protocol level, without routing through banks, subscription portals, or third-party processors.

That day is here, thanks to AI agents. Agentic commerce only works if two fundamental problems are solved simultaneously: agents must pay and prove who they are.

x402 solves the first. Self Agent ID solves the second.

Together, they form the infrastructure stack that agentic commerce has been waiting for.

What Is x402, and Why Does It Matter?

x402 is an open payment standard built on the HTTP 402 status code. Coinbase developed it, the x402 Foundation now stewards it, and major infrastructure providers, including Cloudflare and Self’s partners at Google have already integrated it.

The mechanics are simple. A client (an AI agent, a service, a developer tool) sends an HTTP request to a server. If the resource requires payment, the server responds with a 402 status code and a set of payment instructions in the body: how much, to whom, and in which token. The client pays with stablecoins like USDC, adds the payment authorization header, and resends the request. The server verifies and responds with the requested resource.

That's the entire flow: eliminating account creation, subscription management, redirects to payment pages, or waiting for a bank to settle.

For a human browsing the web, this might seem like a marginal improvement. For an AI agent executing dozens or hundreds of tasks per minute, it changes everything. Agents cannot create accounts, manage subscriptions, or click through payment flows. They need payments to work the way HTTP works: as a protocol, not a product.

x402 processed over 35 million transactions and more than $10 million in volume since launching on Solana, and in January 2026, the protocol received a major upgrade, adding wallet-based identity, multi-chain support across Base, Solana, and other networks, and a modular SDK that makes integration a single middleware line of code.

The protocol is growing fast. Weekly transactions reached 156,000, up 492%, and x402 was integrated into Google's Agent Payments Protocol as the crypto rail. The missing layer of the internet is here.

The Problem x402 Does Not Solve Alone

Here is the thing about a payment protocol: it handles the money, but it does not handle the trust.

When an AI agent sends a payment over x402, the receiving server gets paid. What it does not get is any verifiable answer to the question: who authorized this? Is this agent acting on behalf of a real, unique human being? Is the operator behind this agent on a sanctions list? Has someone spun up 10,000 identical agents to drain an API or game a system?

These questions matter enormously for anyone building services that agents will pay for and use. Pay-per-use pricing only works if you can prevent abuse. Age-gated services need to verify the operator. Compliance teams need OFAC checks. Marketplaces need to know sybil agents are not flooding them with fake identities.

x402 enables the transaction. It does not verify the transactor.

That verification gap is exactly what Self Agent ID fills.

What Is Self Agent ID?

Self Agent ID is a verifiable identity layer for AI agents, here is how it works:

• A user scans their passport using the Self app. 

• A cryptographic proof is generated on-device, meaning no personal data ever leaves the phone. That proof links the user's real identity to their registered agent without revealing the underlying personal data to anyone.

• The agent receives two things: a soulbound NFT that lives onchain, and an A2A-compatible identity card that any service can verify with a single API call. The entire process is zero-knowledge from start to finish.

The result is an agent that can prove it represents a verified human being without revealing the human's identity. It can selectively disclose specific credentials (proof of age, proof of nationality, proof of OFAC compliance, proof of humanity) depending on the requirements of a given service. Because verification is tied to a real passport, the system is sybil-resistant by design. One person gets one agent identity.

Self Agent ID is built as an extension of ERC-8004, the emerging standard for agent registries. SDKs are available in TypeScript, Python, and Rust. There is an MCP server and Claude Code plugin so developers can manage agent identity directly from their IDE, whether that is Cursor, Windsurf, Copilot, or Claude Code.

How x402 and Self Agent ID Work Together

Think about what the combination unlocks.

An agent registered through Self Agent ID carries verifiable credentials. When that agent hits a service gated by x402, it can do two things simultaneously: pay for the resource, and prove it is authorized to access it. The service receives payment at internet speed and, in the same request, verifies that the operator behind the agent is a real person, not a bot, and meets the service's compliance requirements.

This is the foundation of trusted agentic commerce.

Today, when a developer builds an AI agent that needs to access paid APIs, they must manually manage API keys, billing accounts, and subscription plans for every service the agent interacts with. When the agent makes a purchase or accesses a sensitive resource, there is no automatic proof that a verified human authorized the action. Compliance is an afterthought.

When x402 and Self Agent ID are combined, the agent handles payments natively over HTTP, and the identity credentials travel with the agent. Every transaction is both settled and attributable. Developers do not have to build bespoke billing and identity layers for every integration. Service providers do not have to choose between frictionless access and knowing who they are dealing with.

What This Enables for Builders

For developers building on Self Protocol's agentic stack, the practical implications are significant.

Agents can access pay-per-use AI inference, data feeds, compute resources, and API services without pre-purchasing credits or managing subscriptions. A trading agent pays fractions of a cent per data request. A research agent pays per document fetched. A task automation agent pays per tool call. All of it settles instantly in stablecoins, with no minimum commitments and no human required to authorize each payment.

Because Self Agent ID uses selective credential disclosure, builders can define exactly what their agent is allowed to prove. A healthcare application might require age verification. A financial service might require OFAC compliance. A marketplace might only need proof of humanity to prevent spam. Operators stay anonymous while still proving what needs to be proven.

The Self ecosystem already has projects like SelfClaw, where verified agents operate a skill marketplace with agent-to-agent commerce and onchain reputation. Agents earn, pay, and interact in ways that were simply not possible before verifiable identity and native payments existed simultaneously.

The Agentic Economy Needs Both Layers

There is a chaotic version of agentic commerce: agents spending tokens without accountability, services being gamed by automated bots, no way to enforce compliance, and every platform building one-off identity and billing solutions that do not interoperate.

And there is a version that actually works: an open payment standard that any agent and any service can speak, combined with a privacy-preserving identity layer that links agents to real humans without exposing personal data.

The second version requires x402 and the Self Agent ID to work together. x402 is the payment rail. Self Agent ID is the trust layer. Neither one alone is sufficient.

If you are building agents that will operate in the real world, accessing services, spending money, and making decisions, you need both pieces of infrastructure in place before you deploy.

The good news is that both exist today, and both are production-ready.

Get Started

Registering your agent takes a few minutes. You will need the Self app to scan your passport and generate your zero-knowledge proof, after which you can choose the identity mode that best fits your use case.

Start at ai.self.xyz. The SDKs, MCP server, and developer integration documentation are available through Self Protocol at self.xyz.

For agents who need to pay and prove their identity, the stack is ready.