agentsclimarketplace

Quicknode skill

Skill quiknode-labs/blockchain-skills/skills/quicknode-skill

Blockchain skills you can use with your coding agent, such as Claude Code, OpenCode, Codex, Cursor and more.

Install
npx -y skills add quiknode-labs/blockchain-skills --skill quicknode-skill

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 16 stars16 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Quicknode blockchain infrastructure for 80+ chains: Core RPC API, Streams, Webhooks, Blazar WSS, Solana gRPC, HyperCore gRPC, SQL Explorer, Metaplex DAS API, Blockbook, Ordinals & Runes API, Swap API, x402, MPP, Agent Subscriptions, CLI, and MCP. Use for any Quicknode product, blockchain data access, or wallet-paid agent access.

SKILL.md

44.9 KB, as published. Nobody here has run it

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

ProductDescriptionUse Case
Core RPC APIHigh-performance blockchain access for 80+ chainsdApp backend, wallet interactions
Dedicated ClustersDedicated private node clustersHigh-throughput production, compliance isolation
IPFSDecentralized file storageNFT metadata, asset hosting

Real-Time Data

ProductDescriptionUse Case
StreamsReal-time & historical blockchain data pipelinesEvent monitoring, analytics, indexing
Streams BackfillsOn-demand historical data backfill into StreamsGap recovery, historical re-indexing
WebhooksEvent-driven notificationsAlerts, transaction monitoring
Solana gRPCSolana Geyser streaming — included on Scale/Business, add-on on Build/AccelerateReal-time account, transaction, slot data
Blazar WSSQuicknode-built Solana WebSocket engine — all plans, freeFast block, account, transaction, and slot subscriptions
HyperCore gRPCgRPC streaming for Hyperliquid L1 — included on all paid plansTrades, order book diffs, events, blocks in real time

Indexed Data

ProductDescriptionUse Case
SQL ExplorerDirect SQL access to indexed blockchain dataTrading analytics, historical queries, market analysis
Agent Identity (ERC-8004)On-chain agent discovery and reputation recordsAgent identity, capability advertising
BlockbookWallet-centric blockchain data via JSON-RPCAddress balances, UTXOs, transaction history
Metaplex DAS APISolana Digital Asset Standard — NFTs, cNFTs, fungible tokens, MPL CoreNFT/token queries, compressed NFTs, asset search
Ordinals & Runes APIBitcoin inscriptions and Runes protocol dataInscription lookup, UTXO tracking, Runes balances

Trading & DeFi

ProductDescriptionUse Case
Swap APIMulti-DEX aggregated token swapsSolana (Jupiter/Metis), EVM (0x, OpenOcean, Aerodrome, Velodrome, Titan)

Marketplace Add-ons

ProductDescriptionUse Case
Solana Priority Fee APIRecommended priority fees for Solana transactionsFee estimation, transaction landing
Jito BundlesSolana bundle submission and status APIsMEV-aware transaction delivery
Single Flight RPCRequest de-duplication for identical in-flight RPC callsHigh-concurrency read workloads
Multi-region Transaction BroadcastTransaction propagation across multiple regionsLatency-sensitive submission
Scorechain Risk Assessment APIWallet and transaction risk dataCompliance, fraud monitoring
Block Timestamp LookupTimestamp-to-block lookup utilitiesTime-window to block-range conversion
Multi-chain Stablecoin Balance APIStablecoin balances across supported chainsTreasury, payments, portfolio state
Covalent GoldRush APIsMulti-chain wallet and portfolio dataWallet summaries, token/NFT holdings

Agent Surface

