Quicknode Blockchain Infrastructure

Intake Questions

• Which chain and network should Quicknode target?
• Is this read-only or should I create infrastructure (streams, webhooks, IPFS writes)?
• Does this require real-time streaming (Solana gRPC/Blazar WSS/HyperCore gRPC) or standard RPC?
• What endpoint or API key should I use (default: QUICKNODE_RPC_URL, optional QUICKNODE_WSS_URL / QUICKNODE_API_KEY)?
• If no API key exists, does the agent want pay-per-request access (x402, MPP) or a wallet-paid Quicknode account via Agent Subscriptions?
• Any constraints (latency, regions, throughput, destinations)?

Safety Defaults

• Default to testnet/devnet when a network is not specified.
• Prefer read-only operations and dry runs before creating resources.
• Never ask for or accept private keys or secret keys.

Confirm Before Write

• Require explicit confirmation before creating or modifying Streams, Webhooks, or IPFS uploads.
• Require explicit confirmation before creating an Agent Subscription, topping up credits, or any action that spends real funds via x402 or MPP.
• If confirmation is missing, return the exact API payload for review.

Quick Reference

Infrastructure

Product	Description	Use Case
Core RPC API	High-performance blockchain access for 80+ chains	dApp backend, wallet interactions
Dedicated Clusters	Dedicated private node clusters	High-throughput production, compliance isolation
IPFS	Decentralized file storage	NFT metadata, asset hosting

Real-Time Data

Product	Description	Use Case
Streams	Real-time & historical blockchain data pipelines	Event monitoring, analytics, indexing
Streams Backfills	On-demand historical data backfill into Streams	Gap recovery, historical re-indexing
Webhooks	Event-driven notifications	Alerts, transaction monitoring
Solana gRPC	Solana Geyser streaming — included on Scale/Business, add-on on Build/Accelerate	Real-time account, transaction, slot data
Blazar WSS	Quicknode-built Solana WebSocket engine — all plans, free	Fast block, account, transaction, and slot subscriptions
HyperCore gRPC	gRPC streaming for Hyperliquid L1 — included on all paid plans	Trades, order book diffs, events, blocks in real time

Indexed Data

Product	Description	Use Case
SQL Explorer	Direct SQL access to indexed blockchain data	Trading analytics, historical queries, market analysis
Agent Identity (ERC-8004)	On-chain agent discovery and reputation records	Agent identity, capability advertising
Blockbook	Wallet-centric blockchain data via JSON-RPC	Address balances, UTXOs, transaction history
Metaplex DAS API	Solana Digital Asset Standard — NFTs, cNFTs, fungible tokens, MPL Core	NFT/token queries, compressed NFTs, asset search
Ordinals & Runes API	Bitcoin inscriptions and Runes protocol data	Inscription lookup, UTXO tracking, Runes balances

Trading & DeFi

Product	Description	Use Case
Swap API	Multi-DEX aggregated token swaps	Solana (Jupiter/Metis), EVM (0x, OpenOcean, Aerodrome, Velodrome, Titan)

Marketplace Add-ons

Product	Description	Use Case
Solana Priority Fee API	Recommended priority fees for Solana transactions	Fee estimation, transaction landing
Jito Bundles	Solana bundle submission and status APIs	MEV-aware transaction delivery
Single Flight RPC	Request de-duplication for identical in-flight RPC calls	High-concurrency read workloads
Multi-region Transaction Broadcast	Transaction propagation across multiple regions	Latency-sensitive submission
Scorechain Risk Assessment API	Wallet and transaction risk data	Compliance, fraud monitoring
Block Timestamp Lookup	Timestamp-to-block lookup utilities	Time-window to block-range conversion
Multi-chain Stablecoin Balance API	Stablecoin balances across supported chains	Treasury, payments, portfolio state
Covalent GoldRush APIs	Multi-chain wallet and portfolio data	Wallet summaries, token/NFT holdings

Agent Surface

