From blockchain-skills
Guides QuickNode setup for blockchain RPC (80+ chains), Streams/Webhooks, IPFS, Solana DAS/gRPC streaming, KV store, SQL queries on indexed data, and add-ons.
npx claudepluginhub quiknode-labs/blockchain-skills --plugin blockchain-skillsThis skill uses the workspace's default tool permissions.
- Which chain and network should Quicknode target?
references/admin-api-reference.mdreferences/hypercore-hyperliquid-reference.mdreferences/ipfs-reference.mdreferences/marketplace-addons.mdreferences/mpp-reference.mdreferences/rpc-reference.mdreferences/sdk-reference.mdreferences/solana-das-api-reference.mdreferences/sql-explorer.mdreferences/streams-reference.mdreferences/webhooks-reference.mdreferences/x402-reference.mdreferences/yellowstone-grpc-reference.mdSets up QuickNode RPC endpoints for Ethereum/Solana, installs @quicknode/sdk or ethers.js via npm, configures .env vars, and verifies connections with TypeScript code.
Integrates Alchemy APIs into application code (servers, backends, dApps, scripts) via API key. Covers EVM JSON-RPC, Token/NFT/Transfers/Prices/Portfolio APIs, Solana RPC/DAS/gRPC, Sui gRPC, Wallets. Requires $ALCHEMY_API_KEY.
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Share bugs, ideas, or general feedback.
QUICKNODE_RPC_URL, optional QUICKNODE_WSS_URL / QUICKNODE_API_KEY)?| Product | Description | Use Case |
|---|---|---|
| RPC Endpoints | High-performance blockchain access | dApp backend, wallet interactions |
| Streams | Real-time & historical blockchain data pipelines | Event monitoring, analytics, indexing |
| Webhooks | Event-driven notifications | Alerts, transaction monitoring |
| IPFS | Decentralized file storage | NFT metadata, asset hosting |
| Add-ons | Enhanced blockchain APIs | Token balances, NFT data, DeFi |
| DAS API | Solana Digital Asset Standard (add-on) | NFT/token queries, compressed NFTs, asset search |
| Yellowstone gRPC | Solana Geyser streaming (add-on) | Real-time account, transaction, slot data |
| Hypercore | Hyperliquid gRPC/JSON-RPC/WS (beta) | Trades, orders, book updates, blocks, TWAP, events, writer actions |
| SQL Explorer | Direct SQL access to indexed blockchain data | Trading analytics, historical queries, market analysis |
| 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 |
| x402 | Pay-per-request ($0.001/call) or credit drawdown ($10/1M) RPC via stablecoins | Keyless RPC access, AI agents, pay-as-you-go |
| MPP | Pay-per-request RPC via IETF Payment Authentication headers | AI agents, multi-service payments, high-volume sessions |
Quicknode provides low-latency RPC endpoints for 80+ blockchain networks.
// 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!);
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.
| 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
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.
Real-time & historical blockchain data pipelines that filter, transform, and deliver data to your destinations.
| 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 |
See references/streams-reference.md for filter examples and full Streams documentation.
Event-driven notifications for blockchain activity.
| 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.
Decentralized file storage with Quicknode's IPFS gateway.
See references/ipfs-reference.md for upload examples, metadata examples, and complete IPFS documentation.
Enhanced APIs available through Quicknode's marketplace.
// Get all token balances for an address
const response = await fetch(process.env.QUICKNODE_RPC_URL!, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
method: 'qn_getWalletTokenBalance',
params: [{ wallet: '0x...', contracts: [] }]
})
});
// Fetch NFTs owned by address
const response = await fetch(process.env.QUICKNODE_RPC_URL!, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
method: 'qn_fetchNFTs',
params: [{ wallet: '0x...', page: 1, perPage: 10 }]
})
});
// Get recommended priority fees
const response = await rpc.request('qn_estimatePriorityFees', {
last_n_blocks: 100,
account: 'YOUR_ACCOUNT'
}).send();
// Using Metis - Jupiter Swap API
import { createJupiterApiClient } from '@jup-ag/api';
const jupiterApi = createJupiterApiClient({
basePath: `${process.env.QUICKNODE_METIS_URL}`
});
const quote = await jupiterApi.quoteGet({
inputMint: 'So11111111111111111111111111111111111111112',
outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
amount: 1000000000,
slippageBps: 50
});
const swapResult = await jupiterApi.swapPost({
swapRequest: {
quoteResponse: quote,
userPublicKey: 'YourPubkey...'
}
});
See references/marketplace-addons.md for complete Add-ons documentation.
Comprehensive API for querying Solana digital assets — standard NFTs, compressed NFTs (cNFTs), fungible tokens, MPL Core Assets, and Token 2022 Assets. Available as a Marketplace add-on (Metaplex DAS API).
Docs: https://www.quicknode.com/docs/solana/solana-das-api
// 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
| 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/solana-das-api-reference.md for complete DAS API documentation with all methods, parameters, and examples.
High-performance Solana Geyser plugin for real-time blockchain data streaming via gRPC. Available as a Marketplace add-on.
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 | 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/yellowstone-grpc-reference.md for complete Yellowstone gRPC documentation.
Quicknode's data delivery infrastructure for the Hyperliquid L1 chain. Provides gRPC, JSON-RPC, WebSocket, and Info API access. Currently in public beta.
| 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 |
| 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 |
| 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.
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
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"
}'
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.
See references/sql-explorer.md for complete table schemas, query examples, optimization tips, and API reference.
Official JavaScript/TypeScript SDK for Quicknode services.
npm install @quicknode/sdk
import { Core } from '@quicknode/sdk';
const core = new Core({
endpointUrl: process.env.QUICKNODE_RPC_URL!,
});
// Token API
const balances = await core.client.qn_getWalletTokenBalance({
wallet: '0x...',
});
// NFT API
const nfts = await core.client.qn_fetchNFTs({
wallet: '0x...',
page: 1,
perPage: 10,
});
See references/sdk-reference.md for complete SDK documentation.
REST API for programmatic management of Quicknode endpoints, usage, rate limits, security, billing, and teams. Enables infrastructure-as-code workflows.
| Resource | Methods | Endpoint |
|---|---|---|
| Chains | GET | /v0/chains |
| Endpoints | GET, POST, PATCH, DELETE | /v0/endpoints |
| Metrics | GET | /v0/endpoints/{id}/metrics |
| Rate Limits | GET, POST, PUT | /v0/endpoints/{id}/method-rate-limits, /v0/endpoints/{id}/rate-limits |
| Security | GET | /v0/endpoints/{id}/security_options |
| Usage | GET | /v0/usage/rpc, by-endpoint, by-method, by-chain |
| Billing | GET | /v0/billing/invoices |
| Teams | GET | /v0/teams |
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, billing, and teams.
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.
List operations — manage lists of items (e.g., wallet addresses):
qnLib.qnUpsertList — create or update a listqnLib.qnAddListItem — add item to a listqnLib.qnRemoveListItem — remove item from a listqnLib.qnContainsListItems — batch membership checkqnLib.qnDeleteList — delete a listSet operations — manage key-value pairs:
qnLib.qnAddSet — create a key-value setqnLib.qnGetSet — retrieve value by keyqnLib.qnBulkSets — bulk create/remove setsqnLib.qnDeleteSet — delete a setDocs: https://www.quicknode.com/docs/key-value-store
Pay-per-request RPC access via stablecoin payments. No API key required. Two access patterns: pay-per-request ($0.001/call, no auth needed) and credit drawdown (SIWX auth, $10/1M requests). Supports USDC on Base/Polygon/Solana and USDG on XLayer. Access 140+ chain endpoints.
import { wrapFetch } from "@x402/fetch";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({
account,
chain: base,
transport: http(),
});
// Wrap fetch to auto-handle 402 payments
const x402Fetch = wrapFetch(fetch, walletClient);
// Use like normal fetch — payments are handled automatically
const response = await x402Fetch("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 SIWE authentication, credit management, and the @x402/fetch wrapper.
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). Payment via PathUSD on Tempo or USDC on Solana. Access 140+ chain endpoints.
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.
import { Core } from '@quicknode/sdk';
const chains = {
ethereum: new Core({
endpointUrl: 'https://YOUR_ETH_ENDPOINT.quiknode.pro/KEY/'
}),
polygon: new Core({
endpointUrl: 'https://YOUR_POLYGON_ENDPOINT.quiknode.pro/KEY/'
}),
arbitrum: new Core({
endpointUrl: 'https://YOUR_ARB_ENDPOINT.quiknode.pro/KEY/'
}),
};
// Use appropriate chain
const ethBalance = await chains.ethereum.client.getBalance({ address: '0x...' });
/info) for account state and market metadataSELECT * FROM hyperliquid_trades WHERE block_time > ...GROUP BY for volume, counts, averagesWHERE block_time > ...)Main Docs: https://www.quicknode.com/docs/
Webhooks: https://www.quicknode.com/docs/webhooks
Admin API: https://www.quicknode.com/docs/admin-api
DAS API (Solana): https://www.quicknode.com/docs/solana/solana-das-api
Yellowstone gRPC: https://www.quicknode.com/docs/solana/yellowstone-grpc/overview
Hyperliquid: https://www.quicknode.com/docs/hyperliquid
Hyperliquid gRPC: https://www.quicknode.com/docs/hyperliquid/grpc-api
SQL Explorer: https://www.quicknode.com/docs/sql-explorer
SQL Explorer REST API: https://www.quicknode.com/docs/sql-explorer/using-rest-api
Hyperliquid Queries: - https://www.quicknode.com/docs/sql-explorer/hyperliquid-queries
Schema Reference: https://www.quicknode.com/docs/sql-explorer/schema-reference
Key-Value Store: https://www.quicknode.com/docs/key-value-store
https://www.quicknode.com/docs/{chain-or-product}/llms.txt)