# What does HTTP 402 Payment Required mean? A history of the web's unused code

## What does HTTP 402 Payment Required mean? A history of the web's unused code

**HTTP 402 "Payment Required" is a web status code that says a server will give you what you asked for if you pay.** It has been part of the standard since the 1990s, and until recently it did nothing: every specification since 1997 has described it as "reserved for future use". In 2025 the x402 protocol gave it a job. This article, the first chapter of the Group's book [*The x402 Economy*](https://services.561.group/the-x402-economy-book/), tells how the code came to sit idle for about thirty years and what changed.

### What are HTTP status codes?

Every time a browser asks a web server for something, the server answers with a three-digit number before anything else. The number says how the request went. `200` means "here it is". `404` means "there is nothing here". `500` means "something broke on my side". Most people have seen 404; few have seen the others, because browsers handle them quietly.

These numbers are part of HTTP, the Hypertext Transfer Protocol, the set of rules every web browser and web server follows. HTTP groups its codes by their first digit. Codes in the 400s mean the request itself was the problem: the client asked for something it may not have, or asked in the wrong way. `401` means "you need to sign in". `403` means "you may not have this". And `402` means "Payment Required".

### Why has 402 been "reserved for future use" since 1997?

The formal specification of HTTP/1.1, published by the Internet Engineering Task Force (IETF) as RFC 2068 in January 1997, gave 402 one sentence: "This code is reserved for future use." Every revision since has kept it. The current specification, RFC 9110 from June 2022, still says "The 402 (Payment Required) status code is reserved for future use."

| Specification | Date | What it says about 402 |
| --- | --- | --- |
| RFC 2068 | January 1997 | "This code is reserved for future use." |
| RFC 2616 | June 1999 | The same sentence |
| RFC 7231 | June 2014 | "reserved for future use" |
| RFC 9110 | June 2022 | "The 402 (Payment Required) status code is reserved for future use." |

Reserved codes are not unusual. Protocol designers leave room for things they expect to need. What is unusual about 402 is how specific the reservation was. The designers did not reserve a code for some unknown purpose. They named the purpose, payment, and then waited a quarter of a century for a way to carry it out.

### What did the first web designers have in mind?

The idea is older than the 1997 specification. In the early 1990s, the team at CERN that built the first web software kept a short list of status codes and what each meant. Its entry for 402 reads: "The parameter to this message gives a specification of charging schemes acceptable. The client may retry the request with a suitable ChargeTo header." (That is from the W3C's historical page [Status codes in HTTP](https://www.w3.org/Protocols/HTTP/HTRESP.html), last revised 1994.)

That sentence describes almost exactly how x402 works today. The server says how it will accept payment. The client pays and asks again, carrying proof in a header, which is a labeled line of extra information attached to a request. The difference is that in the early 1990s there was no `ChargeTo` header, no agreed way to fill one in, and nothing on the other end to settle the charge. The web's designers knew what they wanted. They did not have the money.

### Why did charging small amounts on the web fail?

Through the late 1990s and early 2000s, companies and researchers tried to build what they called micropayments: charges of a few cents or less, made with a click, for a page, an article or a song. Digital-cash systems such as DigiCash issued electronic tokens a user could spend. Millicent, from Digital Equipment Corporation, was designed for charges of a fraction of a cent. A W3C working group drafted a standard way for web pages to show a price. Newspapers, music services and payment startups tried variations for another decade.

None of them lasted. The usual explanation is cost, and it is part of the story. Card networks charge a fixed fee per transaction plus a percentage, so a ten-cent charge can cost more to process than it earns. Accounts had to be opened and funded. Fraud had to be handled. Every one of those costs fell on each payment, however small.

Two essays from the period argued that cost was not the deepest problem. Nick Szabo wrote in 1999 that the real obstacle was what he called *mental transaction costs*: deciding whether an article is worth three cents takes a moment of attention, and that moment is worth more than three cents to most people. Clay Shirky made the argument bluntly in 2000 in "The Case Against Micropayments": people dislike making many small, unpredictable decisions about money, and any charge big enough to matter to the seller is big enough to make the buyer stop and think. People prefer a flat price they decide on once.

The market agreed. The web's economy settled on three ways of paying that avoid small decisions: **advertising** (the reader pays with attention), **subscriptions** (the reader decides once a month or year) and **bundles** (one price covers many things). 402 stayed reserved.

### What changed in the 2020s?

Two things changed, and x402 depends on both.

**The money.** A stablecoin is a digital token that its issuer promises to redeem for a fixed amount of an ordinary currency, usually one US dollar. Stablecoins live on blockchains, shared public ledgers that record every transfer. On some blockchains a transfer now costs a fraction of a cent and completes in seconds. That removes the fixed per-payment cost that sank the card-based micropayment schemes.

**The buyer.** Szabo's and Shirky's arguments are about people. They say nothing about a computer program that has been given a budget and a task. A program does not feel a moment of doubt before spending three cents. It checks the price against its rules and pays or does not. When the buyer is software, the mental transaction cost the skeptics identified drops away, because there is no mind to spend it.

Software that acts on a person's behalf, choosing steps and calling services to reach a goal, is now usually called an AI agent. Agents built on large language models became common in 2024 and 2025. Many of the interfaces they need are sold by subscription with a human sign-up flow, which an agent cannot easily complete. An agent that meets a paywall mid-task has, until recently, had to stop and ask its person for help. x402 is an attempt to let it pay instead.

### Was x402 the first protocol to use HTTP 402?

No. In 2020 Lightning Labs, a company that builds software for Bitcoin's Lightning Network, published a scheme it first called LSAT and later renamed [L402](https://github.com/lightninglabs/L402). A server using L402 answers a request with 402 and a Lightning invoice. The client pays the invoice and retries with proof of payment and a credential the server can check. L402 uses Bitcoin rather than dollar stablecoins and has a committed community of users. (Secondary sources give both 2023 and 2024 as the year of the rename; we have not settled that from a primary source.)

What set x402 apart when it appeared in May 2025 was its backing and its money. It came from Coinbase, one of the largest US cryptocurrency companies, and it settled in USDC, a dollar stablecoin. Within a year it had the support of the major card networks, the largest cloud providers and a Linux Foundation body to govern it; that story is in [Who built x402 and who governs it](https://services.561.group/who-built-x402-and-who-governs-it/). The comparison with L402 and the other agent payment protocols is in [x402 versus MPP, AP2, ACP and L402](https://services.561.group/x402-vs-mpp-ap2-acp-and-l402/).

### What should I take from this history?

- HTTP 402, "Payment Required", has existed since the 1990s, and every specification since 1997 has left it "reserved for future use".
- The web's first designers imagined a client paying and retrying with proof; there was no money to make that work.
- 1990s micropayment schemes failed on per-payment costs and, more deeply, on the attention a person must spend to decide on each small payment.
- Cheap stablecoin transfers remove the first obstacle. Software buyers remove the second.

### Where do I go next?

To see what a 402 response looks like today, read [What is x402?](https://services.561.group/what-is-x402/) or follow the [step-by-step walkthrough of one paid request](https://services.561.group/how-an-x402-payment-works-step-by-step/). To try the real thing against a live market, send an unpaid request to `https://market.561.group/v1/publications/the-x402-economy` and read the `payment-required` header; the [quickstart](https://services.561.group/how-to-buy-from-an-x402-market-as-a-software-agent/) shows how.