Quicknode

February 17, 2026 — 11 min read

Quicknode now supports x402 pay-per-request access, giving developers and AI agents instant, wallet-authenticated access to blockchain endpoints across 130+ networks. This includes RPC, WebSocket, REST, and gRPC interfaces. Pay with USDC on Base, Solana, or Polygon and start making calls in minutes.

x402 is an additive access method that complements Quicknode's existing plans. Teams running production workloads benefit from Quicknode's standard plans with SLAs, dedicated support, and credit-based billing. x402 adds a new option for use cases where lightweight, permissionless access is the priority.

This post covers what x402 is, how it works with Quicknode, what you can build with it, and how to get started.

What is x402?

x402 is an open payment protocol developed by Coinbase that brings native payments to HTTP. It revives the long-reserved HTTP 402 "Payment Required" status code and turns it into a working payment layer for the internet.

The concept is straightforward: when a client makes a request to an x402-enabled endpoint without payment, the server responds with a 402 status and includes payment instructions (price, accepted tokens, network, and wallet address). The client signs a USDC payment authorization, attaches it to the request header, and retries. The server verifies the payment through a facilitator, settles it onchain, and returns the requested data.

This is especially significant for AI agents. Traditional payment systems require human-driven signups, credential management, and billing cycles. x402 removes all of that. An agent with a wallet can autonomously discover, pay for, and consume API services without any human intervention.

Why Quicknode Supports x402

Quicknode provides blockchain infrastructure to developers and enterprises across 80+ chains and 130+ networks. Accessing that infrastructure typically involves creating an account and managing API keys, which works well for teams building production applications.

x402 adds a complementary access path for a growing category of users: AI agents, quick prototypers, and developers who want to test something before committing to a plan. With x402 enabled on Quicknode endpoints, anyone (or anything) with a wallet can:

• Access RPC, WebSocket, REST, and gRPC endpoints across 130+ blockchain networks

• Pay-per-request with USDC using a drawdown credit model. Fund your balance once, and each request automatically draws down from your credits, so there's no per-call payment latency.

• Authenticate using wallet-based auth (Sign-In with X / SIWx), supporting both EVM and Solana wallets

• Get started with up to 10,000 free requests using devnet USDC

The payment network is decoupled from the endpoints you query. That means you can pay with USDC on Base and make Solana calls, or pay with Solana USDC and query Ethereum, or pay with Polygon USDC. The chain you pay on does not need to match the chain you are querying.

x402 vs Standard Quicknode Plans

x402 is additive. It does not replace Quicknode's standard plans. Teams with production workloads should continue using standard SLA plans, dedicated support, and higher rate limits.

Supported Payment Networks

Quicknode's x402 implementation currently supports USDC payments on:

• Base (mainnet and Sepolia testnet)

• Solana (mainnet and devnet)

• Polygon (mainnet and Amoy testnet)

Additional payment networks are actively being added. The x402 protocol is chain-agnostic by design, so expanding support is straightforward as new facilitators come online.

For testing, developers can use devnet USDC on Base Sepolia, Solana devnet, or Polygon Amoy to get up to 10,000 free requests against any of Quicknode's production endpoints.

How It Works: The Technical Flow

Here is what happens under the hood when an agent or developer makes an x402-enabled request to Quicknode:

1. Initial request: The client sends an HTTP request to the Quicknode x402 endpoint without payment headers.

2. 402 response: The server responds with HTTP 402 and a PAYMENT-REQUIRED header containing payment details: the price per request, accepted tokens (USDC), supported networks (Base, Solana, Polygon), and the wallet address to pay.

3. Wallet authentication: The client authenticates using SIWx (Sign-In with X). Quicknode's implementation uses SIWx to issue JWT tokens, optimizing performance by avoiding per-request signature verification overhead (which would add 10-20ms per call).

4. Payment authorization: The client signs a USDC transfer authorization using EIP-3009 (for EVM) or a Solana signing method equivalent. This is a gasless operation for the client.

5. Retry with payment: The client retries the original request with the signed payment in the X-PAYMENT header.

6. Verification and settlement: The facilitator verifies the signed authorization, settles the USDC transfer onchain, and confirms the payment.

7. Response: Quicknode returns the requested data.

