# Agent-Native Blockchain Infrastructure | Quicknode

Give your agents reliable RPC access, protocol context, and execution capabilities across every major chain. 80+ networks, zero friction.

---

## Hero

**Badge:** Agents

**Title:** Agent-Native Blockchain Infrastructure

**Subtitle:** Give your agents reliable RPC access, protocol context, and execution capabilities across every major chain. 80+ networks, zero friction.

**CTAs:**
- Explore AI Tools — https://www.quicknode.com/docs/build-with-ai
- View Documentation — https://www.quicknode.com/docs/build-with-ai

---

## AI Integration Tools

**Badge:** AI Integration Tools

**Title:** The Tools Your Agents Need to Go On-Chain

**Subtitle:** From crypto-native authentication to natural language queries, everything your agents need to operate on-chain.

### x402

**Label:** x402

**Headline:** Authenticate and Pay for RPC Access Without API Keys

**Description:** HTTP 402-based authentication for AI agents. Authorize and pay for RPC access using cryptocurrency. Zero setup friction across 130+ networks.

**CTA:** Read the x402 guide — https://www.quicknode.com/guides/x402/access-quicknode-endpoints-with-x402-payments

---

### Agent Subscription API

**Label:** Agent Subscription API

**Headline:** Create Quicknode Accounts and Endpoints Autonomously

**Description:** Programmatic subscription provisioning for agents that need a full Quicknode account — no human signup. Pay once via x402 or MPP to create a subscription (`POST https://www.quicknode.com/api/v1/agent/subscriptions`) and receive a `QN_*` API key. Then create RPC endpoints via the Admin API (`POST https://api.quicknode.com/v0/endpoints`). Use `GET https://api.quicknode.com/v0/chains` to discover valid chain and network slug values before provisioning.

**CTA:** Read the walkthrough — https://www.quicknode.com/agents/create-endpoint.md

---

### Quicknode MCP

**Label:** Quicknode MCP

**Headline:** Query Chains and Manage Infrastructure Through Conversation

**Description:** Model Context Protocol integration for AI assistants. Query blockchains, analyze contracts, and manage infrastructure through natural language.

**CTA:** Read the MCP guide — https://www.quicknode.com/guides/ai/quicknode-mcp

---

### Build Web3 Plugin

**Label:** Plugins

**Headline:** Give Your Agents Deep Protocol Knowledge Instantly

**Description:** The `build-web3` skill and the Quicknode MCP install together as one plugin in Claude Code and Codex, so your agent generates valid, optimized requests on the first attempt. Add the skill on its own to any other agent with no account required.

**CTA:** Read the plugin docs — https://www.quicknode.com/docs/build-with-ai/build-web3-plugin

---

### Quicknode CLI

**Label:** Quicknode CLI

**Headline:** Manage Your Infrastructure From the Command Line

**Description:** `qn` is a command-line interface for Quicknode with ergonomic commands (`qn endpoint list`, `qn stream create`) for endpoints, streams, webhooks, the KV store, teams, usage, and billing. Output in table, JSON, YAML, Markdown, or TOON (LLM-optimized). Built for both humans and agents. Install with `brew install quicknode/tap/qn`.

**CTA:** Install the CLI: https://www.quicknode.com/docs/cli

---

### LLMs.txt

**Label:** LLMs.txt

**Headline:** Point Any LLM at 80+ Networks With One File

**Description:** Machine-readable documentation indexes across all Quicknode resources. LLMs discover the right content automatically for better, more accurate responses.

**CTA:** View all indexes — https://www.quicknode.com/llms.txt

---

## Quick Start Commands

**Badge:** Get Started

**Title:** Quick Start Commands

### 1 — Build Web3 Plugin

Install the `build-web3` skill and the Quicknode MCP in Claude Code with two commands, or add the skill on its own to any agent with no account required.

**Install — Claude Code (skill + Quicknode MCP):**
```
/plugin marketplace add quicknode/agent-plugins
/plugin install build-web3@quicknode-agent-plugins
```

**Install — any agent (skill only, no account needed):**
```
npx skills add quicknode/agent-plugins --skill build-web3
```

**Prompt your agent:**
```
"Stream live order book data from Hyperliquid"
```

**Links:**
- View documentation — https://www.quicknode.com/docs/build-with-ai/build-web3-plugin
- Browse library — https://www.skills.sh/quicknode/agent-plugins/build-web3

---

### 2 — MCP

Manage your Quicknode infrastructure, usage, and billing through natural language.

**Install:**
```
claude mcp add quicknode --transport http https://mcp.quicknode.com/mcp
```

**Prompt your agent:**
```
Create a Base endpoint and enable JWT authentication
```

**Links:**
- NPM Package — https://www.npmjs.com/package/@quicknode/mcp
- Read guide — https://www.quicknode.com/guides/ai/quicknode-mcp

---

### 3 — CLI

Let your agent drive Quicknode from the command line with structured, LLM-readable output.

**Install:**
```
brew install quicknode/tap/qn
```