Product	Description	Use Case
x402	Testnet monthly cap plus mainnet pay-per-request via stablecoins	Keyless RPC access, AI agents, pay-as-you-go
MPP	Testnet monthly cap plus mainnet pay-per-request via IETF Payment Authentication	AI agents, multi-service payments, high-volume sessions
Agent Subscriptions	Wallet-paid Quicknode account creation, returns a QN_* full platform API key	Autonomous agents needing full platform access
Quicknode CLI	qn CLI for endpoints, Streams, Webhooks, KV, and SQL from the terminal	Scripting, CI/CD, infrastructure automation
Quicknode MCP	Native Claude/OpenAI connector plus generic MCP server — Admin API via MCP	Manage Quicknode from Claude, ChatGPT, Codex, Cursor, or any MCP-capable AI tool

Platform

Product	Description	Use Case
Admin API	REST API for account management	Endpoint CRUD, usage monitoring, billing
Key-Value Store	Serverless key-value and list storage (beta)	Persistent state for Streams, dynamic address lists
Quicknode SDK	Official SDK for Quicknode product APIs	Admin API, Streams, Webhooks, KV, SQL Explorer

---

Core RPC API

Quicknode provides low-latency RPC endpoints for 80+ blockchain networks.

qn rpc call (CLI) and qn.rpc.call (SDK) reach any supported network via Tooling Access — a single multichain, read-only endpoint Quicknode provisions automatically with short-lived JWTs. No endpoint setup required. See references/cli-reference.md / references/sdk-reference.md. Use a dedicated endpoint below for a fixed URL, non-read-only methods, or dedicated throughput.

Endpoint Setup

// EVM chains (ethers.js)
import { JsonRpcProvider } from 'ethers';
const provider = new JsonRpcProvider(process.env.QUICKNODE_RPC_URL!);

// EVM chains (viem)
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
const client = createPublicClient({
  chain: mainnet,
  transport: http(process.env.QUICKNODE_RPC_URL!),
});

// Solana
import { createSolanaRpc } from '@solana/kit';
const rpc = createSolanaRpc(process.env.QUICKNODE_RPC_URL!);

Authentication

Quicknode endpoints include authentication in the URL:

https://{ENDPOINT_NAME}.{NETWORK}.quiknode.pro/{API_KEY}/

For additional security, enable JWT authentication or IP allowlisting in the Quicknode dashboard.

Supported Networks

Category	Networks
EVM	Ethereum, Polygon, Arbitrum, Optimism, Base, BSC, Avalanche, Fantom, zkSync, Scroll, Linea, Hyperliquid EVM (HyperEVM)
Non-EVM	Solana, Bitcoin, NEAR, Stacks, Cosmos, Sei, Aptos, Sui, TON, Hyperliquid (HyperCore)

Not exhaustive. Full list: https://www.quicknode.com/chains

Rate Limits & Plans

As of 2026-02-02. Verify current limits in Quicknode docs before sizing a production system.

Plan	Requests/sec	Credits/month
Free Trial	15	10M
Build	50	80M
Accelerate	125	450M
Scale	250	950M
Business	500	2B

See references/rpc-reference.md for complete RPC documentation including method tables for EVM, Solana, and Bitcoin chains, WebSocket patterns, and batch request examples.

IPFS

Decentralized file storage with Quicknode's IPFS gateway.

See references/ipfs-reference.md for upload examples, metadata examples, and complete IPFS documentation.

Dedicated Clusters

Dedicated private node clusters for teams requiring deterministic throughput, regional pinning, or compliance isolation. Agents typically do not provision Dedicated Clusters directly — this is an infrastructure decision made by the account owner.

Marketing: https://www.quicknode.com/clusters Docs: https://www.quicknode.com/docs/custom-rpc-options

---

Streams

Real-time & historical blockchain data pipelines that filter, transform, and deliver data to your destinations.

Stream Types

Type	Data	Use Case
Block	Full block data	Block explorers, analytics
Transaction	Transaction details	Tx monitoring, indexing
Logs	Contract events	DeFi tracking, NFT sales, token transfers
Receipt	Transaction receipts	Gas analysis, status tracking

Quick Setup

1. Create stream in Quicknode dashboard
2. Select network and data type
3. Add filter function (JavaScript)
4. Configure destination (webhook, S3, database)

See references/streams-reference.md for filter examples and full Streams documentation.

Streams Backfills

On-demand historical data delivery into an existing Stream. Use Backfills to recover gaps, seed a new data store with history, or re-index a range of blocks without rebuilding your pipeline.

Docs: https://www.quicknode.com/docs/streams/backfilling

When to Use