The x402 client libraries handle steps 2 through 6 automatically. From a developer's perspective, the code appears to be a standard HTTP request.

What You Can Build

AI Agents with Autonomous Blockchain Access

The most immediate use case is enabling AI agents to interact with blockchain data without pre-provisioned API keys. An agent can:

• Query token prices and portfolio balances across chains

• Monitor wallet activity and transaction history

• Execute blockchain reads for DeFi protocols

• Access historical block data for analysis

All without a human having to set up an account first.

MCP Server for AI-Assisted Infrastructure Management

Quicknode's official MCP server (@quicknode/mcp) brings blockchain infrastructure management directly into AI assistants like Claude and Cursor. With the MCP server, an AI assistant can set up and configure Quicknode endpoints across multiple networks, monitor usage and billing, and manage infrastructure through natural language. This pairs well with x402: use the MCP server to provision and manage your Quicknode infrastructure, and use x402 for lightweight, wallet-authenticated endpoint access.

Install via npx:

npx -y @quicknode/mcp

See the package on npm: npmjs.com/package/@quicknode/mcp

Blockchain Skills for AI Coding Agents

Quicknode also offers Blockchain Skills, a lightweight reference package that gives AI coding agents accurate, up-to-date knowledge of the full Quicknode product suite. One command adds it to Claude Code, Cursor, Codex, Windsurf, or any skills-compatible agent:

npx skills add quicknode-labs/blockchain-skills

At around 240 tokens, it gives your agent the right endpoints, correct parameters, and current best practices without bloating the context window. Fully open source at github.com/quicknode-labs/blockchain-skills. Browse it on the Skills registry at skills.sh/quicknode-labs/blockchain-skills.

Pay-Per-Request Development and Prototyping

Developers who want to test an idea across multiple chains can use x402 to access any of Quicknode's supported networks without committing to a plan. Spin up a prototype, pay a few cents in USDC for the RPC calls you actually make, and move on.

Quicknode's Admin API provides full programmatic control over your account and infrastructure configuration, letting agents and developers create endpoints, manage security, and monitor usage through simple REST calls.

HyperCore CLI with x402

Quicknode's open-source HyperCore CLI tool also supports x402 pay-per-request access. Developers can stream and backfill Hyperliquid datasets (trades, orders, fills, TWAP, book updates, events, blocks) directly from the terminal, paying per request with a wallet instead of needing a Quicknode account.

Install it globally:

npm install -g @quicknode/hypercore-cli

The CLI supports real-time streaming over WebSocket and gRPC, auto-reconnect with gap recovery, historical backfill, and output to JSON, CSV, or SQLite.

Content and API Monetization

Beyond consuming x402-enabled services, developers can also build their own x402-powered APIs using Quicknode's open-source tooling:

• x402-rails: A Ruby gem for adding x402 paywalls to Rails applications

• x402-payments: A Ruby gem for generating signed payment headers

• qn-x402-examples: Example implementations for both EVM and Solana payment flows

The @quicknode/x402 and @quicknode/x402-solana npm Packages

The @quicknode/x402 npm package is the recommended way to interact with Quicknode's x402 gateway. It wraps the full authentication and payment flow into a single install: SIWX wallet auth, JWT session management, and x402 payment handling.

Previously, integrating with x402 on Quicknode required manually handling the SIWX signing, JWT token lifecycle, and payment header construction. This package abstracts all of that. Agents and developers can install the package, connect a wallet, and start making authenticated, paid requests in minutes.

npm i @quicknode/x402

The package supports both EVM and Solana wallets and works across all supported payment networks (Base, Solana, Polygon).

@quicknode/x402 on npm: npmjs.com/package/@quicknode/x402

Source: github.com/quicknode-labs/quicknode-x402

For Solana users: the @quicknode/x402-solana npm wraps @quicknode-x402 and adds the ability to use Solana Kit with Quicknode's RPC services instantly.

@quicknode/x402-solana on npm: npmjs.com/package/@quicknode/x402-solana

Source: github.com/quicknode-labs/x402-solana

The Admin API

