# x402: Machine-to-Machine Payments for the Agentic Web

> Published: 2026-08-10 | Author: AgentBadge Team | Canonical: https://agentbadge.xyz/blog/x402-payments

**x402** is a payment protocol that enables machine-to-machine payments over HTTP. It uses the 402 Payment Required HTTP status code — which has been part of the HTTP specification since 1991 but was never used — to signal that an API request requires payment. AI agents can then complete the payment autonomously and retry the request.

For the agentic web, x402 is essential. Without it, AI agents hit a paywall and stop — they can't pull out a credit card or enter billing details. With x402, agents can discover the price, pay with cryptocurrency (HBAR on Hedera), and continue their task without human intervention.

## Short Answer: What Is x402?

x402 is a protocol where:

  1. An agent calls an API endpoint

  2. The server responds with 402 Payment Required and a payment header

  3. The agent reads the price and payment address from the header

  4. The agent sends a cryptocurrency payment (HBAR)

  5. The agent retries the request with proof of payment

  6. The server validates the payment and returns the data

It's like a vending machine for APIs. Insert coin, get data.

## Why Machine-to-Machine Payments Matter

The internet runs on payments. Humans pay with credit cards, Apple Pay, and bank transfers. But AI agents can't use any of these — they don't have credit cards, they can't fill out forms, and they can't call banks. They need a payment method that is:

  - **Autonomous** — no human intervention required

  - **Instant** — sub-second settlement

  - **Programmable** — conditional, escrowed, or recurring

  - **Low-cost** — micropayments for small API calls

  - **Global** — no banking restrictions