ProductDescriptionUse Case
x402Testnet monthly cap plus mainnet pay-per-request via stablecoinsKeyless RPC access, AI agents, pay-as-you-go
MPPTestnet monthly cap plus mainnet pay-per-request via IETF Payment AuthenticationAI agents, multi-service payments, high-volume sessions
Agent SubscriptionsWallet-paid Quicknode account creation, returns a QN_* full platform API keyAutonomous agents needing full platform access
Quicknode CLIqn CLI for endpoints, Streams, Webhooks, KV, and SQL from the terminalScripting, CI/CD, infrastructure automation
Quicknode MCPNative Claude/OpenAI connector plus generic MCP server — Admin API via MCPManage Quicknode from Claude, ChatGPT, Codex, Cursor, or any MCP-capable AI tool

Platform

ProductDescriptionUse Case
Admin APIREST API for account managementEndpoint CRUD, usage monitoring, billing
Key-Value StoreServerless key-value and list storage (beta)Persistent state for Streams, dynamic address lists
Quicknode SDKOfficial SDK for Quicknode product APIsAdmin 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

CategoryNetworks
EVMEthereum, Polygon, Arbitrum, Optimism, Base, BSC, Avalanche, Fantom, zkSync, Scroll, Linea, Hyperliquid EVM (HyperEVM)
Non-EVMSolana, 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.

PlanRequests/secCredits/month
Free Trial1510M
Build5080M
Accelerate125450M
Scale250950M
Business5002B

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

TypeDataUse Case
BlockFull block dataBlock explorers, analytics
TransactionTransaction detailsTx monitoring, indexing
LogsContract eventsDeFi tracking, NFT sales, token transfers
ReceiptTransaction receiptsGas 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

FeatureWebhooksStreams
SetupSimpleMore configuration
FilteringAddress/event-basedCustom JavaScript
DestinationsHTTP endpoint onlyWebhook, S3, Postgres, Azure
ProcessingBasicFull transformation
Use CaseSimple alertsComplex 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

FilterDescription
accountsAccount data changes by pubkey, owner, or data pattern
transactionsTransaction events with vote/failure/account filters
transactionsStatusLightweight transaction status updates
slotsSlot progression and status changes
blocksFull block data with optional tx/account inclusion
blocksMetaBlock metadata without full contents
entryPoH 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

MethodPath / PortUse Case
Info API/info (POST)50+ methods for market data, positions, orders
JSON-RPC/hypercore (POST)Block queries (hl_getBlock, hl_getBatchBlocks)
WebSocket/hypercore/wsReal-time subscriptions (hl_subscribe)
gRPCPort 10000Lowest-latency streaming for trades, orders, books

gRPC Stream Types

StreamVolumeDescription
TRADESHighExecution data: coin, price, size, side, fees
ORDERSVery HighOrder lifecycle with 18+ status types
BOOK_UPDATESVery HighL2 order book diffs
TWAPLowTime-weighted average price order updates
EVENTSHighLedger updates, funding, deposits, withdrawals
BLOCKSExtremeRaw HyperCore blocks (gRPC only)
WRITER_ACTIONSLowSystem-level token transfers

HyperEVM

PathDebug/TraceArchiveUse Case
/evmNoPartialStandard EVM operations
/nanorethYesExtendedDebug, 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

MethodDescription
getAssetGet metadata for a single asset
getAssetsGet metadata for multiple assets
getAssetProofGet Merkle proof for a compressed asset
getAssetProofsGet Merkle proofs for multiple assets
getAssetsByAuthorityList assets by authority
getAssetsByCreatorList assets by creator
getAssetsByGroupList assets by group (e.g., collection)
getAssetsByOwnerList assets by wallet owner
getAssetSignaturesTransaction signatures for compressed assets
getTokenAccountsToken accounts by mint or owner
getNftEditionsEdition details of a master NFT
searchAssetsSearch 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

import { createQuicknodeX402Client } from "@quicknode/x402";

const client = await createQuicknodeX402Client({
  baseUrl: "https://x402.quicknode.com",
  network: "eip155:84532", // Base Sepolia payment network
  evmPrivateKey: process.env.PRIVATE_KEY as `0x${string}`,
  paymentModel: "pay-per-request",
});

