Quicknode

April 29, 2026 — 4 min read

Nanopayments powered by Circle Gateway is live on mainnet today, and Quicknode is a day-one launch partner.

Nanopayments gives developers, agentic platforms, and infrastructure teams a purpose-built financial rail for machine-scale commerce: gas-free USDC payments down to $0.000001, instant verification, batched settlement, and unified liquidity across a growing set of chains. For builders on Quicknode, it's the pricing primitive the agent economy has been waiting for.

Why This Matters

Internet commerce is no longer just humans clicking checkout buttons. Its agents, APIs, and software transact continuously at denominations that traditional payment rails were never designed for. Gas fees on standard onchain transfers often exceed the payment itself. Card networks carry fixed costs that make sub-cent economics impossible. Both models break before a product reaches scale.

The x402 protocol began fixing this, processing more than $100 million in payments in its first few months. Researchers now estimate agentic commerce could reach $5 trillion by 2030. The demand is real. What was missing was the payment primitive underneath.

Nanopayments is that primitive.

What Nanopayments Unlocks

Powered by Circle Gateway's unified balance model, Nanopayments lets developers deposit USDC into a non-custodial smart contract and access liquidity across supported chains in under 500 milliseconds. Thousands of transactions are batched and settled onchain in the background, so individual payments feel instant and cost essentially nothing.

For builders, the result is:

• Gas-free USDC transfers down to $0.000001

• Instant verification that unlocks sub-second user experience

• Batched settlement that makes high-frequency payments practical

• Chain-abstracted UX through Circle Gateway's unified liquidity

• A non-custodial model where payments only execute from user-signed authorizations

• Full compatibility with x402 as an additive payment option, not a replacement

You do not have to choose between open standards and better economics. Nanopayments gives you both.

How It Works

1. A user deposits USDC into a Circle Gateway smart contract, establishing a balance usable across supported chains.

2. An agent requests a paid resource. The merchant returns an HTTP 402 with payment instructions.

3. The agent signs an EIP-3009 authorization for the requested amount, preserving the non-custodial model.

4. The agent resubmits the request with the signed authorization. The merchant forwards it to Nanopayments for verification.

5. Nanopayments verifies the signature instantly, checks the balance, deducts the authorized amount, and returns success. The merchant gets paid.

Batched settlement happens in the background. Developers see a clean pay-per-request flow. That's it.

Where It Runs

Nanopayments is live on mainnet across Base, Polygon, Arbitrum, HyperEVM, and more, with full-chain coverage rolling out via Circle Gateway. Arc testnet is also supported, giving teams a prototyping environment ahead of Arc's mainnet launch.

For teams building on these networks through Quicknode, Nanopayments plugs directly into the workflows you already have.

Why Quicknode Is a Launch Partner

Quicknode already supports x402 across 80+ chains, with real mainnet revenue flowing through pay-per-request infrastructure. Nanopayments extends that foundation with the economics the agent economy actually demands: payments small enough to match the cost of a single API call, fast enough to not slow agents down, and standard enough to work across the full stack.

Agents hitting RPC endpoints. Bots crawling onchain data. Inference pipelines paying per call. Memory writes, dataset reads, per-second compute. These flows require programmable, neutral, and efficient infrastructure for very small denominations. That is exactly what Nanopayments delivers, and exactly the traffic Quicknode was built to serve.

Using Nanopayments with Quicknode

Here is what calling a Quicknode RPC endpoint looks like through an x402 flow with Nanopayments handling payment:

curl -X POST https://your-endpoint.quicknode.com \
  -H "Content-Type: application/json" \
  -H "X-Payment: <signed_authorization>" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": 1
  }'

import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const fetchWithPayment = wrapFetchWithPayment(fetch, account);

const response = await fetchWithPayment(
  "https://your-endpoint.quicknode.com",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      method: "eth_blockNumber",
      params: [],
      id: 1,
    }),
  }
);

const data = await response.json();

The client handles the payment handshake. Your code just makes requests. Gateway settles the payment in the background.

What You Can Build

The use cases stretch well beyond RPC:

• Agent-to-agent and API payments for data, compute, inference, and specialized services

• Usage-based billing by the request, second, or event, no subscriptions required

• Data and analytics markets monetizing RPC, wallet intelligence, and market feeds at a granular scale

• Content and licensing flows for pay-per-article, pay-per-asset, and instant digital media access

• Games, rewards, and machine networks powering micro-incentives and M2M compensation

Anywhere payments are too small or too frequent for traditional rails, Nanopayments fits.

Start Building

Nanopayments powered by Circle Gateway is live on mainnet. Quicknode endpoints are ready for x402 flows across 80+ chains.

Get started with our x402 docs, explore the full agentic stack at quicknode.com/agents, or check Circle's Nanopayments quickstart guides to integrate directly.

The agent economy has its financial rail. Time to build on it.