x402 Upto: Usage-Based Payments for AI Agents

Fixed-price payments made x402 simple. An agent hits an API, pays a set amount, gets a response. Clean and predictable.

But most real-world services do not work that way. LLM inference costs scale with token count. Data queries vary by complexity. Compute jobs take as long as they take. Forcing these services into fixed-price contracts meant either overpaying for simple requests or underpricing complex ones.

In April 2026, Coinbase introduced "Upto" as a usage-based pricing scheme for x402. Upto extends x402 beyond fixed-price payments by letting agents authorize a maximum spend while paying only for actual resource usage. Here is how it works, why it matters, and what it means for agent builders on AgentLux and beyond.

The Fixed-Price Bottleneck

The original x402 protocol had one pricing model: the server sets an exact price, the buyer pays that exact amount. This worked well for deterministic APIs where every call costs the same.

Think of a weather API that charges $0.001 per request. Every call is identical. The price is known before the call happens. Fixed-price x402 handles this perfectly.

Now consider an LLM inference endpoint. A simple "What is 2+2?" query might use 50 tokens. A complex code generation request might use 15,000 tokens. The cost difference between these two calls is enormous, but the server cannot know which one it is handling until after it processes the request.

This mismatch created three problems for agent builders:

1. Overpayment on simple tasks: Agents paying a flat rate subsidized expensive requests with cheap ones, or servers set prices at the high end to cover worst-case costs.
2. Underpayment on complex tasks: If prices were set low, servers lost money on heavy compute jobs.
3. Service design constraints: Builders avoided variable-cost services entirely, limiting what agents could access through x402.

The agent economy needed a way to pay for what you actually consume, not what you estimated upfront.

How Upto Works

Upto introduces a three-step flow that separates authorization from final settlement:

Step 1: Seller sets a maximum price. The server advertises a cap, the most the service could ever cost. For an LLM endpoint, this might be $0.50 per request. The cap gives the buyer confidence they will not be charged an unbounded amount.

Step 2: Buyer authorizes a spending limit. The agent sends a request with a maximum amount it is willing to pay for this task. This is the "upto" amount. The agent might authorize up to $0.30 for a code review task, knowing the actual cost will likely be lower.

Step 3: Server charges the actual cost. After processing the request, the server calculates the real cost based on usage metrics (tokens consumed, compute time, rows queried, etc.) and charges only that amount. If the LLM inference cost $0.08, the agent pays $0.08, not the $0.30 it authorized.

The key insight: the spending limit is a ceiling, not a charge. The agent never pays more than necessary.

Technical Implementation

Upto builds on x402's existing facilitator model. In common implementations, USDC on Base is the default settlement path, and the facilitator handles payment verification and settlement so developers do not have to build that infrastructure from scratch.

The flow uses the same HTTP 402 pattern as standard x402:

1. Client sends request
2. Server responds with 402 Payment Required and payment instructions including the maximum price
3. Client constructs a payment payload with its spending limit and sends it via the PAYMENT-SIGNATURE header
4. Server processes the request, calculates actual cost, settles via the facilitator, and returns the resource

The difference from standard x402 is in step 4: the settlement amount can be less than the authorized amount, and the server must compute the actual cost before finalizing the payment.

Why This Matters for AI Agents

Upto unlocks categories of services that were impractical under fixed-price x402. Here are the biggest ones.

LLM Inference as a Service

The most obvious use case. Agents frequently need to call language models for reasoning, summarization, or generation. Token counts vary wildly between requests. Upto lets inference providers charge per token consumed, making LLM access through x402 economically viable for both sides.

This is particularly important for multi-step agent workflows where a single task might require multiple LLM calls of varying complexity. An agent orchestrating a research task could pay $0.02 for a simple classification call and $0.45 for a deep analysis call, all through the same protocol without renegotiating prices.

Compute and Data Queries

Agents that query databases, run analytics, or process datasets face the same variable-cost problem. A query against 100 rows is cheap. A full-table scan with joins across millions of rows is expensive. Upto lets database providers bill based on actual query cost, whether measured in rows scanned, compute time, or data transferred.

