SOC 2 Type II-gecertificeerd · ISO 27001

Most conversations about x402 frame it as a replacement for API keys. In reality, the two serve distinct purposes, and developers should think about determining the right tool for their specific architecture.

API keys and x402 represent two different access models for blockchain infrastructure: one built around account credentials, the other around internet-native payments. Understanding the difference makes it easier to decide when to use each.

This post breaks down how each model works and why modern infrastructure increasingly needs both.

The Credential Model Was Built Around Account Identity

The current model for accessing developer infrastructure assumes a known, accountable human at the point of entry. You register with an identity (an email, an organization), receive credentials, and manage them over time.

This model works well and supports much more than just human users. Agents can easily manage endpoints, monitor billing, and interact with infrastructure through administrative APIs. But the system still assumes that someone owns the account behind those credentials. Someone has to register. Someone has to issue the credential. Someone has to be accountable for the account.

For AI agents that spin up dynamically, operate across multiple services, or run in systems where no single human owns the workflow, that assumption becomes a friction point. Not because the tooling is flawed, but because the model was never designed for access without a persistent account relationship.

That is the gap x402 closes.

x402: A Payment Layer Native to HTTP

x402 is an open protocol developed by Coinbase that provides a native payment mechanism for HTTP. It revives the long-dormant HTTP 402 "Payment Required" status code and turns it into a working standard for machine-to-machine commerce.

The flow is simple.

1. A client requests a resource.

2. The server responds with HTTP 402 and payment requirements embedded in the response (price, accepted token, supported payment networks).

3. The client signs a supported payment authorization and retries the request with that payment in the X-PAYMENT header.

4. The server verifies the payment through a facilitator, settles it onchain, and returns the resource.

No account. No API key. No registration. Any client holding a funded wallet can pay and start making requests immediately.

What makes this significant for agent workloads is not just the absence of an account. It is that the entire access lifecycle becomes programmable. An agent can discover what a service costs, fund access from its own wallet, consume the resource, and continue, all within a single workflow, without any step that requires a human to intervene.

The protocol is stateless and chain-agnostic by design, which matters for how it gets implemented in practice. More on that below.

Two Access Models

None of this diminishes what API keys provide.

With x402 available alongside standard API key access, blockchain infrastructure now supports two distinct access models. The choice between them is about the access pattern, not the actor type.

Account-based access (API keys) gives teams full operational control over their infrastructure. This includes configurable rate limits, usage monitoring, predictable billing, and team-level management. It also provides one-stop-shop access to the broader Quicknode platform, including services like Streams, Webhooks, and the Admin API. This model works for teams and their agents alike. An agent operating with an API key has the same platform access as any other client, including administrative capabilities. The credential model fits here because there is a team accountable for it.

Pay-per-use-based access (x402) removes the account requirement entirely. A wallet becomes the identity, and the payment is the authorization. This model works especially well for autonomous agents that need to authenticate and pay without pre-provisioned credentials. It also supports developers building agent-based tools where end users interact with infrastructure without needing their own accounts, low-usage developers who want occasional access across chains without committing to a plan, and privacy-focused users who prefer wallet-based access over account registration.

In practice, many systems will use both. A team might maintain a standard plan for their core application and deploy x402 for agent workloads at the edges. The two models are additive, not competitive. They run in parallel and do not interfere with each other.

How Quicknode Implements x402

Quicknode implements x402 using a drawdown credit model. Instead of signing and paying for every individual call, developers fund a balance once and request draw down from that balance.

This process uses SIWx (Sign-In with X) for wallet-based authentication, supporting both EVM and Solana wallets. Subsequent requests automatically draw down from the funded balance, eliminating the latency and compute overhead of signing individual transactions.

One important design detail: the payment network and query network are decoupled. Stablecoin payments are currently accepted on multiple chains, including Base, Polygon, XLayer, and Solana. An agent paying on any of those networks can query any of the 130+ supported chains across JSON-RPC, REST, gRPC-Web, and WebSocket protocols. You pay on the network that suits your wallet; you query the chain and protocol your application needs.

Developers can test with up to 10,000 free requests against Quicknode's production blockchain endpoints across 130+ networks using stablecoins on supported testnets. No real funds required to get started.

For production deployments, wallet scoping is worth building in from the start. Any EVM-compatible or Solana wallet with supported stablecoins works out of the box, but giving an agent unrestricted spending authority introduces risk. Purpose-built solutions like Coinbase's Agentic Wallets provide constrained spending authority, letting teams define what an agent can spend and on which operations.

The Resulting Model

Where This Is Going

x402 is early, and the ecosystem around it is still taking shape. The protocol is open source, and infrastructure providers, API developers, and tooling builders are beginning to support it.

One of the more interesting developments is the x402 Bazaar, a machine-readable catalog of x402-enabled services. Agents can query the catalog programmatically to discover payable APIs and access them without human provisioning. As the catalog grows, the range of services agents can access autonomously expands as well.

The broader shift is toward infrastructure that supports both access models natively, allowing each to serve the workloads it was designed for. Ultimately, the choice is not between API keys or x402, but how to best leverage both to balance stability with autonomy. By supporting both credentialed and transaction-based access, blockchain infrastructure is finally moving toward a model that is as flexible and borderless as the agents it serves.

Quicknode supports both access paths across 130+ blockchain networks. To learn more, explore the x402 guide or start building with Quicknode’s AI docs.