Quicknode's Admin API gives developers and agents full programmatic control over account and infrastructure operations, from creating endpoints and configuring security to monitoring usage and managing teams, all through standard REST calls. Combined with x402 and the MCP server, it means an agent can not only query blockchain data but also provision and manage the infrastructure it depends on.

Getting Started

Prerequisites

• A crypto wallet (any EVM-compatible wallet or Solana wallet)

• USDC on Base, Polygon or Solana (or devnet USDC for free testing)

• Node.js 18+ and the @quicknode/x402 package (npm i @quicknode/x402)

Quick Start with Devnet USDC (Free)

For testing, you can use devnet USDC to make up to 10,000 free requests:

1. Get Base Sepolia USDC from the Circle USDC faucet

2. Or get Solana devnet USDC from the Solana faucet

3. Or get Polygon Amoy USDC from the Circle USDC faucet

4. Follow the Getting Started guide

Production Setup

For production usage with real USDC:

1. Fund your wallet with USDC on Base, Solana, or Polygon

2. Install the @quicknode/x402 package (npm i @quicknode/x402)

3. Point your requests at the Quicknode x402 endpoint

The per-request payment is minimal, making this viable for high-volume agent workloads and development testing alike.

Open Source and Ecosystem

Quicknode has invested heavily in the x402 ecosystem beyond just enabling payments on its own endpoints:

• x402 Explorer: A sample app for testing x402 payment flows

• x402 Video Paywall Demo: A sample showing how to paywall video content with x402

• x402 Rails Integration: A guide for adding x402 to Ruby on Rails APIs

• x402 Paywall Guide: A comprehensive walkthrough of implementing x402

• llms.txt: Machine-readable documentation for LLM and agent discoverability. The protocol itself is open source and maintained by Coinbase at github.com/coinbase/x402

• @quicknode/x402 package:

Frequently Asked Questions

What is x402 on Quicknode?

x402 on Quicknode is an alpha capability that enables wallet-authenticated, pay-per-request access to Quicknode endpoints (RPC, WebSocket, REST, and gRPC) using USDC. It uses the HTTP 402 Payment Required standard and is built on Coinbase's open x402 protocol.

Does x402 replace Quicknode accounts or plans?

No. x402 is additive. It provides a complementary access path alongside Quicknode's standard plans. Teams running production workloads should continue using standard plans for SLAs, dedicated support, and higher rate limits. x402 is designed for AI agents, rapid prototyping, and permissionless access.

Does x402 require a Quicknode account?

No. x402 access is wallet-authenticated. You need a crypto wallet and USDC, not a Quicknode account or API key.

What payment networks are supported?

USDC payments are currently supported on Base (mainnet and Sepolia testnet), Solana (mainnet and devnet), and Polygon (mainnet and Amoy testnet). Additional payment networks are being added. The payment network does not need to match the chain you are querying.

Can AI agents use x402 autonomously?

Yes. x402 is designed for autonomous agent access. An agent with a funded wallet can discover, authenticate, pay for, and consume Quicknode endpoints without any human intervention.

Is x402 production-ready?

x402 on Quicknode is currently in alpha. It is functional and available for use, but does not carry the same SLA guarantees as standard Quicknode plans. For production workloads requiring uptime guarantees and dedicated support, use a standard Quicknode plan.

How much does each request cost?

Pay-per-request pricing is minimal and denominated in USDC. Developers can test for free using devnet USDC, which provides up to 10,000 free requests against production RPC endpoints.

What wallets are supported for authentication?

Any EVM-compatible wallet or Solana wallet. Authentication uses SIWx (Sign-In with X), which supports both EVM and Solana wallet signing.

Technical Summary

Resources

• Guide: Access Quicknode Endpoints with x402 Payments

• Examples: github.com/quicknode-labs/qn-guide-examples

• Video walkthrough: How to Get Started with x402 on Quicknode

• x402 Protocol Explainer: What is the x402 Payment Protocol?

• Sample Apps: Quicknode Sample App Library

• HyperCore CLI: npmjs.com/package/@quicknode/hypercore-cli

• llms.txt: x402.quicknode.com/llms.txt

• x402 Ecosystem:

Quicknode provides blockchain infrastructure to developers and enterprises across 80+ chains and 130+ networks. Get started with a standard plan or access endpoints instantly with x402 pay-per-request access.