• A Stream destination was down and you need to replay missed blocks.
• You're launching a new Stream and need historical data from block N to the current head.
• You want to re-process a range of blocks after updating a filter function.

What to Provide

When asking an agent to trigger a Backfill, provide:

• Stream ID (from the Quicknode dashboard or Admin API)
• Start block number
• End block number (or latest)
• Destination confirmation (Backfills deliver to the Stream's existing destination)

See references/streams-backfills-reference.md for dataset selection, range planning, batching, compression, cost guidance, and automation notes.

Webhooks

Event-driven notifications for blockchain activity.

Webhooks vs Streams

Feature	Webhooks	Streams
Setup	Simple	More configuration
Filtering	Address/event-based	Custom JavaScript
Destinations	HTTP endpoint only	Webhook, S3, Postgres, Azure
Processing	Basic	Full transformation
Use Case	Simple alerts	Complex pipelines

See references/webhooks-reference.md for API examples and full Webhooks documentation.

Solana gRPC (formerly Yellowstone gRPC)

High-performance Solana Geyser plugin for real-time blockchain data streaming via gRPC. Included on Scale and Business plans; available as a Marketplace add-on on Build and Accelerate plans.

Quick Setup

import Client, { CommitmentLevel } from "@triton-one/yellowstone-grpc";

// Derive from HTTP URL: https://example.solana-mainnet.quiknode.pro/TOKEN/
const client = new Client(
  "https://example.solana-mainnet.quiknode.pro:10000",
  "TOKEN",
  {}
);

const stream = await client.subscribe();
stream.on("data", (data) => {
  if (data.transaction) console.log("Tx:", data.transaction);
});

stream.write({
  transactions: {
    txn_filter: {
      vote: false,
      failed: false,
      accountInclude: ["PROGRAM_PUBKEY"],
      accountExclude: [],
      accountRequired: [],
    },
  },
  accounts: {},
  slots: {},
  blocks: {},
  blocksMeta: {},
  transactionsStatus: {},
  entry: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.CONFIRMED,
});

Filter Types

Filter	Description
accounts	Account data changes by pubkey, owner, or data pattern
transactions	Transaction events with vote/failure/account filters
transactionsStatus	Lightweight transaction status updates
slots	Slot progression and status changes
blocks	Full block data with optional tx/account inclusion
blocksMeta	Block metadata without full contents
entry	PoH entry updates

See references/solana-grpc-reference.md for complete Solana gRPC documentation.

Blazar WSS

Quicknode-built Solana WebSocket engine. Every standard Solana subscription method (blockSubscribe, accountSubscribe, transactionSubscribe, logsSubscribe, and more) rebuilt for reliability and speed. Included free on all plans — no add-on required. Uses the same WSS endpoint URL (QUICKNODE_WSS_URL) as standard Solana RPC.

Docs: https://www.quicknode.com/docs/solana

Quick Setup

const ws = new WebSocket(process.env.QUICKNODE_WSS_URL!);

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'blockSubscribe',
    params: ['all', { commitment: 'confirmed', encoding: 'jsonParsed' }]
  }));
});

ws.on('message', (raw) => {
  const msg = JSON.parse(raw.toString());
  if (msg.params?.result?.value?.block) {
    console.log('New block slot:', msg.params.result.context.slot);
  }
});

Supported Subscription Methods

blockSubscribe, accountSubscribe, logsSubscribe, programSubscribe, signatureSubscribe, slotSubscribe, slotsUpdatesSubscribe, transactionSubscribe, voteSubscribe

HyperCore (Hyperliquid)

Quicknode's data delivery infrastructure for the Hyperliquid L1 chain. Provides gRPC, JSON-RPC, WebSocket, and Info API access. Currently in public beta. Included on all paid plans.

Access Methods

Method	Path / Port	Use Case
Info API	/info (POST)	50+ methods for market data, positions, orders
JSON-RPC	/hypercore (POST)	Block queries (hl_getBlock, hl_getBatchBlocks)
WebSocket	/hypercore/ws	Real-time subscriptions (hl_subscribe)
gRPC	Port 10000	Lowest-latency streaming for trades, orders, books

gRPC Stream Types

Stream	Volume	Description
TRADES	High	Execution data: coin, price, size, side, fees
ORDERS	Very High	Order lifecycle with 18+ status types
BOOK_UPDATES	Very High	L2 order book diffs
TWAP	Low	Time-weighted average price order updates
EVENTS	High	Ledger updates, funding, deposits, withdrawals
BLOCKS	Extreme	Raw HyperCore blocks (gRPC only)
WRITER_ACTIONS	Low	System-level token transfers