**Your agent runs commands and reads structured output:**
```
qn endpoint list --output toon
qn stream create --chain ethereum --network mainnet
qn usage show --output json
```

**Links:**
- Install the CLI — https://www.quicknode.com/cli
- View docs — https://www.quicknode.com/docs/quicknode-cli

---

### 4 — x402

Give AI agents access to 130+ blockchain networks with USDC, no account or API key required.

**Fastest path: Quicknode CLI**

```shell
brew install quicknode/tap/qn
qn wallet generate --vm evm --name payer
qn rpc x402 drip --payment-wallet payer --payment-network base-sepolia
qn rpc call eth_blockNumber \
  --network ethereum-mainnet \
  --x402 \
  --payment-wallet payer \
  --payment-network base-sepolia \
  --payment-asset USDC \
  --max-amount 1000
```

CLI guide — https://github.com/quicknode/cli#micropayments

**SDK path:**
```js
import { createQuicknodeX402Client } from "@quicknode/x402";

const client = await createQuicknodeX402Client({
  baseUrl: "https://x402.quicknode.com",
  network: "eip155:84532", // pay on Base
  evmPrivateKey: "0x...",
});
```

**Send a request to a network through Quicknode:**
```js
const block = await client.fetch(
  "https://x402.quicknode.com/ethereum-mainnet",
  {
    method: "POST",
    body: JSON.stringify({
      jsonrpc: "2.0",
      method: "eth_blockNumber",
      params: [],
      id: 1,
    }),
  }
);
```

**Links:**
- Quicknode SDK guide — https://github.com/quicknode/sdk/blob/main/npm/README.md#crypto-micropayment-lane-rpccall (Rust, Python, Node.js, Ruby)
- View documentation — https://www.quicknode.com/docs/build-with-ai/x402-payments

---

### 5 — LLMs.txt

A machine-readable index of Quicknode for LLM context and agent tooling.

**Fetch the Quicknode LLM indexes:**
```
# Main Quicknode index (entry point for all resources)
curl https://www.quicknode.com/llms.txt

# Documentation index (RPC methods and API references)
curl https://www.quicknode.com/docs/llms.txt
```

**Prompt your agent:**
```
Using Quicknode documentation, generate a script that fetches the
latest Ethereum block using JSON-RPC.
```

---

## Sample Applications

**Badge:** Sample Applications

**Title:** Start From Working Code, Not a Blank Page.

**Subtitle:** Reference implementations across Solana, EVM, and DeFi, with full documentation and source code.

**CTA:** View All AI Sample Apps

### Solana MCP Server

Query Solana wallets, token accounts, and transaction history directly from Claude or Cursor. No RPC calls required.

### EVM MCP Server

Give Claude live access to Ethereum and EVM chains. Analyze contracts, check balances, and monitor gas through natural conversation.

### AI-Powered DeFi Optimizer

Connect an AI model to Aerodrome's Swap API to analyze yields, surface strategies, and execute swaps based on live market conditions.

---

## FAQ

**Q: Which Quicknode tool should my agent use — x402, MCP, the Build Web3 plugin, the CLI, LLMs.txt, or the Agent Subscription API?**
These tools operate at different layers and are designed to be used together. Use x402 or MPP when your agent needs to read or write on-chain data without an account or API key. Use the Agent Subscription API when your agent needs a full Quicknode account + dedicated RPC endpoint without human signup — pay via x402/MPP, receive a `QN_*` key, then call `POST /api/v0/endpoints` on the Admin API. Use MCP when an assistant needs to manage existing endpoints through natural language. Use the Build Web3 plugin when an agent is generating code that calls Quicknode APIs. Use the Quicknode CLI when an agent works from a terminal and needs structured output it can parse. Use LLMs.txt when an LLM needs to find the right Quicknode documentation automatically.
https://quicknode.com/docs/build-with-ai

**Q: How does an AI agent create a Quicknode account and RPC endpoint without human signup?**
Use the Agent Subscription API. Two steps: (1) `POST https://www.quicknode.com/api/v1/agent/subscriptions` with `plan_name` (e.g. `b6_build`), `email`, `password`, `billing_address`, plus a `PAYMENT-SIGNATURE` (x402) or `Authorization: Payment` (MPP) header, paid from a funded EVM wallet; the response returns a `QN_*` API key. (2) `POST https://api.quicknode.com/v0/endpoints` with body `{"chain":"base","network":"base-mainnet"}` and `x-api-key: QN_...` — creates a Base/Ethereum/Solana/etc. RPC endpoint via the Admin API. Full runnable walkthrough: https://www.quicknode.com/agents/create-endpoint.md
https://quicknode.com/agents.md

**Q: How does an AI agent access Quicknode RPC without an account or API key?**
x402 is a wallet-authenticated, pay-per-request access layer built on the HTTP 402 standard. Any agent holding a wallet with USDC or USDG can start making RPC calls across 80+ chains immediately — no account registration, no API key. Payments are handled automatically by the @quicknode/x402 client: 1,000,000 credits for $10 USDC on mainnet.
https://quicknode.com/docs/build-with-ai/x402-payments