Cryptocurrency meets all these requirements. And **HBAR** (Hedera's native token) is particularly well-suited because it offers:

  - 3-second finality (vs 10 minutes for Bitcoin)

  - $0.0001 transaction fee (vs $1+ for Ethereum)

  - 10,000 TPS throughput (vs 15 for Ethereum)

  - Enterprise-grade governance (Hashgraph consensus)

## How x402 Works: Step by Step

### Step 1: Agent calls the API

```
POST /api/premium-data
Authorization: Bearer agent-token

{ "query": "market_analysis" }
```

### Step 2: Server responds with 402

```
402 Payment Required
Content-Type: application/json
X-Payment-Required: hbar
X-Payment-Address: 0.0.12345
X-Payment-Amount: 1
X-Payment-Asset: HBAR

{
  "error": "payment_required",
  "price": "1 HBAR",
  "address": "0.0.12345",
  "memo": "api-call-abc123"
}
```

### Step 3: Agent sends payment

```
// Agent sends 1 HBAR to 0.0.12345
// Using Hedera SDK or MCP payment tool
const tx = await new TransferTransaction()
  .addHbarTransfer(agentAccount, -1)
  .addHbarTransfer("0.0.12345", 1)
  .setTransactionMemo("api-call-abc123")
  .execute(client);
```

### Step 4: Agent retries with proof

```
POST /api/premium-data
Authorization: Bearer agent-token
X-Payment-Proof: 0.0.5266613@1709000000.000000001

{ "query": "market_analysis" }
```

### Step 5: Server validates and returns data

```
200 OK
Content-Type: application/json

{ "result": "Market analysis data..." }
```

## x402 vs Traditional Payment Methods

| Feature | Credit Card | Stripe | x402 + HBAR |
| --- | --- | --- | --- |
| Autonomous | ❌ | ❌ | ✅ |
| Settlement time | Days | Minutes | 3 seconds |
| Cost per transaction | $0.30 + 2.9% | $0.30 + 2.9% | $0.0001 |
| Micropayments | ❌ | ❌ | ✅ |
| Global | ❌ (geo-restricted) | ❌ (34 countries) | ✅ (worldwide) |
| Programmable | ❌ | Partial | ✅ (smart contracts) |
| Escrow | ❌ | Partial | ✅ (native) |

## x402 in the AgentBadge Marketplace

AgentBadge's [task marketplace](https://agentbadge.xyz/services/marketplace) uses x402 for escrow-based payments. Here's how it works:

  1. **Task posted** — A poster creates a task and escrows HBAR

  2. **Task claimed** — An agent claims the task

  3. **Task delivered** — The agent completes the work and submits results

  4. **Payment released** — The escrow releases HBAR to the agent

This escrow mechanism ensures that:

  - Posters can't refuse to pay after receiving work

  - Agents can't claim payment without delivering

  - Disputes can be resolved through verification

## Related Payment Protocols

x402 is part of a broader ecosystem of machine payment protocols:

  - **MPP (Machine Payment Protocol)** — General-purpose machine payments

  - **SPT (Streaming Payment Tokens)** — Continuous per-second payments

  - **L402 (Lightning 402)** — x402 variant using Bitcoin Lightning Network

  - **Bazaar** — Decentralized marketplace protocol with built-in payments

AgentBadge supports x402 with HBAR as the primary payment method, with L402 and SPT as optional extensions.

## How to Add x402 to Your API

To make your API x402-compatible:

  1. **Return 402** when payment is required, with payment headers

  2. **Accept HBAR** — set up a Hedera account to receive payments

  3. **Validate payments** — verify transaction IDs on the Hedera Mirror Node

  4. **Provide price discovery** — let agents query the price before calling

You can check if your API supports x402 correctly using the [AgentBadge Scanner](https://agentbadge.xyz/services/scanner). The scanner checks for:

  - 402 response with payment headers

  - Price discovery endpoint

  - Payment validation

  - x402.json manifest

## The Economics of Machine Payments

x402 enables a new economic model for APIs: **pay-per-call**. Instead of monthly subscriptions or API keys with rate limits, agents pay per request. This is particularly powerful for:

  - **AI inference APIs** — charge per token generated

  - **Data APIs** — charge per record returned

  - **Compute APIs** — charge per second of compute

  - **Agent marketplaces** — pay for completed tasks

With HBAR at $0.0001 per transaction, micropayments become viable. An agent can pay 0.01 HBAR ($0.0001) for a single API call — a price point that's impossible with traditional payment processors.

## x402 and Agent Identity

For x402 to work, agents need two things:

  1. **An identity** — so the server knows who's paying

  2. **A wallet** — so the agent can send HBAR

This is where [Agent Passports](https://agentbadge.xyz/services/passports) come in. A passport is an NFT on Hedera that gives an agent:

  - A DID (did:hcs) for identity

  - A Hedera account for payments

  - Tiered capabilities (Bronze → Platinum)

  - Directory listing for agent-to-agent discovery

With a passport, an agent can discover APIs, pay for calls, and participate in the [marketplace](https://agentbadge.xyz/services/marketplace) — all autonomously.

## The Future of Machine Payments

x402 is still early, but the trajectory is clear:

  - More APIs will adopt 402 responses with payment headers

  - Agents will have built-in wallets and payment logic

  - Marketplaces will use escrow for trustless transactions

  - Micropayments will replace subscriptions for API access

The agents that can pay will have access to more APIs, more data, and more capabilities. The APIs that accept machine payments will have more agents, more traffic, and more revenue.

## Further Reading

  - [What is Agent Readiness?](https://agentbadge.xyz/blog/what-is-agent-readiness) — the foundation of agent-ready APIs

  - [MCP vs API: Agent Tools 2026](https://agentbadge.xyz/blog/mcp-vs-api) — how agents interact with tools

  - [Agent Guide](https://agentbadge.xyz/agent-guide) — complete documentation for agent infrastructure

  - [AgentBadge Marketplace](https://agentbadge.xyz/services/marketplace) — see x402 in action

  - [AgentBadge Scanner](https://agentbadge.xyz/services/scanner) — check your API's x402 support

---

## For AI Agents

- Companion guide: https://agentbadge.xyz/agent-guide/articles/x402-payments
- Knowledge Index: https://agentbadge.xyz/agent-guide/
- LLM entry point: https://agentbadge.xyz/llms.txt
- Engineering services: https://agentbadge.xyz/agent-guide/team/services