# 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

---

### Quicknode Skills

**Label:** Quicknode Skills

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

**Description:** Curated instruction sets for blockchain operations. Teach agents how to interact with specific protocols and smart contracts across 80+ ecosystems.

**CTA:** Browse skills library — https://skills.sh/quiknode-labs/blockchain-skills/quicknode-skill

---

### 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/quicknode-cli#install

---

### 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 — Skills

Give your AI agent accurate knowledge of Quicknode's full product suite in one command.

**Install:**
```
npx skills add https://github.com/quiknode-labs/blockchain-skills --skill quicknode-skill
```

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

**Links:**
- Browse library — https://skills.sh/quiknode-labs/blockchain-skills/quicknode-skill

---

### 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 — x402

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

**Set up the x402 client:**
```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:**
- View documentation — https://www.quicknode.com/docs/build-with-ai/x402-payments

---

### 4 — 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, Skills, 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 Blockchain Skills when an agent is generating code that calls Quicknode APIs. 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 Blockchain Skills to give your coding agent accurate API knowledge (npx skills add https://github.com/quiknode-labs/blockchain-skills --skill quicknode-skill), 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 are Quicknode Blockchain Skills and how does an AI coding agent install them?**
Blockchain Skills is a reference package that gives 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. Install with one command: npx skills add https://github.com/quiknode-labs/blockchain-skills --skill quicknode-skill. The skill loads automatically at session start and works with Claude Code, Cursor, Codex, OpenCode, and Windsurf.
https://quicknode.com/docs/build-with-ai/quicknode-skills

**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