Quicknode Skill

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

Real-Time Data

Indexed Data

Trading & DeFi

Marketplace Add-ons

Agent Surface

Platform

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

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.

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

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

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

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

gRPC Stream Types

HyperEVM

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

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: 'agent@example.com',
      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: 'agent@example.com',
      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

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

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.

• Validator as a Service — Non-custodial Ethereum staking with custom fee recipients and MEV-boost. https://www.quicknode.com/validator-as-a-service
• Solana Validator — Managed Solana validator infrastructure. https://www.quicknode.com/chains/solana/validator
• Monad Validator — Managed Monad validator infrastructure. https://www.quicknode.com/chains/monad/validator
• ChainKit — No-code blockchain data tooling and integrations. https://www.quicknode.com/chainkit

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 v

…(truncated)