HyperEVM

Path	Debug/Trace	Archive	Use Case
/evm	No	Partial	Standard EVM operations
/nanoreth	Yes	Extended	Debug, trace, WebSocket subscriptions

See references/hypercore-hyperliquid-reference.md for complete HyperCore and Hyperliquid documentation.

---

SQL Explorer

Direct SQL access to indexed blockchain data without requiring infrastructure. Query billions of rows of on-chain data using standard SQL syntax and receive results in seconds.

Docs: https://www.quicknode.com/docs/sql-explorer

Quick Setup

curl -X POST 'https://api.quicknode.com/sql/rest/v1/query' \
  -H 'x-api-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "SELECT timestamp, coin, side, price, size FROM hyperliquid_trades WHERE block_time > now() - INTERVAL 1 HOUR ORDER BY block_number DESC LIMIT 10",
    "clusterId": "hyperliquid-core-mainnet"
  }'

Coverage

Hyperliquid (HyperCore) - Tables covering trades, orders, fills, funding, order book diffs, perpetual markets, spot markets, blocks, transactions, system actions, builder activity, staking, ledger updates, and more.

Key Features

• Infrastructure-free - No database or indexer setup required
• Standard SQL - Full SQL syntax including joins, subqueries, CTEs, window functions
• 40+ pre-built queries - Common patterns for trading analytics, whale tracking, liquidations
• Optimized performance - Monthly partitioning, sort keys, columnar storage
• REST API - Execute queries programmatically via HTTPS

See references/sql-explorer.md for complete table schemas, query examples, optimization tips, and API reference.

Agent Identity (ERC-8004)

On-chain agent identity and reputation discovery based on the ERC-8004 standard. erc-8004.quicknode.com indexes registrations, feedback, validations, and reputation across supported EVM networks.

API Base: https://erc-8004.quicknode.com REST prefix: /v1

See references/agent-identity-reference.md for verified endpoints, x402 behavior, rate limits, and on-chain registration guidance.

Blockbook

Wallet-centric blockchain data via the Blockbook JSON-RPC add-on. Provides address balances, UTXO sets, and transaction history across supported chains — particularly useful for UTXO-based chains like Bitcoin where standard RPC methods lack wallet-level indexing.

Marketing: https://www.quicknode.com/blockbook Docs: https://www.quicknode.com/docs/bitcoin/blockbook/overview

Supported Chains

Bitcoin (BTC), Ethereum (ETH), Bitcoin Cash (BCH), Dogecoin (DOGE), Litecoin (LTC), Zcash (ZEC) — each as its own add-on on your endpoint.

When to Use

• Get the full balance and transaction history for a Bitcoin or UTXO-chain address.
• Fetch UTXOs to construct a transaction.
• Look up confirmed/unconfirmed balance for an address without running a personal indexer.

See references/blockbook-reference.md for methods and examples.

Metaplex DAS API (Solana)

Comprehensive API for querying Solana digital assets — standard NFTs, compressed NFTs (cNFTs), fungible tokens, MPL Core Assets, and Token 2022 Assets. Available as the Metaplex Digital Asset Standard (DAS) API add-on on your Quicknode Solana endpoint. Formerly documented in this skill as "Solana DAS API".

Marketing: https://www.quicknode.com/metaplex-das-api Docs: https://www.quicknode.com/docs/solana/solana-das-api

Quick Setup

// Get all assets owned by a wallet
const response = await fetch(process.env.QUICKNODE_RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getAssetsByOwner',
    params: {
      ownerAddress: 'E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk',
      limit: 10,
      options: { showFungible: true, showCollectionMetadata: true }
    }
  })
});
const { result } = await response.json();
// result.total — total assets
// result.items — array of asset metadata
// result.cursor — for pagination

Available Methods

Method	Description
getAsset	Get metadata for a single asset
getAssets	Get metadata for multiple assets
getAssetProof	Get Merkle proof for a compressed asset
getAssetProofs	Get Merkle proofs for multiple assets
getAssetsByAuthority	List assets by authority
getAssetsByCreator	List assets by creator
getAssetsByGroup	List assets by group (e.g., collection)
getAssetsByOwner	List assets by wallet owner
getAssetSignatures	Transaction signatures for compressed assets
getTokenAccounts	Token accounts by mint or owner
getNftEditions	Edition details of a master NFT
searchAssets	Search assets with flexible filters