// Use like normal fetch — payment negotiation is handled automatically
const response = await client.fetch("https://x402.quicknode.com/ethereum-mainnet", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    method: "eth_blockNumber",
    params: [],
    id: 1,
  }),
});

See references/x402-reference.md for complete x402 documentation including SIWX authentication, credit management, and @quicknode/x402 setup.

MPP (Machine Payments Protocol)

Pay-per-request RPC access via IETF Payment Authentication headers. No API key required. Two intent types: charge ($0.001/request) and session ($0.00001/request via off-chain vouchers). Tempo testnet wallets share a monthly cap of 1,000,000 credits per wallet; mainnet wallets are uncapped. Payment via PathUSD or USDC.e on Tempo mainnet, PathUSD on Tempo testnet, or USDC on Solana. Access 140+ chain endpoints.

Quick Setup

import { Mppx, tempo } from 'mppx/client'
import { privateKeyToAccount } from 'viem/accounts'

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)

// Polyfills globalThis.fetch — handles 402 challenges automatically
Mppx.create({
  methods: [tempo({ account })],
})

// Charge intent ($0.001/req) — payment is transparent
const response = await fetch('https://mpp.quicknode.com/tempo-mainnet', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'eth_blockNumber',
    params: [],
  }),
})

const { result } = await response.json()
console.log('Block number:', BigInt(result))

See references/mpp-reference.md for complete MPP documentation including charge vs session intents, Solana setup, CLI usage, and payment receipts.

Agent Subscriptions

Programmatic Quicknode account creation for autonomous agents. A single POST to /api/v1/agent/subscriptions with an x402 or MPP payment creates a paid account synchronously and returns a QN_* full platform API key, no dashboard signup or email confirmation required. The same payment SDKs used for x402 and MPP per-request RPC sign the subscription payment.

Docs: https://www.quicknode.com/docs/build-with-ai/agent-subscriptions

When to Use

  • Pay-per-request (x402, MPP) when the agent only needs short-lived RPC access with no persistent state.
  • Agent Subscriptions when the agent needs the full platform: Streams, Webhooks, Key-Value Store, multiple endpoints, security rules, billing, or any other Admin API surface.

Discover Plans

To fetch the live plan list, prices, accepted payment networks, asset contract addresses, and recipient (payTo) addresses, send the request without a payment header. The server returns HTTP 402 with the details in the body and a PAYMENT-REQUIRED header (base64-encoded x402 requirement).

curl -X POST https://www.quicknode.com/api/v1/agent/subscriptions \
  -H "Content-Type: application/json" \
  -d '{}'

Parse the 402 body, pick a plan, then retry the request through the SDK.

Quick Setup (x402)

import { createQuicknodeX402Client } from '@quicknode/x402'

const client = await createQuicknodeX402Client({
  baseUrl: 'https://www.quicknode.com',
  network: 'eip155:8453', // Base Mainnet
  evmPrivateKey: process.env.PRIVATE_KEY as `0x${string}`,
})

const res = await client.fetch(
  'https://www.quicknode.com/api/v1/agent/subscriptions',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      plan_name: 'b6_build', // b6_build | b6_accelerate | b6_scale | b6_business
      interval: 'monthly', // monthly | yearly
      email: '[email protected]',
      password: process.env.ACCOUNT_PASSWORD,
      password_confirmation: process.env.ACCOUNT_PASSWORD,
      full_name: 'Autonomous Agent',
      name: 'Agent Account',
      billing_address: {
        line1: '123 Main St',
        city: 'New York',
        postal_code: '10001',
        country: 'US',
      },
    }),
  },
)

const { api_key } = await res.json() // "QN_..." full platform API key

The returned api_key is the same QUICKNODE_API_KEY used everywhere else in this skill. Use it against https://api.quicknode.com/v0/... to provision endpoints, configure security, top up credits, read balances, and so on.

