Monetizing AI Agents at the Edge with Akamai Functions

For 20 years, the web’s implicit contract was simple: Content and API owners give something away (a page, a data feed, a compute cycle); ads, subscriptions, or direct billing pay the bills; and automated clients (mostly search engines) play by the unwritten rules.

Two types of AI agents are breaking that contract, each in a distinct way:

1. Content-scraping bots, such as GPTBot, ClaudeBot, PerplexityBot, and CCBot ,  fetch and repackage publisher content without clicking ads, converting to subscribers, or sending human traffic back to the original publisher.

2. Task-executing agents now autonomously call paid APIs, data feeds, and compute services on behalf of a human or another agent, entirely without a human in the loop, to click “buy” or enter a credit card.

Both types of bot activity create the same underlying problem: The resource owner needs a programmatic, per-request way to charge an automated client so they either eat the cost, block the traffic, or force it through slow, human-shaped payment flows (API keys, prepaid credits, manual invoicing) that don’t fit how agents actually operate.

Blocking outright is a defensive, not a strategic, move  —  for content, it just pushes you out of whatever AI-mediated discovery layer comes next; for APIs and data, it forecloses an entire emerging buyer category. The better move is the one that markets have always made when a new class of consumer showed up: Charge for access, in a form that the consumer class can actually transact in. For agents, that means no signup forms, no credit cards, no human-in-the-loop approval  —  just a request, a price, a signature, and a retry.

That’s exactly what the x402 protocol is for. It’s an open standard that repurposes the long-dormant HTTP 402 Payment Required status code into a machine-readable handshake for stablecoin micropayments. 

In this blog post, I’ll examine the x402 protocol using a publisher content paywall as an example because it’s the easiest to visualize end to end .

Here’s the strategic insight this demo was built around: Akamai customers shouldn’t have to touch their origin infrastructure to monetize agent traffic.

Most origins are legacy content management systems (CMSs), hand-rolled back ends, or third-party platforms nobody wants to modify. It is a nonstarter for most teams to do any of the following just to charge automated clients:

• Integrate a crypto wallet SDK

• Add payment-verification middleware

• Maintain PCI-adjacent security posture

It’s the same reason CDNs win by living in front of origins instead of requiring origin rewrites.

We already sit in front of the traffic as the reverse proxy of record. That position is the leverage point.

Figure 1 illustrates the pitch in one diagram: The origin never sees agent traffic that hasn’t paid, and never had to change a single line of code to make that true. All the new logic  —  detection, payment negotiation, settlement  —  lives at the edge, as a discrete, addable layer. The origin behind it could just as easily be a paid weather API, a market-data feed, or an MCP tool server as a news site.

There’s a second strategic decision baked into this architecture: running the paywall as a Spin/Wasm on Akamai Functions instead of a traditional always-on origin service.

This matters commercially, not just technically.

• The pay-as-you-go cost shape matches pay-as-you-go revenue. The gateway only executes  —  and only costs anything  —  when an agent actually shows up. A customer with low agent traffic today pays almost nothing; one who suddenly gets hit hard by a new agent doesn’t need to provision for it. The cost curve tracks the monetization curve.

• There is no capacity planning, no idle infrastructure. There’s no origin-side fleet to size for a traffic pattern (agent bursts) that is inherently bursty and unpredictable.

• Cold start latency is solved by running in Wasm at the edge, not by overprovisioning an origin container fleet in one region.

• It’s additive, not invasive. A customer can turn this on for one property, one path pattern, or one bot category  —  and turn it back off  —  via Property Manager rule changes, with zero deploys to their own stack.

In short: This isn’t just “a bot paywall.” It’s a template for an Akamai customer to build edge native monetization middleware  that allows Akamai to turn detection signal (Bot & Agent Control) and edge compute (Akamai Functions) into a direct new revenue line for customers, with the CDN doing the commercial enablement work the origin never had to.

Even though the audience is bots, latency isn’t free to ignore . Agents run on budgets and timeouts, too, and a slow gateway will just get skipped or blocklisted by the agent operator, killing the monetization opportunity. Running the handshake as a compiled Wasm component at Akamai’s edge, geographically close to wherever the agent’s request originated, keeps the 402 → verify → settle → 200 round trip fast enough that it doesn’t become the agent’s next reason to stop calling you.

When exposing web services to AI agents and automated crawlers, enforcing monetization without disturbing legacy user traffic requires a modular, Zero Trust boundary. This architecture achieves seamless payment verification through four decoupled components, each handling a single responsibility along the request pipeline: 

1. Property Manager handles precise traffic discrimination. 

2. Akamai Functions executes edge-side paywall logic via Wasm. 

3. The x402 facilitator isolates the cryptographic and blockchain transaction settlement. 

4. The origin remains entirely untouched while serving verified requests. 

Four moving pieces, each with a distinct, narrow job (Figure 2).

The elegance of x402 is that this entire negotiation — price discovery, signing, verification, settlement — happens in that single retried HTTP request. There's no OAuth-style redirect dance, no account creation, no API key provisioning. The agent's wallet is its identity and its payment method (Figure 3).

Building a functional, edge-based micro-monetization pipeline requires a strict separation of concerns and an exact alignment with x402 specifications. The following implementation notes cover the core mechanics of how the solution operates in production — and the key details that make or break it. 

Akamai customers can go from zero monetization of agent traffic to a working, on-chain settlement payment gateway by adding one Property Manager rule and deploying one small edge function — with zero or minimal commits to their origin codebase.

The entire payment negotiation completes within a single HTTP request/retry cycle, at edge latency, in a serverless runtime.

Check out the demo code repository. This demo intentionally keeps a few things loose that a production rollout would tighten up: replay protection on the `X-PAYMENT` header (a nonce plus KV check), a real pricing/session model instead of literal pay-per-hit. None of those are architectural changes — they're hardening on top of a pattern that already works end to end, on Akamai's edge, today.

This is worth answering honestly rather than assuming, because it changes who should build this now.

x402 itself has real, if early, traction — its public dashboard reports approximately 75 million transactions, ~US$24M in volume, ~94,000 unique buyers, and ~22,000 sellers over a recent 30-day window (self-reported by x402.org, therefore directional, not independently audited). The protocol also has real institutional backing: Coinbase, Circle, AWS, Anthropic, and Vercel are named collaborators, and a Linux Foundation–backed x402 Foundation now governs the spec  — which signals  a genuine standardization, not a single vendor’s side project.

But look closely at what’s being purchased, and a pattern emerges: The documented adoption is overwhelmingly agent-to-infrastructure spend —  agents paying for GPU inference (Hyperbolic), compute provisioning (OpenMind), real-time market/social data (Zyte, Neynar, Boosty Labs), and MCP tool calls (Anthropic’s own protocol). These are cases in which an agent is completing a task for a paying human or business and needs to acquire a resource to do it  —  it’s an easy, already-budgeted purchase.

General-purpose content-scraping bots (GPTBot, ClaudeBot, PerplexityBot, CCBot) that autonomously pay a publisher’s 402 challenge in the wild may be next. Today’s crawlers aren’t wallet-equipped or configured to autopay  —  they’re built to crawl freely or be blocked. However, a 2026 article suggests that Google has already started a pilot program with selected publishers to pay for their content.