There's a status code that's been sitting in the HTTP spec since the beginning, quietly doing almost nothing. 402 Payment Required. Every web developer has seen 404, 500, maybe 403 if they've been locked out of something they shouldn't have touched. But 402? It's the one code reserved for a future that never really showed up — "hey, you need to pay for this" — because nobody ever built the plumbing to make browsers or servers actually act on it.
CandyChain just built that plumbing. And they're not aiming it at humans typing in a credit card number. They're aiming it at AI agents.
Think about where the internet is actually heading right now. AI agents are starting to do real work on their own — querying APIs, pulling data, calling other services, chaining actions together without a person clicking through each step. That's the whole promise of agentic AI: things happen automatically, in the background, at machine speed.
Except there's a wall every single one of these agents eventually hits. What happens when the API they're calling isn't free? Someone has to pay. And right now, "someone has to pay" usually means a human sitting behind a dashboard with a saved credit card, manually provisioning API keys, setting up billing accounts, and hoping the agent doesn't blow through a rate limit or a budget while nobody's watching. It's clunky, it's slow, and it completely breaks the fantasy of an autonomous agent doing autonomous things.
CandyChain's pitch is pretty simple once you see it: stop making machines pretend to be humans when they pay for things. Give them a payment rail that's actually built for how machines work — instant, programmatic, and triggered by the request itself rather than a person approving an invoice three days later.
The flow CandyChain is showing off is a four-step loop, and it's elegant precisely because it's so mechanical:
An AI agent sends a request to an API — same as it always would. Nothing new yet.
The server responds with an HTTP 402: Payment Required. This is the part that's been sitting dormant in the spec for decades, and CandyChain is finally putting it to work exactly as originally intended — the server telling the requester, in the same language every API already speaks, that access has a price.
The agent pays. Not a person, not a manual top-up, not a support ticket — the agent itself settles the payment in CANDY, right there in the transaction flow, on-chain.
Access granted. The original request goes through, now that payment has cleared, and the agent keeps moving without ever needing a human to intervene.
Request, price, pay, access. No dashboard, no waiting on approvals, no separate billing system bolted onto the side. The payment is baked directly into the same protocol layer the request already travels through.
It would be fair to ask why this needs blockchain rails at all — couldn't you just wire up Stripe to fire on a 402 response? Sort of, but you'd run into exactly the friction this whole idea is trying to eliminate. Traditional payment rails assume a human-verified account, a bank relationship, settlement delays, and per-transaction overhead that makes sense when you're processing a few hundred payments a day, not when an agent might be firing off thousands of tiny API calls an hour.
On-chain settlement solves that differently. CandyChain is running this on its own EVM-compatible chain — Chain ID 2828, for anyone checking the technical details — which means payments settle the way crypto transactions settle: fast, final, and without a human loan officer or card network sitting in the middle deciding whether to approve it. CANDY, the ecosystem's native token, is the unit doing the actual paying. Because it's programmable money on a programmable chain, the entire request-to-settlement loop can happen without a person touching any part of it.
That's the real unlock. Machine-to-machine commerce needs machine-speed money, and traditional finance was never built with that use case in mind.
The obvious audience is API providers — anyone running a service that AI agents might want to call. Instead of building out a whole subscription and billing infrastructure, gating usage behind manually issued API keys, or eating the cost of free-tier abuse, a provider can just answer requests with a 402 and let CandyChain handle collecting payment before access is granted. It's metering and monetization, handled at the protocol layer instead of bolted on afterward.
But the more interesting audience might be the agent builders themselves. If you're building an autonomous agent that's supposed to go out and actually get things done — pull data from five different sources, call a few paid tools, chain them together into a finished task — you need that agent to be able to pay for what it uses without stopping to ask a human for a credit card. CandyChain x402 is effectively giving agents a wallet and a way to spend from it, natively, as part of the same request flow they're already making.
Zoom out and this fits into something CandyChain has been building toward for a while: infrastructure for a version of the internet where a meaningful share of the traffic isn't humans clicking links; it's agents calling APIs on humans' behalf. That's not a hypothetical anymore — it's already happening, just clumsily, with humans stuck in the loop wherever money needs to change hands.
x402 payments are CandyChain's answer to that specific bottleneck. It's a narrow problem — "how does a piece of software pay another piece of software for API access, instantly, without a person in the middle" — but it's the kind of narrow problem that ends up mattering a lot once agentic AI actually scales the way everyone expects it to. Programmable payments, EVM compatibility, and a status code the internet basically forgot it had, put back to work exactly as it was originally intended.
Whether this becomes the standard other chains start copying, or one option among several competing approaches to agent payments, is still an open question — this space is moving fast and CandyChain is far from the only team thinking about machine-native payments. But as a piece of infrastructure, the core idea is hard to argue with: the internet's next major wave of traffic is going to be agents, not humans, and agents need to be able to pay for things without waiting on us.
From settlement requests — automatically. That's the whole pitch, and it's a good one.
More details are live at streams.candychain.io.