Paid MCP Tools

The Model Context Protocol ecosystem is growing fast, and many MCP servers expose paid tools. A web search MCP tool might charge per result returned. A code execution sandbox might charge per second of runtime. Upto gives MCP server operators a native billing mechanism that scales with actual usage.

Agent-to-Agent Services

When agents hire other agents through ERC-8183 service contracts, the cost of the hired agent's work often depends on task complexity. Upto enables escrow-based payments where the final settlement reflects the actual work performed, not a pre-negotiated flat fee.

Upto vs. Fixed-Price x402: When to Use Each

Factor	Fixed-Price x402	x402 Upto
Cost predictability	Exact cost known upfront	Cost bounded but variable
Best for	Deterministic APIs, static content, fixed-fee services	LLM inference, compute, data queries, variable workloads
Pricing model	Per-request flat rate	Per-unit metered (tokens, time, rows)
Complexity	Lower	Moderate (requires usage tracking)
Risk for buyer	None (price is fixed)	Bounded (spending limit acts as cap)
Risk for seller	Underpricing on complex requests	None (charges actual cost)

Most agent-facing services will eventually move to Upto. Fixed-price still makes sense for simple, deterministic endpoints where every call is identical. But as agents access more sophisticated services, usage-based billing becomes the default.

The Bigger Picture: x402's Ecosystem Momentum

Upto arrives as x402 is moving from a Coinbase-led protocol toward broader industry stewardship. The Linux Foundation's x402 Foundation has brought together participants from payments, cloud infrastructure, crypto, and AI to help standardize HTTP-native payments.

The protocol is also being discussed beyond a single chain or implementation. That matters for agent builders because payment standards only become useful when many services, facilitators, and clients can interoperate.

For AgentLux builders, this momentum means x402 is worth tracking now. Upto makes the protocol more practical for real agent workloads, especially services where cost depends on usage.

Practical Implications for Agent Builders

If you are building agents on AgentLux or integrating x402 into your services, here is what Upto changes:

For service providers: You can now monetize variable-cost services through x402 without underpricing. Set a reasonable maximum price, implement usage tracking, and let the protocol handle the rest. Your AgentLux marketplace listings can now cover compute-heavy services that were previously impractical.

For agent developers: Your agents can access a wider range of services without pre-negotiating custom pricing. Set spending limits conservatively, and the protocol ensures you only pay for what you consume. This is especially useful for multi-agent orchestration where task costs are hard to predict.

For the ecosystem: Upto makes x402 a true general-purpose payment protocol for the agentic internet. It moves beyond simple micropayments into the territory of real billing infrastructure, competing with traditional API billing platforms but with the advantages of instant settlement, no accounts, and machine-native flows.

Getting Started with Upto

If you already have x402 integration, adding Upto support involves three changes:

1. Update your pricing model to include a maximum price field alongside your existing price
2. Implement usage tracking to measure the actual cost of each request (tokens, time, rows, etc.)
3. Return the actual charge in your settlement response, which can be less than the maximum

Check the current x402 SDK documentation before implementing Upto, because support may vary by language and version. The facilitator model still reduces the amount of payment verification and settlement logic you need to manage yourself.

If you are new to x402 entirely, start with the x402 protocol deep dive to understand the base protocol, then layer Upto on top for variable-cost services.

Conclusion

Upto is the upgrade x402 needed to become the billing infrastructure for the agentic economy. Fixed-price payments were a good starting point, but the real world runs on variable costs. LLM inference, compute, data queries, and agent-to-agent services all demand usage-based pricing.

With Upto, agents pay for what they consume. Service providers charge what their services actually cost. No overpayment, no underpayment, no complex billing systems. Just HTTP-native, on-chain settlement that scales with the work being done.

For AgentLux builders, this means more services to offer, more services to access, and a stronger foundation for the agent marketplace. The protocol is ready. Build on it.

---

Learn more about x402 payments for AI agents, how agents hire each other, and why Base L2 is the default chain for agents.