Paying with Solana? Use @quicknode/x402-solana to sign x402 payments with a Solana keypair instead of an EVM private key. Once configured, the subscription request body and Admin API steps are identical to the x402 example above. See the How to Access Solana RPC with x402 guide for setup details.

Quick Setup (MPP)

import { Mppx, tempo } from 'mppx/client'
import { privateKeyToAccount } from 'viem/accounts'

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)

Mppx.create({ methods: [tempo({ account })] })

const subscriptionRes = await fetch(
  'https://www.quicknode.com/api/v1/agent/subscriptions',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      plan_name: 'b6_build', // b6_build | b6_accelerate | b6_scale | b6_business
      interval: 'monthly', // monthly | yearly
      email: '[email protected]',
      password: process.env.ACCOUNT_PASSWORD,
      password_confirmation: process.env.ACCOUNT_PASSWORD,
      full_name: 'Autonomous Agent',
      name: 'Agent Account',
      billing_address: {
        line1: '123 Main St',
        city: 'New York',
        postal_code: '10001',
        country: 'US',
      },
    }),
  },
)

const { api_key } = await subscriptionRes.json() // "QN_..." full platform API key

Endpoints

MethodPathAuthRate limitPurpose
POST/api/v1/agent/subscriptionsPayment header (x402 or MPP)20/min, 5/hour by IP + emailCreate account and subscription
POST/api/v1/agent/top_upAPI key + payment header30/min by API keyAdd credits to an existing subscription
GET/api/v1/agent/balanceAPI key60/min by API keyRead current credit balance

All requests target https://www.quicknode.com.

Plan IDs

b6_build, b6_accelerate, b6_scale, b6_business. Map directly to the public Build / Accelerate / Scale / Business plans on pricing. Use the discovery 402 above when the agent needs to choose a plan dynamically.

Guard Rails

  • Real funds: Subscriptions settle in real stablecoins on a mainnet payment network. Confirm plan, interval, and payment network with the user before sending the request.
  • Duplicate email protection: Re-using an existing email returns an error. Resume failed requests with the same email and password instead of creating a duplicate account.
  • Payment retry safety: If validation fails after a payment header is generated, retry with the same signed payment header byte-for-byte. Do not sign a fresh payment for the same attempted operation unless the server requires a new challenge.
  • No free trials: All subscriptions are production-grade from the first request.
  • Synchronous creation: Account creation and subscription activation happen in the same request. There is no async job or webhook to wait for.
  • No invented details: Never fabricate billing details, passwords, or email addresses. Require explicit user input. Password must be 8–64 characters with at least one lowercase letter, one uppercase letter, one number, and one special character.

See references/agent-subscriptions-reference.md for complete endpoint reference, top-up flow, and balance checks.

Quicknode CLI

Command-line tool (qn) for managing Quicknode infrastructure from the terminal. Available on all paid plans.

Installation

# Homebrew
brew install quicknode/tap/qn

# Docker
docker pull quiknode/qn-cli:latest

Authentication

Use interactive login for local work, or pass the API key explicitly in non-interactive environments:

qn auth login
qn auth login --api-key <KEY>
qn auth whoami

Credential precedence is --api-key, then --config-file, then ~/.config/qn/config.toml. The CLI does not read API keys directly from environment variables.

Agent Context

qn agent context
qn agent context -o json

Key Commands

# Endpoints
qn endpoint list
qn endpoint create --chain ethereum --network mainnet

# RPC (Tooling Access) — no endpoint setup required
qn tooling-access status
qn tooling-access enable
qn rpc call eth_getBlockByNumber '["latest", false]' --network base-mainnet

# Account and chain metadata
qn auth whoami --format json
qn chain credits ethereum --format json

# SQL Explorer
qn sql query "SELECT COUNT(*) FROM hyperliquid_trades" --cluster-id hyperliquid-core-mainnet --format json
qn sql schema hyperliquid-core-mainnet

