Cloudflare's Monetization Gateway runs on x402 — and Solana is a settlement rail

On July 1, 2026, Cloudflare announced the Monetization Gateway — a way to charge for any resource sitting behind Cloudflare: web pages, datasets, APIs, and MCP tools. It is opening as a waitlist, and it is built on x402, the HTTP 402 payment protocol. Payment happens in stablecoins, and the whole handshake — the metering, the payment exchange, and the settlement — moves off your origin and onto Cloudflare's edge across 330+ cities.

For a Solana developer, two facts make this worth reading past the headline. First, x402 is rail-agnostic, and Cloudflare's own x402 implementation — the "exact" payment scheme — already runs on Solana. Second, Cloudflare co-founded the x402 Foundation. When the company that sits in front of roughly a fifth of the web standardizes on the exact payment primitive Solana has been shipping at scale, that is not a competing product. That is the demand side arriving.

The problem Cloudflare is naming

The web's two business models — ads and subscriptions — assume a human on the other end. An AI agent views no ads and signs up for no monthly plan. It consumes a page, an API call, or a tool invocation once and moves on. Cloudflare's framing is blunt: below a certain price, collecting the payment used to cost more than the payment was worth. Card rails have per-transaction floors and multi-day settlement; a fraction-of-a-cent charge per API call is simply uneconomical on them.

Stablecoin micropayments are the escape. Cloudflare's pricing examples are all sub-dollar and usage-based:

• a few cents per web search, billed per call;
• $0.001 base plus $0.01/MB for an upload;
• $0.99 per resolved support escalation — outcome-based pricing, not per-request.

None of those clear on a credit card. All of them clear on a chain that settles in under a second for a fraction of a cent — which is exactly the lane Solana occupies.

How the 402 flow works — now at the edge

If you have read our x402 primer or Build an x402 seller on Solana, the handshake is familiar. What Cloudflare changes is where it runs.

Client (agent)                 Cloudflare edge                 Your origin
     │                               │                               │
     │  GET /api/premium/report      │                               │
     │──────────────────────────────▶│  (no valid payment)           │
     │                               │                               │
     │      402 Payment Required      │                               │
     │◀──────────────────────────────│  { price, asset, network,     │
     │                               │    payTo, scheme: "exact" }    │
     │                               │                               │
     │  pay on-chain, retry with      │                               │
     │  X-PAYMENT proof               │                               │
     │──────────────────────────────▶│  verify + settle via          │
     │                               │  facilitator (off-origin)      │
     │                               │                               │
     │                               │  200 OK  ─────────────────────▶│  request finally
     │           200 OK               │◀───────────────────────────────  reaches origin
     │◀──────────────────────────────│                               │

The key line is the last one: your origin never sees the unpaid request, the 402, or the settlement. Cloudflare intercepts at the edge, mints the 402 with your price and payout details, verifies the returned X-PAYMENT header through a facilitator, and only forwards the request to your server once payment is confirmed. It can even intercept a 401 Unauthorized from your origin and transform it into a 402 with pricing attached.

You configure the rules — which paths, which verbs, which prices — from the dashboard, the Cloudflare API, or Terraform. A rule reads about like you'd expect: "charge $0.01 for every GET or POST to /api/premium/*."

Where Solana fits

Cloudflare accepts only stablecoins at launch (it names USDC and Open USD), and its x402 documentation is explicit that the "exact" scheme operates on EVM, Solana, Aptos, Stellar, Hedera, and Sui. Solana is not an afterthought here — across the x402 ecosystem it has become the primary settlement network alongside Base, precisely because of sub-second finality and fees around $0.00025. When an agent is firing thousands of penny payments, the settlement layer's cost and latency are the product.

The Solana "exact" scheme is not the EVM one with the chain field swapped. It has its own shape, covered in depth in our seller guide: the client returns a partially-signed transaction carrying a TransferChecked of USDC to the merchant, a memo used as a nonce for replay protection, and a recent blockhash that bounds its validity. The facilitator co-signs and submits. The payload an agent sends back to Cloudflare therefore looks like this on Solana:

// X-PAYMENT (base64-decoded) — Solana "exact" scheme, abridged
{
  "x402Version": 1,
  "scheme": "exact",
  "network": "solana",
  "payload": {
    "transaction": "<base64 partially-signed tx>",  // TransferChecked USDC → payTo
    "memo": "<nonce>",                                // replay protection
    "blockhash": "<recent blockhash>"                 // bounds tx validity
  }
}

Cloudflare hands this to a facilitator — the public one at x402.org/facilitator is operated by Coinbase and covers Solana at no cost — which verifies and settles the transfer on-chain. If you'd rather not depend on a third party, running your own facilitator that settles on Solana is a well-trodden path; PayAI ships one, and we cover both the build and the trade-offs in the PayAI facilitator write-up.

What actually changes for a Solana x402 seller

Today, accepting x402 on Solana means running middleware on your origin: it emits the 402, parses the X-PAYMENT header, calls a facilitator's verify and settle endpoints, and gates the response. That is a real amount of request-path code sitting in your hot loop.

The Monetization Gateway proposes to lift that off you:

• No origin middleware. Metering, the 402, verification, and settlement run at the edge. Your server can go back to just serving the resource, unaware money changed hands.
• Origin protection. High volumes of unpaid and payment-retry traffic never reach you — they terminate at the edge, in front of your infrastructure and your Solana RPC.
• One control plane, many rails. Because x402 is rail-agnostic, the same pricing rules can, in principle, accept payment on Solana or an EVM chain without you writing per-chain gating logic. You set the price and payout; the protocol negotiates the rail.
• Optional identity. Cloudflare pairs this with Web Bot Auth for verified agent identity, so a seller can require a known, signed agent — not just anonymous payment — before serving.

The trade-off is the usual one: convenience for dependency. Edge-terminated settlement means Cloudflare and its chosen facilitator sit in your payment path. For many sellers that is a fine deal; for those who want to own the rail end to end, the self-hosted-facilitator route we document still applies, and nothing stops you from running x402 middleware on a Solana origin the way you do today.

The signal, not just the feature

Step back from the config. The x402 Foundation — launched by Coinbase and Cloudflare, now under Linux Foundation governance — counts Google, Visa, AWS, Circle, Anthropic, and Vercel among its members. Cloudflare shipping a first-party product on top of it, one that terminates payments at the edge for any customer behind their network, is the clearest sign yet that machine-to-machine micropayments are moving from crypto-native experiment to default web infrastructure.

Solana does not need to win that fight; it needs to be a rail when it settles, and it already is one in Cloudflare's own implementation. The work for Solana builders is unglamorous and concrete: make sure the facilitators that settle on Solana are fast and reliable, keep the "exact" scheme's replay protection tight, and build the sellers — priced APIs, datasets, MCP tools — that agents will actually pay for. For the wider context on who's competing to be the agent payment layer, see our agentic payments landscape and x402 use cases and patterns.

The Monetization Gateway is a waitlist today, not general availability. But the direction is set: HTTP 402 is becoming a product you configure, not a protocol you hand-roll — and when the bill settles, it can settle on Solana.