See references/metaplex-das-reference.md for complete DAS API documentation with all methods, parameters, and examples.

Ordinals & Runes API

Bitcoin inscription and Runes protocol data via a Quicknode Marketplace add-on. Query inscription metadata, satoshi data, Rune details, and collection data through JSON-RPC and ORD-compatible REST on your Bitcoin endpoint. 21 methods available.

Marketing: https://www.quicknode.com/ordinals-runes Docs: https://www.quicknode.com/docs/bitcoin/ord_getInscription

When to Use

• Look up inscription details (content type, sat number, rarity, genesis transaction) for a given inscription ID.
• Query Rune etching details, minting parameters, and live supply.
• Fetch Bitcoin outputs and the inscriptions or Runes they contain.

See references/ordinals-runes-reference.md for supported methods and examples.

Marketplace Add-ons

Endpoint add-ons for specialized capabilities that can be enabled on Quicknode endpoints. Use the add-on docs or dashboard-provided endpoint details for exact API shapes.

Solana Priority Fee API

// Get recommended priority fees
const response = await rpc.request('qn_estimatePriorityFees', {
  last_n_blocks: 100,
  account: 'YOUR_ACCOUNT'
}).send();

Jito Bundles

MEV-aware Solana bundle submission and status APIs for users who have enabled the Jito add-on.

Single Flight RPC

Request de-duplication for identical in-flight RPC calls. Useful for high-concurrency applications where many workers or users request the same data at the same time.

Multi-region Transaction Broadcast

Broadcast signed transactions through multiple regions to improve propagation for latency-sensitive transaction submission.

Scorechain Risk Assessment API

Wallet and transaction risk data for compliance, fraud monitoring, and risk-aware transaction workflows.

Block Timestamp Lookup

Timestamp-to-block lookup utilities for converting human time windows into block ranges.

Multi-chain Stablecoin Balance API

Stablecoin balances across supported chains for treasury, payments, and portfolio workflows.

Covalent GoldRush APIs

Multi-chain wallet and portfolio data, including balances, token holdings, NFT holdings, and transaction history where supported.

See references/marketplace-addons.md for current add-on guidance and product-specific reference links.

---

Swap API

Multi-DEX aggregated token swaps via Quicknode Marketplace add-ons. Supports Metis/Jupiter, 0x, OpenOcean, Aerodrome, Velodrome, Titan Meta Aggregator, and Hyperliquid Exchange API. Each provider is enabled as a separate add-on or product surface on your endpoint/account.

Marketing: https://www.quicknode.com/swap-api

Solana — Metis (Jupiter)

import { createJupiterApiClient } from '@jup-ag/api';

const jupiterApi = createJupiterApiClient({
  basePath: process.env.QUICKNODE_METIS_URL!
});

const quote = await jupiterApi.quoteGet({
  inputMint: 'So11111111111111111111111111111111111111112',   // SOL
  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
  amount: 1_000_000_000,  // 1 SOL in lamports
  slippageBps: 50
});

const swapResult = await jupiterApi.swapPost({
  swapRequest: {
    quoteResponse: quote,
    userPublicKey: 'YourPubkey...'
  }
});
// swapResult.swapTransaction — serialized tx ready for signing

Set QUICKNODE_METIS_URL to your Metis endpoint (e.g., https://jupiter-swap-api.quiknode.pro/YOUR_TOKEN). Enable the Metis Jupiter Swap API add-on in the Quicknode dashboard.

See references/swap-api-reference.md for provider positioning, verified examples, safety defaults, and troubleshooting.

---

x402 (Pay-Per-Request RPC)

Pay-per-request RPC access via stablecoin payments. No API key required. Three payment models: pay-per-request ($0.001/call), nanopayment (batched via Circle Gateway), and credit drawdown (SIWX auth, $10/1M mainnet credits). Testnet wallets share a monthly cap of 1,000,000 credits per wallet; mainnet wallets are uncapped. Supports USDC on Base/Polygon/Solana and USDG on XLayer. Access 140+ chain endpoints.

Quick Setup