# Streams / Webhooks / KV
qn stream list
qn webhook list
qn kv set get my-key

Use --format json for machine-readable output. Mutating commands prompt before acting; require explicit user confirmation before bypassing prompts in automation.

See references/cli-reference.md for complete CLI documentation.

Quicknode MCP

Native Claude/OpenAI connector and generic MCP server that exposes Quicknode Admin API capabilities to AI assistants via the Model Context Protocol (MCP).

Setup

Claude Web/Desktop: Settings → Customize → Connectors → find Quicknode → Connect.

Claude Code:

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

Interactive setup uses OAuth: log in to Quicknode, select Viewer or Admin, and approve access. Use Viewer for read-only inspection and Admin only when the assistant needs to create, delete, or modify resources.

OpenAI (ChatGPT/Codex): Install Quicknode from the ChatGPT Apps catalog or via /plugin in Codex when available. Use the consolidated OpenAI tab on the Quicknode MCP docs page for current setup details.

Capabilities

The MCP server provides tools for endpoint management (list, create, delete, rate limits), security rules, usage monitoring, billing, and chain discovery. Agents and users can manage their Quicknode workspace conversationally without leaving their AI tool.

See references/mcp-reference.md for the complete tool surface and setup instructions.

Quicknode SDK

Official SDK for Quicknode product APIs: Admin API, Streams, Webhooks, Key-Value Store, and SQL Explorer. The rpc client (Node 3.7.0+, other languages 0.7.0+) also makes JSON-RPC calls to any supported network via Tooling Access — no endpoint setup required. Chain-specific client libraries still apply for typed chain abstractions or a dedicated endpoint.

Installation

npm install @quicknode/sdk

Basic Usage

import { QuicknodeSdk } from '@quicknode/sdk';

const qn = QuicknodeSdk.fromEnv();

const endpoints = await qn.admin.getEndpoints({
  limit: 20,
  sortBy: 'created_at',
  sortDirection: 'desc',
});

const account = await qn.admin.accountInfo();
const apiCredits = await qn.admin.getApiCredits('ethereum');

const trades = await qn.sql.query(
  'SELECT * FROM hyperliquid_trades LIMIT 5',
  'hyperliquid-core-mainnet'
);

See references/sdk-reference.md for complete SDK documentation.

Admin API

REST API for programmatic management of Quicknode endpoints, usage, rate limits, security, billing, and teams. Enables infrastructure-as-code workflows.

Quick Reference

ResourceMethodsEndpoint
ChainsGET/v0/chains
Account InfoGET/v0/account/info
API CreditsGET/v0/api-credits/{chain}
EndpointsGET, POST, PATCH, DELETE/v0/endpoints
MetricsGET/v0/endpoints/{id}/metrics
Rate LimitsGET, POST, PUT/v0/endpoints/{id}/method-rate-limits, /v0/endpoints/{id}/rate-limits
SecurityGET/v0/endpoints/{id}/security_options
Tooling AccessGET, PATCH, POST/v0/tooling-access, /v0/tooling-access/token
UsageGET/v0/usage/rpc, by-endpoint, by-method, by-chain
BillingGET/v0/billing/invoices
TeamsGET/v0/teams

Authentication

All requests use the x-api-key header against https://api.quicknode.com/v0/.

const QN_API_KEY = process.env.QUICKNODE_API_KEY!;

const res = await fetch('https://api.quicknode.com/v0/endpoints', {
  headers: { 'x-api-key': QN_API_KEY },
});
const endpoints = await res.json();

See references/admin-api-reference.md for full Admin API documentation including endpoint CRUD, usage monitoring, rate limit configuration, security options, Tooling Access, billing, and teams.

Key-Value Store (Beta)

Serverless storage for lists and key-value sets, primarily accessed from within Streams filter functions via the qnLib helper library. Also available via REST API.

Stream Integration (qnLib)