**Q: What is the fastest way to start building AI agents on Quicknode?**
Three steps: install the Build Web3 plugin to give your coding agent accurate API knowledge (/plugin marketplace add quicknode/agent-plugins, then /plugin install build-web3@quicknode-agent-plugins in Claude Code, or npx skills add quicknode/agent-plugins --skill build-web3 on any other agent), connect the MCP server so your assistant can manage infrastructure through natural language (claude mcp add quicknode-mcp -e QUICKNODE_API_KEY=<key> -- npx -y @quicknode/mcp), then access chains via x402 or a standard endpoint. For working reference implementations, see the Sample App Library.
https://quicknode.com/sample-app-library

**Q: What can I build with Quicknode's agent tools?**
Quicknode's on-chain agent tools support six use cases: Autonomous Trading (real-time market data and execution across DEXs), Smart Contract Analysis (vulnerability and gas analysis at scale), Conversational dApps (natural language blockchain interfaces), On-Chain Analytics (pattern detection and trend analysis via Streams), Wallet Intelligence (asset management and fee optimisation), and Threat Monitoring (AI-powered anomaly detection on contracts and wallets). Each use case maps to a specific combination of Quicknode products.
https://quicknode.com/docs/build-with-ai

**Q: What is the Build Web3 plugin and how does an AI coding agent install it?**
The Build Web3 plugin bundles the `build-web3` skill with the Quicknode MCP server, giving AI coding agents accurate, current knowledge of Quicknode's full product suite — so agents generate correct API calls on the first attempt rather than hallucinating method names or parameters. In Claude Code, install it with two commands: /plugin marketplace add quicknode/agent-plugins, then /plugin install build-web3@quicknode-agent-plugins. On any other agent, install the skill on its own with npx skills add quicknode/agent-plugins --skill build-web3, no account required. The skill loads automatically at session start and works with Claude Code, Cursor, Codex, OpenCode, and Windsurf.
https://quicknode.com/docs/build-with-ai/build-web3-plugin

**Q: What is the Quicknode MCP server and what can an AI assistant do with it?**
The Quicknode MCP server (@quicknode/mcp) connects MCP-compatible AI assistants to your Quicknode account, letting them create and manage endpoints, configure security, set rate limits, and review billing through natural language — no dashboard required. It wraps the Admin API and is compatible with Claude Code, Claude Desktop, Cursor, and OpenAI Codex. It does not provide blockchain data access — for on-chain reads and writes, use x402 or a standard RPC endpoint.
https://quicknode.com/docs/build-with-ai/quicknode-mcp

**Q: How do I give an AI agent access to Hyperliquid data?**
Use HyperCore — Quicknode's data access layer for Hyperliquid L1. It provides four access methods: Info API (/info) for market data and positions, JSON-RPC (/hypercore) for block queries, WebSocket (/hypercore/ws) for real-time subscriptions, and gRPC (port 10000) for lowest-latency streaming. gRPC stream types include TRADES, ORDERS, BOOK_UPDATES, TWAP, EVENTS, BLOCKS, and WRITER_ACTIONS. Requires a Build plan or higher.
https://quicknode.com/docs/hyperliquid

**Q: Does Quicknode support real-time streaming for AI agents?**
Yes — four options depending on chain and latency requirements. Use Streams for deterministic EVM or Solana event pipelines with guaranteed delivery. Use Yellowstone gRPC for sub-second Solana account and transaction monitoring. Use HyperCore gRPC for Hyperliquid order book and trade data. Use Webhooks for simple event-driven HTTP notifications. Streams and Webhooks are not designed for sub-100ms latency use cases.
https://quicknode.com/docs/streams

**Q: Does Quicknode provide working code examples for AI agent use cases?**
Yes. The Sample App Library includes three AI-focused reference implementations: a Solana MCP Server (query wallets, token accounts, and transaction history from Claude or Cursor), an EVM MCP Server (live Ethereum access for contract analysis and gas monitoring), and an AI-Powered DeFi Optimizer (connects an AI model to Aerodrome's Swap API for yield analysis and execution). All include full documentation and source code.
https://quicknode.com/sample-app-library

**Q: What is Quicknode's LLMs.txt and how should an AI system consume it?**
Quicknode publishes machine-readable llms.txt indexes across its full documentation surface — products, chains, RPC methods, guides, sample apps, and courses — so AI systems reference the correct page rather than hallucinating or citing stale sources. Seven indexes are available, including https://quicknode.com/llms.txt (main platform), https://quicknode.com/docs/llms.txt (API reference), and https://x402.quicknode.com/llms.txt (x402 protocol). Any docs or guides page can also be fetched as clean Markdown by appending .md to the URL.
https://quicknode.com/docs/build-with-ai/llms-txt

---

## Final CTA

**Title:** Your Agents Are One Integration Away.

**Subtitle:** Quicknode gives you the infrastructure, tooling, and protocol knowledge to ship production-grade AI agents on any chain.

**CTAs:**
- Start Building Free — https://www.quicknode.com/signup
- View Documentation — https://www.quicknode.com/docs/build-with-ai