List operations — manage lists of items (e.g., wallet addresses):

  • qnLib.qnUpsertList — create or update a list
  • qnLib.qnAddListItem — add item to a list
  • qnLib.qnRemoveListItem — remove item from a list
  • qnLib.qnContainsListItems — batch membership check
  • qnLib.qnDeleteList — delete a list

Set operations — manage key-value pairs:

  • qnLib.qnAddSet — create a key-value set
  • qnLib.qnGetSet — retrieve value by key
  • qnLib.qnBulkSets — bulk create/remove sets
  • qnLib.qnListAllSets — list all set keys
  • qnLib.qnDeleteSet — delete a set

See references/kv-reference.md for REST API usage, size limits, and CLI (qn kv) commands.

Other Quicknode Products

The following Quicknode products are available but agents typically do not invoke them directly. They are provisioned by account owners through the dashboard or by a human operator.

Common Patterns

Multi-Chain RPC Setup

import { JsonRpcProvider } from 'ethers';

const ethereum = new JsonRpcProvider(process.env.QUICKNODE_ETH_RPC_URL!);
const base = new JsonRpcProvider(process.env.QUICKNODE_BASE_RPC_URL!);

const [ethBlock, baseBlock] = await Promise.all([
  ethereum.getBlockNumber(),
  base.getBlockNumber(),
]);

Real-Time Transaction Monitoring

  1. Create Stream filtering for your contract address
  2. Add Filter Function to extract relevant events
  3. Configure Webhook destination to your server
  4. Process Events in your backend

Real-Time Solana Monitoring with Solana gRPC

  1. Connect via gRPC on port 10000 with your auth token
  2. Subscribe to transactions filtering by program or account
  3. Process updates in real-time via the streaming interface
  4. Implement reconnection with exponential backoff

Hyperliquid Trading Data Pipeline

  1. Connect via gRPC on port 10000 for lowest-latency data
  2. Subscribe to TRADES/ORDERS streams with coin filters
  3. Process events — handle ~12 blocks/sec throughput
  4. Use Info API (/info) for account state and market metadata

Historical Trading Analysis with SQL Explorer

  1. Query historical trades — SELECT * FROM hyperliquid_trades WHERE block_time > ...
  2. Aggregate metrics — Use GROUP BY for volume, counts, averages
  3. Join tables — Combine trades, orders, funding for comprehensive analysis
  4. Export data — Results as JSON for downstream processing

Best Practices

RPC

  • Use WebSocket for subscriptions and real-time data
  • Implement retry logic with exponential backoff
  • Cache responses when data doesn't change frequently
  • Use batch requests to reduce API calls

Streams

  • Start with narrow filters, expand as needed
  • Test filter functions locally before deployment
  • Streams will automatically retry on failures
  • Monitor stream health via dashboard

Security

  • Store API keys in environment variables
  • Enable IP allowlisting for production
  • Use JWT authentication for sensitive operations
  • Rotate API keys periodically

gRPC

  • Enable zstd compression to reduce bandwidth (up to 70% for Hyperliquid)
  • Implement reconnection logic with exponential backoff — streams can drop
  • Use narrow filters (specific accounts, coins, or programs) to minimize data volume
  • Set appropriate commitment levels (Solana gRPC: CONFIRMED for most use cases, FINALIZED for irreversibility)
  • Send keepalive pings (every 10s for Solana gRPC, every 30s for HyperCore) to maintain connections

SQL Explorer

  • Always filter by time ranges for partition pruning (WHERE block_time > ...)
  • Use LIMIT on exploratory queries to reduce data scanned
  • Leverage sort keys (check schema reference) for optimal query performance
  • Start with pre-built queries and customize for your needs
  • Monitor query statistics (rows_read, bytes_read) to optimize performance

Documentation Links

Quicknode Products

Chain-Specific Docs

LLM-Optimized Documentation

Additional Resources

Keep looking

Skills are one crate of 328,083. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.