# Quicknode — Full Documentation Bundle > Complete text of Quicknode's core product documentation in a single file. Includes every core product page, the full AI-agent technical reference, the autonomous endpoint provisioning walkthrough, and the pricing matrix. For per-chain RPC method references, developer tutorials, and Builder's Guide comparisons, use the scoped indexes listed at the bottom of this file. Last updated: 2026-07-10 Generated-From: marketing-cms/public/{products,agents,pricing,agents.md} Canonical-Index: https://www.quicknode.com/llms.txt ## About this file This is the root `llms-full.txt` for `quicknode.com`. It is intended to be ingested in a single fetch by an AI agent — Claude, ChatGPT, Cursor, Copilot, or any other LLM-driven tool — that needs comprehensive context on what Quicknode offers, how its products fit together, and how an autonomous agent can provision its own infrastructure. Scope of this bundle: - All twelve core product pages, full text - Pricing (plans, feature comparison, API credit model, FAQ) - AI agent reference (authentication paths, credit costs, rate limits, error handling, workflow examples) - The autonomous endpoint provisioning walkthrough (three runnable steps) - The agents marketing-page overview with FAQs covering common agent questions Not included in this file — fetch the scoped indexes at the bottom instead: - Per-chain RPC method references (80+ chains) → `https://www.quicknode.com/docs/llms.txt` - Developer guides and tutorials → `https://www.quicknode.com/guides/llms.txt` - Builder's Guide tool comparisons and use-case blueprints → `https://www.quicknode.com/builders-guide/llms.txt` - x402 protocol specification → `https://x402.quicknode.com/llms.txt` - MPP protocol specification → `https://mpp.quicknode.com/llms.txt` - Hyperliquid RPC docs → `https://www.quicknode.com/docs/hyperliquid/llms.txt` --- ## Core Platform --- ### Pricing — Predictable pricing, designed to scale Simple, transparent pricing for developers, startups, and enterprises. Need more throughput or custom infrastructure? See Enterprise below. **Source:** https://www.quicknode.com/pricing #### Plans ##### Free trial — $0/mo Start building with no commitment. Includes 1 month free. - 10M API credits included - No additional API credits - 15 requests/second - Streams, Webhooks - Community support **Get started:** https://www.quicknode.com/signup ##### Build — $49/mo (or $42/mo billed annually) For projects ready to move beyond prototyping. - 80M API credits included - $0.62/1M additional API credits - 50 requests/second - Streams, Webhooks, IPFS - 10 endpoints - 24-hour SLA - Ticket support ##### Accelerate — $249/mo (or $212/mo billed annually) ★ Recommended For teams scaling fast and needing more headroom. - 450M API credits included - $0.56/1M additional API credits - 125 requests/second - Streams, Webhooks, IPFS - 20 endpoints - 12-hour SLA - Ticket support ##### Scale — $499/mo (or $424/mo billed annually) For high-throughput applications with serious reliability requirements. - 950M API credits included - $0.53/1M additional API credits - 250 requests/second - Streams, Webhooks, IPFS - 50 endpoints - 8-hour SLA - Ticket support ##### Business — $999/mo (or $849/mo billed annually) For production applications demanding maximum performance. - 2B API credits included - $0.50/1M additional API credits - 500 requests/second - Streams, Webhooks, IPFS - 50 endpoints - 8-hour SLA - Ticket support ##### Enterprise — Custom pricing For high-volume workloads, custom infrastructure, and enterprise compliance needs. - Volume discounts - Custom RPS - Dedicated clusters - Unlimited endpoints - Dedicated support with premium SLA - SSO & RBAC (SAML 2.0) - Enhanced analytics + Prometheus Exporter - SOC1 & SOC2 Type 2 certified - Pay fully in crypto **Contact Sales:** https://www.quicknode.com/contact-us ##### Agent Subscription API — For autonomous AI agents Provision any paid plan above programmatically, without human signup. An agent pays via x402 or MPP from a funded EVM wallet, receives a `QN_*` API key, and then creates RPC endpoints via the Admin API. - Create subscription: `POST https://www.quicknode.com/api/v1/agent/subscriptions` - Create RPC endpoint (with the returned key): `POST https://api.quicknode.com/v0/endpoints` **Walkthrough:** https://www.quicknode.com/agents/create-endpoint.md #### Feature Comparison ##### RPC | RPC | Free | Build | Accelerate | Scale | Business | Enterprise | | ------------------------------- | ----- | ------ | ---------- | ------ | -------- | ---------- | | API Credits | 10M | 80M | 450M | 950M | 2B | Custom | | Additional API Credits (per 1M) | — | $0.62 | $0.56 | $0.53 | $0.50 | Custom | | Endpoints | 1 | 10 | 20 | 50 | 50 | Unlimited | | Requests per second | 15 | 50 | 125 | 250 | 500 | Custom | | All supported chains | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Multi-chain endpoints | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Archive data | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Metered gRPC data | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Trace & Debug | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Advanced metrics | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Advanced security controls | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Logs retention | — | 1 hour | 1 day | 1 day | 1 day | 14 days | | Rate limit by method | — | — | ✓ | ✓ | ✓ | ✓ | | Dedicated Clusters | — | — | — | — | — | ✓ | | Volume discount | — | — | — | — | — | ✓ | ##### Platform Features | Platform Features | Free | Build | Accelerate | Scale | Business | Enterprise | | ----------------------- | ---- | ----- | ---------- | ----- | -------- | ---------- | | Admin API | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Pay in Crypto | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Prometheus Exporter | — | — | — | — | — | ✓ | | SSO (SAML 2.0) | — | — | — | — | — | ✓ | | RBAC | — | — | — | — | — | ✓ | | SOC1 & SOC2 Type 2 | — | — | — | — | — | ✓ | ##### Streams | Streams | Free | Build | Accelerate | Scale | Business | Enterprise | | ---------------------------- | ---- | ----- | ---------- | ----- | -------- | ---------- | | Active streams limit | 1 | 10 | 100 | 100 | 100 | 100 | | Solana active streams limit | 1 | 5 | 5 | 5 | 5 | 10 | | Filters | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Key-Value Store | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Blocks & transactions | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Event logs & receipts | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Webhook destinations | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | S3-compatible storage | — | ✓ | ✓ | ✓ | ✓ | ✓ | | PostgreSQL | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Data compression | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Reorg handling | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Traces | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Azure blob storage | — | — | ✓ | ✓ | ✓ | ✓ | ##### IPFS | IPFS | Free | Build | Accelerate | Scale | Business | Enterprise | | ------------------------- | ---- | --------- | ---------- | --------- | --------- | ---------- | | Storage included (GB/mo) | — | 10 | 25 | 35 | 50 | Custom | | Bandwidth usage rate | — | $0.06/GB | $0.05/GB | $0.04/GB | $0.03/GB | Custom | | Pinning usage rate | — | $0.10/GB | $0.09/GB | $0.08/GB | $0.08/GB | Custom | ##### Webhooks | Webhooks | Free | Build | Accelerate | Scale | Business | Enterprise | | ----------------------------- | ------ | -------- | ---------- | ---------- | ---------- | ---------- | | Active Webhooks | 1 | 10 | 20 | 50 | 50 | Custom | | API credits per matched block | 30 | 30 | 30 | 30 | 30 | 30 | | Payloads included in plan | ~333k | ~2.7M | ~15M | ~31.7M | ~66.7M | Custom | ##### Support | Support | Free | Build | Accelerate | Scale | Business | Enterprise | | ---------------------- | ---- | -------- | ---------- | -------- | -------- | ---------- | | Community support | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Ticket support | — | ✓ | ✓ | ✓ | ✓ | ✓ | | Response time (SLA) | — | 24 hours | 12 hours | 8 hours | 8 hours | Premium | #### API Credits Usage is measured in API Credits. Credits are based on compute intensity per method call. **Formula:** Method Responses × Multiplier = API Credits Once your monthly API Credits threshold is reached, additional usage is billed at the overage rate for your plan. For Build, additional usage over $200 is billed immediately. For Accelerate, Scale, and Business, additional usage over $200 is also billed immediately; amounts under the threshold are billed at end of billing cycle. Learn more: https://www.quicknode.com/api-credits #### Pricing Calculator Use the interactive pricing calculator on the pricing page to estimate your usage by chain, method, and monthly request volume. **Calculator:** https://www.quicknode.com/pricing#calculator #### Pricing FAQ **How do I get started?** Create an account, choose a plan, then select a blockchain. https://www.quicknode.com/signup **Which plan is right for my project?** For early projects: Free or Build. For scaling businesses: Accelerate, Scale, or Business. For enterprise workloads needing custom settings, optimized pricing, higher RPS, and more: Enterprise. **What are API Credits?** API Credits measure usage based on method intensity. Method Responses × Multiplier = API Credits. Multipliers apply to valid 200-status responses. See the full method list: https://www.quicknode.com/api-credits **How can I increase my limits?** Upgrade your plan instantly via the dashboard: https://dashboard.quicknode.com/billing/plan. For volume discounts and custom limits, contact sales: https://www.quicknode.com/contact-us **Can I pay in cryptocurrency?** Yes. Build, Accelerate, Scale, and Business customers can top up with crypto. Enterprise plans support fully crypto billing. **How do I upgrade or downgrade?** Sign in at https://dashboard.quicknode.com, go to Usage & Billing, and change your plan. Upgrades are effective immediately (prorated). Downgrades take effect the next billing cycle. **When am I charged for overages?** Additional usage over $200 is billed immediately on Build, Accelerate, Scale, and Business plans. Amounts under $200 are billed at end of cycle. **Can I use custom traces?** Quicknode supports approved custom traces. Contact https://www.quicknode.com/contact-us to submit yours for review. --- ## Core Products --- ### Core RPC API — Fast, Reliable Blockchain RPC Infrastructure Deploy production-ready RPC endpoints across 80+ chains in seconds. High-performance, globally distributed infrastructure built for enterprise scale. **Source:** https://www.quicknode.com/core-api #### Overview Quicknode's Core API provides globally distributed, low-latency access across every major blockchain so you can focus on your users, not your infrastructure. #### Key Features - **Speed that sets the standard** — Global network delivers real-time blockchain data with unmatched speed, reliability, and uptime. API responses average 81ms vs the 1,567ms industry average (19x faster). - **99.99% Uptime Guaranteed** — Near-perfect availability backed by a 99.99% SLA, ensuring your applications stay live without interruptions. - **80+ Chains Supported** — Connect instantly to the most-used networks in Web3. Each endpoint is optimized for speed, reliability, and real-time insights at scale. - **Supercharge with Add-Ons** — Extend your Core RPC endpoint with add-ons for NFT queries, token pricing, analytics, and more, all accessible through a unified API. #### Built-In Capabilities - Global traffic routing with automatic regional failover - Autoscaling that absorbs sudden traffic spikes without delay - Unified endpoints for seamless access across chains and networks - Real-time observability with detailed usage and error insights #### Infrastructure Options ##### Shared Quicknode's battle-tested API infrastructure delivers consistent performance and reliability at scale, powering leading projects across the Web3 ecosystem. - API responses average 81ms vs the 1,567ms industry average (19x faster). - A robust uptime SLA ensures your applications stay live and responsive. - Whether you have 10 users or 10 million, infrastructure scales effortlessly with your growth. ##### Dedicated Clusters Built for teams that demand peak performance and total control, customizable to your needs and backed by a team committed to your success. - Dedicated capacity eliminates slowdowns from complex computations or network congestion. - Simplify operations with fixed monthly pricing so you can focus on innovation, not maintenance. - Exclusive access to a private node group built on the highest redundancy standards in Web3. #### Security & Compliance SOC 1, SOC 2, and ISO 27001 certified. --- ### Dedicated Clusters — High-Scale Blockchain Infrastructure Deploy dedicated node clusters with unmatched redundancy, performance, and global uptime. Purpose-built infrastructure for mission-critical workloads. **Source:** https://www.quicknode.com/clusters #### Overview Dedicated Clusters are engineered for maximum uptime and reliability, powering the world's leading Web3 brands with consistent, enterprise-grade performance. #### Key Features ##### Truly Unmetered Built to handle demanding workloads at scale. Whether powering apps, executing DeFi strategies, or running event-driven workflows, Dedicated Clusters adapt to your throughput needs with stable, predictable results. ##### Greater Redundancy, More Peace of Mind Eliminate downtime concerns with Dedicated Clusters. Each cluster runs two or more nodes of the same chain within a region, forming a fully redundant, mirrored system with independent distribution paths for maximum reliability. ##### Your Operations, Fully Isolated Dedicated Clusters provide an isolated environment free from shared traffic spikes, ensuring consistent performance and lower latency. - Fully isolated resources protect your operations from external threats and internal bottlenecks. - Built on the same infrastructure principles trusted by the world's leading enterprises. ##### Local Superiority, Global Reach Run your operations where you need them, when you need them. Choose your preferred global locations to deliver consistent performance across every region without compromise. **Available regions:** London UK, Montreal Canada, Mumbai India, Oregon USA, Dublin Ireland, Frankfurt Germany. ##### One Price, Zero Surprises No overages. No rate limits. No hidden multipliers. Dedicated Clusters offer predictable monthly pricing, simplifying your budget and removing the headaches of managing multiple providers. #### Shared vs. Dedicated Comparison ##### Shared Quicknode's battle-tested API infrastructure delivers consistent performance and reliability at scale. - API responses average 81ms vs the 1,567ms industry average (19x faster). - Robust uptime SLA ensures your applications stay live and responsive. - Scales from 10 users to billions without volume concerns. ##### Dedicated Designed for those who need ultimate performance, customizable to their needs, backed by a dedicated team. - Dedicated capacity — no performance lags from complex computations or network overloads. - Fixed monthly rate — focus on innovation, not infrastructure management. - Exclusive access to the node group, following the highest redundancy principles in Web3. --- ### Streams — Real-Time Blockchain Data Streaming Stream blockchain data continuously with no polling. Quicknode Streams delivers reliable, push-based pipelines for analytics, trading, and AI systems. **Source:** https://www.quicknode.com/streams #### Overview Access fast, reliable, and scalable onchain data with Quicknode Streams, built to power everything from live alerts to high-volume analytics. #### How It Works From setup to delivery, Streams makes it easy to collect, filter, and route blockchain data. No servers, no manual pipeline maintenance required. 1. Connect your stream to a blockchain network 2. Apply filters and transformations 3. Deliver data to your webhook, data warehouse, or analytics system #### Key Benefits - **Predictable, usage-based pricing** — Streams consumes API credits according to the number of blocks processed by your stream, based on the network and dataset, so usage stays transparent and easy to forecast. - **7x Faster Backfills** — Sync historical data up to seven times faster than legacy pipelines. No polling and no infrastructure to maintain. - **80+ Hours Saved** — Eliminate manual pipelines. Automatically stream on-chain data to your webhook or warehouse and free your team to focus on innovation. #### ETL Pipelines Without the Overhead Get blockchain data at scale without servers or maintaining manual pipelines. Reduce latency, cut costs, and power responsive applications effortlessly. #### Customer Testimonials > "Quicknode Streams is a promising technology for allowing both new and existing builders to have significantly better blockchain processing pipelines. After successful proof of concepts on limited use cases, we are looking to expand Streams across our entire stack for core functionalities, like balance, transaction history, and more." > — Andrei Terentiev, CTO, Bitcoin.com > "The outstanding real-time performance helps us deliver the freshest analytics to our users — key to maintaining our competitive edge in the industry." > — Nirmal, Head of Engineering, Artemis --- ### Streams Backfills — One-Click Historical Blockchain Data Backfill historical blockchain data with prebuilt templates for major networks. Fast, accurate delivery for analytics, indexing, and compliance workloads. **Source:** https://www.quicknode.com/streams/backfills #### Overview One-Click Backfills let you retrieve historical blockchain data with guaranteed delivery and flexible batching. Prebuilt templates make it fast to get started on major networks. #### Key Features - Prebuilt templates for major blockchain networks - Guaranteed delivery with no data gaps - Flexible batching for analytics, indexing, and compliance workloads - Fast historical data retrieval — up to 7x faster than legacy pipelines - No infrastructure to maintain #### Use Cases - **Analytics** — Backfill historical on-chain data for dashboards and reporting - **Indexing** — Populate databases and search indexes with blockchain history - **Compliance** — Retrieve historical transaction data for audit and regulatory requirements --- ### Webhooks — Real-Time Blockchain Event Notifications Receive instant blockchain event notifications across 80+ chains with reliable, low-latency webhooks designed for high-volume applications. **Source:** https://www.quicknode.com/webhooks #### Overview Web3 webhooks you can set up in seconds with guaranteed delivery across 130+ networks. Pay only when they deliver. #### How It Works — Go Live in Three Steps No WebSockets or custom polling logic required. Just point, paste, and start receiving events in seconds. 1. Choose a no-code template or configure custom filters 2. Enter your wallet or contract address 3. Add your webhook URL and start receiving events #### No-Code Templates Deploy in seconds with pre-built templates by simply adding your wallet or contract address. | Template | Network | Description | |---|---|---| | Wallet Activity Monitor | Solana Mainnet | Get alerts when SOL or SPL Tokens move to or from specified accounts | | Contract Events | Base Mainnet | Get notified when a contract emits an event | | Parsed Contract Events | Ethereum Mainnet | Get parsed event logs based on a provided ABI | | Wallet Activity Monitor | Bitcoin Mainnet | Monitor specified wallets for Bitcoin transfers | | Wallet Activity Monitor | Tron Mainnet | Get notified when a wallet sends or receives tokens on Tron | | Wallet Activity Monitor | Ethereum Mainnet | Get notified when a wallet sends or receives tokens on Ethereum | #### Features — Built for Speed, Hardened for Production - **Guaranteed Delivery** — Your webhook receives each event exactly once, with no duplicates and no omissions. - **No-Code Templates** — Point, click, and deploy your Web3 webhook in seconds. - **Pay Per Matching Block** — Pay only when a block matches your filter. No unnecessary charges for unrelated events. - **Supports 90+ Networks** — Use no-code templates across Solana, Ethereum, Bitcoin, and more. - **Reorg Handling** — Webhooks automatically manage chain reorganizations so your data always stays current. - **Robust Retries** — Automatic retries and recovery if your backend goes down, ensuring reliable delivery every time. #### Pricing Simple, usage-based pricing. Only pay for what you use. Each successful webhook delivery is metered by credits, not features. --- ### IPFS — Gateways and Pinning for Blockchain Applications Store and access decentralized data with fast, reliable IPFS gateways and pinning services, optimized for blockchain developers and production apps. **Source:** https://www.quicknode.com/ipfs #### Overview Upload, store, and retrieve data seamlessly through dedicated gateways and managed pinning, with no node maintenance needed. #### Why IPFS - **Decentralized** — Built on open-source software and a peer-to-peer network, IPFS distributes data across multiple nodes instead of relying on a single central server. - **Trust** — Every file and block in IPFS is content-addressed with a unique hash, ensuring data integrity and verifying that nothing has been altered. - **Efficiency** — Data is retrieved from the nearest or fastest nodes, reducing bandwidth usage and improving speed across global networks. - **Cost-Effective** — Skip the overhead of running your own IPFS nodes. Pin files and access content instantly through dedicated, high-performance gateways. #### Gateway Features Your gateway to the IPFS network. Deliver IPFS content instantly through Quicknode's gateways for a seamless experience your users can trust. - **Dedicated for Performance** — Retrieve content from a global edge network optimized for speed, ensuring fast, consistent delivery for your users. - **Private or Public Access** — Configure your gateway to be public or private, giving you full control over visibility and access. - **Trust and Security** — Content addressing uses unique cryptographic hashes to locate and verify data, ensuring data integrity and permanence. - **Custom Domains** — Use your own domain to keep branding consistent and deliver a professional, integrated experience. #### Pinning Secure storage and pinning through the dashboard or API, with no nodes to manage or infrastructure to maintain. #### Use Cases - **NFTs** — Launching a new project? Ensure your NFTs are stored safely and securely on IPFS. - **Gaming** — Store your game assets on IPFS and ensure scalable and secure storage. - **Metaverse** — IPFS enables secure data access vital for expansive metaverse applications. #### Pricing Get started with IPFS as part of your paid plan, and scale up your usage as needed with pay-as-you-go. - **Storage** — Up to 50 GB of file storage included, depending on plan. - **Bandwidth** — 1 dedicated gateway free to get started. Up to 50 GB included depending on plan. Additional bandwidth starts at $0.06/GB. --- ### Solana gRPC — High-Speed Solana Data Streaming Access real-time Solana data through Yellowstone-compatible gRPC with unmatched speed and reliability. Ideal for trading, analytics, and large-scale apps. **Source:** https://www.quicknode.com/solana-grpc #### Overview Get real-time Solana data from ShredStream leaders with global reliability and performance that keeps you ahead. Available as an add-on or as dedicated nodes optimized for peak performance. #### Options ##### Add-On (Instant Start) Start instantly with the Solana gRPC add-on. Available through the Quicknode Marketplace. ##### Dedicated Nodes Scale up with dedicated nodes optimized for peak performance, reliability, and control. Both options offer Geyser gRPC built for scale. #### Use Cases — Built for Latency-Critical Applications Milliseconds matter in real-time Solana workloads. Tracking blocks, accounts, or transactions at scale requires globally distributed, high-availability nodes. - **High-Frequency Trading** — React to slot and account updates in real time to capture optimal execution windows. - **Arbitrage Snipers** — Stream program updates the instant they're processed so you never miss an opportunity. - **MEV Bots** — Leverage live Solana data to drive precise liquidation and arbitrage strategies. #### Developer Resources - [Solana gRPC Overview](https://www.quicknode.com/docs/solana/solana-grpc/overview) — Get started with the add-on, configure endpoints and tokens, and make your first requests. - [Monitor Solana Liquidity Pools with gRPC (Go)](https://www.quicknode.com/guides/solana-development/tooling/solana-grpc/solana-grpc-go) — Subscribe to SOL/USDC pool transactions and monitor real-time activity across Raydium liquidity pools. - [Monitor Solana Programs with gRPC (Rust)](https://www.quicknode.com/guides/solana-development/tooling/solana-grpc/solana-grpc-rust) — Build a program monitoring system that detects Raydium Launchpad transactions. - [Parse Real-Time Solana Program Data with gRPC and Carbon](https://www.quicknode.com/guides/solana-development/tooling/solana-grpc/solana-grpc-carbon) — Create a Pump.fun transaction monitor using gRPC with Carbon. --- ### Solana Validator — Zero-Fee Staking with 100% Uptime Stake SOL with Quicknode's high-performance Solana validator offering 0% fees, industry-leading uptime, and enterprise-ready reliability. Perfect for both users and institutional staking. **Source:** https://www.quicknode.com/chains/solana/validator #### Overview Stake confidently with Quicknode's premier validator and earn high APY with no fees and no commissions. #### Why Choose Quicknode's Validator - **100% MEV Rewards** — All MEV rewards are passed directly back to stakers through Jito, maximizing your yield with full transparency. - **Network Strengthening** — Your stake doesn't just earn rewards; it helps secure and strengthen the Solana network for every builder. - **Zero fees and zero commissions** — 100% of rewards go to stakers. - **Enterprise-grade security** — SOC 1, SOC 2, and ISO 27001 certified infrastructure. #### Enterprise Staking Custom staking solutions available for institutional clients. Contact the team of Solana experts for enterprise staking arrangements. --- ### Validator as a Service — Enterprise-Grade Blockchain Validators Run enterprise-grade blockchain validators without the operational overhead. Quicknode's Validator as a Service offers SLAs, performance optimization, and white-label support for teams that need reliability at scale. **Source:** https://www.quicknode.com/validator-as-a-service #### Overview Launch a fully customized validator on Quicknode's enterprise-grade infrastructure while we manage the systems and operations behind it. #### Infrastructure Built on industry-leading uptime and global availability, Quicknode provides the reliability and performance required to run validators at scale. - **Guaranteed Availability** — Backed by a 99.99% uptime SLA and 24/7 monitoring to keep validators running reliably. - **Multi-Chain Expertise** — Operational expertise across 78+ diverse blockchain ecosystems to manage validators at scale. - **Globally Distributed Infrastructure** — Optimized for low latency and high performance across regions, delivering reliable access to your users worldwide. #### Why Businesses Choose Quicknode VaaS Focus on your users, product, and growth while we deliver a secure, production-ready validator optimized for performance and yield. - **Faster Time to Market** — Launch production-ready validators in days. No internal DevOps, SRE, or specialized engineering teams required. - **Complete Customization** — Take full control over branding, fees, commissions, and user experience to match your business model. - **Optimized Returns** — Capture higher yield through MEV strategies, optimized block production, and efficient infrastructure. - **Enterprise-Grade Security** — Multi-layered security and compliance controls audited against SOC 1, SOC 2, and ISO 27001 standards. - **Priority Support** — 24/7 dedicated support with rapid response times and direct access to engineers for mission-critical operations. #### Who It's Built For ##### Exchanges and Fintech Platforms Offer staking directly inside your product while maintaining full ownership of fees, commissions, and delegator relationships. ##### Custodians and Wallet Providers Provide secure, branded staking experiences supported by enterprise-grade infrastructure and continuous monitoring. ##### Funds and Asset Managers Operate dedicated validators for fund assets to capture full rewards, improve yield efficiency, and maintain control over how AUM is staked. ##### Corporate Treasuries Stake treasury assets on a dedicated validator that improves capital efficiency and aligns with enterprise-grade governance and audit requirements. --- ### Admin API — Manage Your Quicknode Infrastructure with Code Use one REST API to create endpoints, monitor usage, configure security, and manage teams across your Quicknode infrastructure. Built for developers and enterprise teams. **Source:** https://www.quicknode.com/admin-api #### Overview One REST API for everything you do in the Quicknode dashboard. Manage endpoints, configure security, and monitor spending from your terminal or AI agent. #### Stats - 130+ blockchain networks supported - 99.99% API uptime backed by SLAs - 40+ endpoints for full dashboard control #### What You Can Manage ##### Manage Endpoints Create, configure, pause, and archive endpoints across any blockchain. Set rate limits, update security settings, and organize with tags through REST API calls. ##### Monitor Usage & Spending Track credit consumption in real-time by endpoint, method, or chain. Set up alerts before hitting limits and pull billing history on demand. ##### Manage Teams Add members, assign roles, and control endpoint access at scale. Built for organizations with multiple developers or environments. ##### Control Security Configure JWT authentication, IP allowlists, referrer restrictions, and token-based access controls. #### Getting Started ##### Authentication Generate an API key from your dashboard and include it in your request headers. No OAuth flows or token management — include the key in the `x-api-key` header. ##### Standard HTTP Methods Make requests with GET, POST, PATCH, and DELETE. Familiar REST conventions with predictable endpoints. Use it in scripts, CI/CD pipelines, monitoring tools, or AI agents. #### Building with AI Agents Use our Quicknode MCP for instant Admin API context in Claude Desktop and agentic workflows. - MCP Documentation: https://www.quicknode.com/docs/build-with-ai/quicknode-mcp #### Who It's For ##### Developers Integrate Quicknode into your existing workflows. Script repetitive tasks, build custom tooling, or let AI agents handle infrastructure management. ##### Enterprise Teams Centralize operations across projects and environments. Track spending by team, enforce policies organization-wide, and maintain compliance with audit logs. #### Admin API FAQ **What is the Quicknode Admin API?** The Quicknode Admin API is a REST API that allows you to programmatically manage your Quicknode account and infrastructure configuration. Instead of using the dashboard UI, you can create and configure endpoints, monitor usage, control security settings, and manage teams using standard HTTP requests. It provides automation capabilities for infrastructure management, not blockchain RPC execution. **What can I manage with the Admin API?** Create, update, pause, and archive blockchain endpoints; configure rate limits and security settings (JWT, IP allowlists, referrer restrictions); monitor API credit usage and spending in real time; retrieve billing history and usage data; create and manage teams and assign role-based access. **When should I use the Admin API?** Use the Admin API when you need to manage your Quicknode infrastructure programmatically. To send blockchain requests (eth_call, solana_getBalance), use RPC endpoints. To ingest deterministic blockchain data, use Streams. The Admin API is designed for infrastructure and account management, not blockchain data execution. **What does the Admin API not do?** The Admin API does not execute blockchain RPC methods or return transaction or block data. It does not replace RPC endpoints for blockchain requests, Streams for block ingestion, or data indexing tools. **Is the Admin API available on all plans?** Available on all paid plans — Build, Accelerate, Scale, Business, and Enterprise. Not included in the Free Trial plan. **How do I authenticate?** Generate an API key from your Quicknode dashboard and include it in the `x-api-key` header. No OAuth flow or token exchange required. #### Security Enterprise-grade security with SOC 1, SOC 2, and ISO 27001 compliance. --- ### ChainKit — Launch and Scale Your Blockchain Launch and operate your blockchain with infrastructure, visibility, and developer tooling from day one. Proven across 30+ live chain partnerships. **Source:** https://www.quicknode.com/chainkit #### Overview The complete platform for chains to ship fast, scale reliably, and reach developers. ChainKit delivers the essentials through a coordinated, modular stack operated by Quicknode. #### Why ChainKit Launching a blockchain today requires more than just keeping a network online. Successful networks need resilient infrastructure and ecosystem readiness, with reliability, visibility, and developer tooling built in. #### Infrastructure The foundational infrastructure to launch your chain and operate it reliably at scale. - **Production RPC & Public Endpoints** — Low-latency RPC and public endpoints built for fast responses and high-throughput traffic, supporting sustained and burst workloads up to 50k requests per second. - **Managed Validator Services** — Actively monitored, performance-tuned validators that ensure consistent block production and network stability. - **Enterprise-Grade Security** — Continuous monitoring and layered protections, backed by SOC compliance and ISO certification. #### Ecosystem The ecosystem tools that make your chain discoverable and developer-ready from day one. - **Public Visibility** — Branded block explorer and testnet faucet that surface onchain activity and enable immediate network interaction. - **Queryable Onchain Data** — Indexing and subgraph hosting that organize blockchain data for applications, analytics, and integrations. - **Developer & App Enablement** — Token APIs, account abstraction, and paymaster support that let developers build modern applications without infrastructure overhead. - **User & Network Protection** — Threat detection and MEV protection that safeguard users, applications, and network integrity. #### One Integration, One Accountable Partner From launch through long-term operation and ecosystem expansion, Quicknode delivers everything your chain needs through a single integration with end-to-end ownership. - **Priority Support from Dedicated Engineers** — 24/7 priority support with minute-level response times and holistic issue management across infrastructure, ecosystem services, and integrations. - **Ecosystem Extensions, Managed for You** — Extend beyond core capabilities as your network grows. Quicknode coordinates and operates partner integrations within the same accountable system. No vendor sprawl, extra contracts, or fragmented support. #### ChainKit FAQ **Do we need ChainKit if we already have some partners?** ChainKit is modular. If you already use certain services, we can coordinate what you keep and unify the rest under one accountable relationship. **Can we start small and expand later?** Yes. Start with what you need today and add modules as your ecosystem grows. **Can we run our own explorer?** You can, but most forks are expensive to maintain and often break at scale. RPC costs alone can reach $50–$100k+ per year for common setups, excluding infrastructure usage. Block Explorer is managed, customizable, and designed to scale with your network. **Can we build this ourselves?** You can, but most teams underestimate the time, cost, and operational overhead required to reach production reliability. --- ### Hyperliquid — Managed Infrastructure for the Fastest Onchain Orderbook Build trading bots, analytics dashboards, and DeFi apps on Hyperliquid with enterprise-grade RPC, gRPC streaming, and a purpose-built SDK for Hyperliquid. **Source:** https://www.quicknode.com/chains/hyperliquid #### Overview HyperCore for Hyperliquid is Quicknode's managed infrastructure for the Hyperliquid L1 — the only provider with full HyperCore and HyperEVM coverage under a single endpoint. Access 50+ info methods, historical block data, standard EVM JSON-RPC, advanced tracing, and 9 gRPC streams including exclusive L2 and L4 orderbook depth. #### Key Features - **Single Endpoint, Full Coverage** — One base URL serves four API paths (`/info`, `/hypercore`, `/evm`, `/nanoreth`) plus gRPC on port `:10000`. No juggling multiple providers. - **9 gRPC Streams** — Real-time trades, orders, book updates, TWAP, events, blocks, writer actions, and gRPC-exclusive L2 and L4 orderbook depth with zstd compression. - **Purpose-Built SDK** — TypeScript, Python, Go, and Rust clients with one-line trading, fluent order builders, and typed access to every API surface. - **Higher Rate Limits** — 50–500 RPS depending on plan, well above Hyperliquid's public API limits. - **Enterprise Reliability** — 99.99% uptime SLA, SOC 1/2 Type II and ISO 27001 certified. #### API Paths ##### /info — Market Data and User State 50+ HyperCore info methods covering market data, user positions, vault details, delegations, borrow/lend state, funding history, and exchange metadata. ##### /hypercore — Historical Blocks and Order Management Query historical block data across all stream types (trades, orders, book updates). Build, sign, and send orders programmatically with preflight validation. ##### /evm — Standard Ethereum JSON-RPC Full Ethereum JSON-RPC for HyperEVM (chain ID 999). Accounts, transactions, blocks, logs, gas estimation — everything you need for smart contract interaction on HyperEVM. ##### /nanoreth — Advanced HyperEVM Tracing, debugging, and system transaction access for HyperEVM. Includes `debug_traceTransaction`, `trace_block`, and HyperEVM-specific methods like `eth_getSystemTxsByBlockNumber`. #### gRPC Streaming Nine real-time data streams available on port `:10000` with `x-token` authentication: | Stream | Description | Availability | |--------|-------------|--------------| | Trades | Executed trades with price, size, and side | gRPC + WebSocket | | Orders | Full order lifecycle with 18+ status types | gRPC + WebSocket | | Book Updates | L2 orderbook changes (deltas) | gRPC + WebSocket | | TWAP | TWAP algorithm execution data | gRPC + WebSocket | | Events | Funding payments, liquidations, governance | gRPC + WebSocket | | Writer Actions | Spot token transfers and system writes | gRPC + WebSocket | | Blocks | Raw HyperCore blockchain data | gRPC only | | **StreamL2Book** | Aggregated depth snapshots by price level | **gRPC only** | | **StreamL4Book** | Individual order-level depth with diffs | **gRPC only** | All streams support zstd compression for ~70% bandwidth reduction and field-level filtering. **StreamL2Book** delivers full depth snapshots every block — ideal for depth charts and price displays. **StreamL4Book** provides individual order visibility (wallet address, order ID, queue position) — built for market makers and HFT systems. #### SDK A purpose-built SDK for Hyperliquid available in four languages: - **TypeScript:** `npm install @quicknode/hyperliquid-sdk` - **Python:** `pip install hyperliquid-sdk` - **Go:** `go get github.com/quiknode-labs/hyperliquid-sdk/go` - **Rust:** `cargo add quicknode-hyperliquid-sdk` ##### Sub-Clients | Client | Surface | Methods | |--------|---------|---------| | `sdk.info` | Market data, user state, vaults, delegations | 50+ | | `sdk.core` | Block queries, order management, build-sign-send | 30+ | | `sdk.evm` | Ethereum JSON-RPC for HyperEVM | 50+ | | `sdk.stream` | WebSocket subscriptions | 20+ | | `sdk.grpc` | gRPC streaming (all 9 streams) | 9 | ##### One-Line Trading ```typescript await sdk.marketBuy("BTC", { size: 0.001 }); await sdk.marketSell("ETH", { notional: 100 }); await sdk.buy("BTC", { size: 0.001, price: 65000 }); ``` ##### Fluent Order Builder ```typescript import { Order } from '@quicknode/hyperliquid-sdk'; await sdk.order(Order.buy("BTC").size(0.001).price(65000).gtc().reduceOnly()); ``` Supports market, limit, stop-loss, take-profit, TWAP, and scale orders. Trigger orders, leverage management, vault deposits, staking, and cross-account transfers are all built in. **44 runnable examples** in the [examples repository](https://github.com/quiknode-labs/hyperliquid-examples). #### Streams Integration Use Quicknode Streams for push-based filtered delivery of Hyperliquid data: - Write JavaScript filter functions that run on every block or event - Matching data delivered to webhooks automatically - Historical backfills available for replaying past data - No polling, no WebSocket management — just filtered pushes #### Use Cases - **Trading Bots and HFT** — Low-latency order execution with gRPC streaming and one-line SDK trading - **Portfolio Trackers** — Real-time position, P&L, and funding data via WebSocket and Info API - **Orderbook Visualization** — L2 depth charts and L4 individual-order views via gRPC-exclusive streams - **Whale Monitoring and Alerts** — Track large orders and liquidations with Streams push delivery - **DeFi Analytics on HyperEVM** — Standard EVM tooling (Hardhat, Foundry, ethers.js) works out of the box on chain ID 999 #### Why Quicknode vs. Native Hyperliquid API | | Quicknode | Native HL API | |---|---|---| | Rate limits | 50–500 RPS | Public tier limits | | Uptime SLA | 99.99% guaranteed | Best-effort | | Push delivery | Streams (filtered webhooks) | Not available | | L2/L4 orderbook | gRPC with managed infra | Self-hosted only | | Compliance | SOC 1/2, ISO 27001 | None | | Multi-chain | 78+ chains from one platform | Hyperliquid only | | SDK | TypeScript, Python, Go, Rust | Python, Rust (official) | #### Hyperliquid Pricing Summary - **Free trial:** 1 month, 10M credits, 15 RPS - **Build:** From $49/mo - **Scale:** Up to $999/mo - **Enterprise:** Custom pricing with dedicated infrastructure --- ## For AI Agents --- ### Quicknode for AI Agents Multi-chain blockchain infrastructure for AI agents. RPC access, transaction simulation, token data, real-time streams, and SQL queries across 80+ chains and 130+ networks. **Source:** https://www.quicknode.com/agents.md #### Quickstart: provision an endpoint For autonomous agents with a funded EVM wallet and no Quicknode account. 1. **Pay → receive API key.** `POST https://www.quicknode.com/api/v1/agent/subscriptions` with `PAYMENT-SIGNATURE` (x402) or `Authorization: Payment` (MPP). POST with no body to receive a 402 listing all plans, networks, and payment accepts. Response returns a `QN_*` API key. 2. **Use key → create endpoint.** `POST https://api.quicknode.com/v0/endpoints` with body `{"chain":"base","network":"base-mainnet"}` and header `x-api-key: QN_*`. Admin API. Returns an RPC URL. 3. **Use the RPC.** Standard JSON-RPC POSTs to the returned URL. Full runnable walkthrough (every field, curl, response shape): https://www.quicknode.com/agents/create-endpoint.md Admin API full spec: https://www.quicknode.com/api-docs/v0/swagger.json #### Choose Your Path - **Autonomous agent, no account?** → x402 or MPP (pay-per-request with stablecoins) - **Autonomous agent needs to create endpoints via its own subscription?** → Agent Subscription API + Admin API (pay → API key → create endpoint). See Quickstart above. - **Agent with a Quicknode account?** → API Key - **AI coding agent generating Quicknode code?** → Install Blockchain Skills - **AI assistant managing infrastructure?** → Connect MCP Server #### Authentication ##### x402 — No Account Required Use x402 if you want agents to authenticate and pay using only a wallet, no accounts or API keys required. It's an open standard (developed by Coinbase) built on HTTP 402, using SIWX (Sign-In with X) for authentication. Agents sign a SIWE (EVM) or SIWX (Solana) message, receive a JWT, and pay in stablecoins. Fully programmatic. No human in the loop. ```javascript import { createQuicknodeX402Client } from "@quicknode/x402"; const client = await createQuicknodeX402Client({ baseUrl: "https://x402.quicknode.com", network: "eip155:84532", // pay on Base Sepolia evmPrivateKey: "0x...", }); const response = await client.fetch( "https://x402.quicknode.com/ethereum-mainnet", { method: "POST", body: JSON.stringify({ jsonrpc: "2.0", method: "eth_blockNumber", params: [], id: 1, }), } ); ``` - Three payment models: - **Per-request**: $0.001 per request — no auth required, pay on every call - **Nanopayment**: $0.0001 per request via Circle Gateway — sub-cent payments (Quicknode is the first infra provider with Circle Nanopayments via x402) - **Credit drawdown**: $10 USDC = 1,000,000 credits on mainnet — authenticate via SIWX, consume credits per request - Payment networks: Base, Solana, Polygon (USDC), XLayer (USDG). The payment chain determines how you pay, not which networks you can query — pay on Base and query Solana, or any other combination across 80+ chains. - Auth: SIWE (EVM) or SIWX (multi-chain including Solana). The `@quicknode/x402` SDK handles SIWX auth, payment negotiation, and JWT session management automatically. - Access: Per-request and nanopayment support JSON-RPC and REST only. For WebSocket or gRPC streaming connections, use credit drawdown mode. - On credit exhaustion: requests return HTTP 402. The SDK auto-signs a payment and retries. Or top up wallet manually. - NPM: `@quicknode/x402` (recommended), `@x402/fetch`, `@x402/evm`, `@x402/svm` - Docs: https://www.quicknode.com/docs/build-with-ai/x402-payments ##### MPP — No Account Required Machine Payments Protocol (IETF Internet-Draft by Tempo Labs and Stripe). A second wallet-based payment option alongside x402. No signup, no API key. ```javascript import { Mppx, tempo } from "mppx/client"; import { privateKeyToAccount } from "viem/accounts"; const account = privateKeyToAccount("0x..."); // Polyfills globalThis.fetch — all subsequent fetch() calls handle 402 automatically Mppx.create({ methods: [tempo({ account })], }); const response = await fetch("https://mpp.quicknode.com/ethereum-mainnet", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", method: "eth_blockNumber", params: [], id: 1, }), }); ``` - Payment methods: PathUSD on Tempo or USDC on Solana - Two intents: - **Charge**: $0.001 per request — simple one-time payment per call - **Session**: $0.00001 per request — open a payment channel, send off-chain vouchers per request (100x cheaper, best for high-volume agents) - Same 130+ network coverage as x402 - On payment required: HTTP 402 with `WWW-Authenticate: Payment` challenge. The `mppx` SDK handles payment negotiation automatically. - NPM: `mppx` (Tempo), `solana-mpp` (Solana) - Docs: https://www.quicknode.com/docs/build-with-ai/mpp-payments ##### API Key Standard authentication with a Quicknode account. ```shell curl https://YOUR_ENDPOINT.quiknode.pro/ \ -X POST \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' ``` - Get a key: https://www.quicknode.com/signup - On auth failure: HTTP 401. Verify API key and endpoint URL. - Pricing: https://www.quicknode.com/pricing.md ##### Agent Subscription API Create a Quicknode subscription programmatically to obtain a `QN_*` API key. RPC endpoints are then created via the Admin API using that key — see Quickstart at the top of this section for a runnable 3-step example. Use this flow when an agent needs a full account; for one-off RPC calls use x402 or MPP above. Base URL: `https://www.quicknode.com`. Pay via x402 v2 (`PAYMENT-SIGNATURE` header) or MPP (`Authorization: Payment `). Call any endpoint without payment to get a 402 listing required fields, plans, and accepted payment methods. - `POST /api/v1/agent/subscriptions` — create account + plan. Returns a one-time `QN_*` API key. - `POST /api/v1/agent/top_up` — add credit. Requires API key + payment. Idempotent on payment tx hash. - `GET /api/v1/agent/balance` — current balance. Requires API key. After subscription, create RPC endpoints via the Admin API at `https://api.quicknode.com`: - `POST https://api.quicknode.com/v0/endpoints` — body: `{"chain","network"}`; auth: `x-api-key: QN_*`. Full spec: https://www.quicknode.com/api-docs/v0/swagger.json API key auth: `x-api-key: QN_*` or `Authorization: Bearer QN_*`. Rate limits: `/subscriptions` 20/min/IP + 5/hour/email; `/top_up` 30/min; `/balance` 60/min. #### Agent Quick Start ##### 1. Install Blockchain Skills (for AI coding agents) Give your agent accurate knowledge of Quicknode's full API surface: ``` npx skills add https://github.com/quiknode-labs/blockchain-skills --skill quicknode-skill ``` Works with: Claude Code, Cursor, Codex, OpenCode, Windsurf ##### 2. Connect MCP Server (for AI assistants) Manage Quicknode infrastructure through natural language. The MCP server is hosted remotely and authenticates via OAuth — no API key needed. **Recommended — Remote server (OAuth):** ``` claude mcp add quicknode --transport http https://mcp.quicknode.com/mcp ``` On first connect, a browser window opens to log in with your Quicknode account. Works with: Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Zed. **Alternative — Local server (API key):** ``` npx -y @quicknode/mcp ``` Requires a `QUICKNODE_API_KEY` environment variable. Use this if you prefer local execution or can't use browser-based OAuth. MCP capabilities: create endpoints, configure security, set rate limits, review billing, monitor usage. Does NOT provide blockchain data access — use x402 or RPC endpoints for on-chain reads/writes. - Docs: https://www.quicknode.com/docs/build-with-ai/quicknode-mcp - NPM: https://www.npmjs.com/package/@quicknode/mcp ##### 3. Access Chains via x402 or MPP (for autonomous agents) No account needed. See x402 and MPP auth sections above. #### Picking the Right Tool ##### By task - Need real-time Solana monitoring? → **Yellowstone gRPC** - End-to-end EVM/Solana/UTXO/Hypercore data pipelines → **Streams** - Need Hyperliquid order book or trade data? → **HyperCore gRPC** - Need ad-hoc analytics on Hyperliquid trading data? → **SQL Explorer** - Need simple event-driven alerts? → **Webhooks** - Need to read balances, blocks, or transaction receipts? → **RPC Call** - Need to validate a transaction before broadcasting? → **Transaction Simulation** ##### By chain type | | EVM Chains | Solana | Hyperliquid | Bitcoin/UTXO | | :---- | :---- | :---- | :---- | :---- | | RPC | JSON-RPC + REST (Beacon) | JSON-RPC + WebSocket | JSON-RPC + Info API | JSON-RPC | | Real-time data | Streams | Streams + Yellowstone gRPC | HyperCore gRPC | Streams | | Tx model | Account-based, EVM opcodes | Account-based, programs | Perp/spot orders | UTXO | | Key difference | `eth_call` for reads | `getAccountInfo` for reads | `/info` for market data, `/hypercore` for blocks | No smart contracts | | Archive data | Yes | Yes | Yes | Yes | | Trace & Debug | Yes (paid plans) | No — use program logs and tx metadata instead | N/A | N/A | | Finality | ~15 min (2 epochs) | ~400ms | ~1s | ~60 min (6 confirmations) | ##### Block finality Agents acting on blockchain state must account for finality. Reading unfinalized data can lead to bad decisions — a transaction that appears confirmed may be reorged away. | Chain | Time to Finality | Safe to Act On | | :---- | :---- | :---- | | Ethereum | ~13 minutes (2 epochs, 64 slots × 12s each) | `finalized` block tag for high-value actions | | Solana | ~400ms | `confirmed` commitment for most reads, `finalized` for critical actions | | Base/Arbitrum/Optimism | ~13 min (inherits L1 finality) | Use L1 finality for withdrawals, L2 confirmation for reads | | Bitcoin | ~60 minutes (6 blocks) | 1 confirmation for small amounts, 6 for high-value | | Hyperliquid | ~1 second | Near-instant for trading actions | Rule of thumb: use `finalized` or equivalent for any action involving value transfer. Use `latest`/`confirmed` for read-only queries where speed matters more than certainty. #### API Credit Costs Every API call costs credits. Cost depends on chain and method type. | Chain Group | Base Credits | Chains | | :---- | :---- | :---- | | Tier 1 | 10 credits | Bitcoin, Bitcoin Cash, Aptos, Dogecoin, Flow, Fuel, Litecoin, Stellar | | Tier 2 | 20 credits | Ethereum, Base, Arbitrum, Optimism, Polygon, BNB, Hyperliquid, [+42 more](https://www.quicknode.com/api-credits) | | Tier 3 | 30 credits | Solana, Monad, TRON, Gnosis, zkSync, +5 more | | Tier 4 | 40 credits | Cosmos, Sui, TON, Polkadot, Stacks, XRP, +7 more | | Tier 5 | 50 credits | NEAR, Polygon zkEVM | ##### Multipliers | Method Type | Multiplier | Example Methods | | :---- | :---- | :---- | | Standard | 1x | eth_blockNumber, eth_getBalance, getAccountInfo | | Advanced | 2x | Trace & Debug, Token API, NFT API, arbtrace, txpool, Solana getAsset methods, TRON Enhanced methods | | Large | 4x | txpool_content, trace_replayBlockTransactions, trace_replayTransaction, Arbitrum: arbtrace_replayTransaction / arbtrace_replayBlockTransactions, Solana: getLargestAccounts / getSupply | **Cost formula:** Base Credits × Multiplier = Credits Per Call Examples: - `eth_getBalance` on Ethereum = 20 credits × 1x = **20 credits** - `debug_traceTransaction` on Ethereum = 20 credits × 2x = **40 credits** - `getAccountInfo` on Solana = 30 credits × 1x = **30 credits** ##### SQL Explorer credits SQL Explorer queries use API credits from your plan. Credit cost scales with query complexity and data scanned — simple queries cost standard rates, complex aggregations across large block ranges cost more. Same credit pool as RPC calls, no separate pricing. Full method-level reference: https://www.quicknode.com/api-credits #### Rate Limits and Error Handling ##### Rate limits by plan | Plan | Requests/sec | Behavior at limit | | :---- | :---- | :---- | | Free | 15 | HTTP 429 — back off and retry | | Build | 50 | HTTP 429 — back off and retry | | Accelerate | 125 | HTTP 429 — back off and retry | | Scale | 250 | HTTP 429 — back off and retry | | Business | 500 | HTTP 429 — back off and retry | | x402 | No fixed ceiling | Throttled by credit balance and network capacity. HTTP 402 on exhaustion, 429 if upstream saturated. | | Enterprise | Custom | Custom | ##### Error handling | HTTP Code | Meaning | Agent Should | | :---- | :---- | :---- | | 200 | Success | Process response | | 402 | Payment required (x402/MPP) | Top up wallet with stablecoins, retry | | 401 | Unauthorized | Check API key or re-authenticate (SIWX for x402) | | 429 | Rate limited | Exponential backoff, start at 1s, max 30s | | 500 | Server error | Retry with backoff, max 3 attempts | | 503 | Service unavailable | Retry after 5s, check status.quicknode.com | ##### Backoff strategy ``` wait = min(2^attempt * 1000ms, 30000ms) ``` On 429: respect `Retry-After` header if present. Otherwise use exponential backoff. On credit exhaustion (x402): requests fail with 402 until the wallet is topped up. Monitor credit balance proactively. ##### Parallelism When fanning out concurrent requests, stay under 70% of your plan's req/sec limit to leave headroom for retries and spikes. Example: on the Build plan (50 req/sec), cap parallel requests at ~35. Use a semaphore or token bucket to enforce this client-side. #### Example Workflow: Token Swap Safety Check A concrete multi-step flow for an agent validating a swap: ``` 1. CHECK BALANCE → eth_getBalance(wallet) — verify sufficient funds 2. GET TOKEN PRICE → Token API: get current price + slippage estimate 3. BUILD TRANSACTION → Construct swap calldata for DEX router (client-side, no API call) 4. SIMULATE → Transaction Simulation: check for reverts, gas estimate, state diffs → If simulation reverts: STOP. Return revert reason to user. 5. BROADCAST → eth_sendRawTransaction(signedTx) 6. MONITOR → Streams or Webhooks: watch for tx confirmation → If not confirmed in 3 blocks: alert user, check mempool ``` Credit breakdown on Ethereum: - Step 1: `eth_getBalance` — Standard (1x) = **20 credits** - Step 2: Token API — Advanced (2x) = **40 credits** - Step 3: Client-side — **0 credits** - Step 4: Transaction Simulation — Advanced (2x) = **40 credits** - Step 5: `eth_sendRawTransaction` — Standard (1x) = **20 credits** - Step 6: Webhook — **30 credits** per matched block Total: **~150 credits** for full flow. #### Example Workflow: Solana Wallet Monitor Watch a wallet for incoming SPL token transfers using Yellowstone gRPC and trigger an action: ``` 1. CONNECT → Open Yellowstone gRPC stream to Solana endpoint → Subscribe to account updates for target wallet 2. FILTER → Watch for token account changes (SPL Token Program) → Parse transfer instruction from transaction metadata 3. VALIDATE → getTransaction(signature) — confirm transfer details → Check: sender, token mint, amount, finality (use "confirmed" commitment) 4. ACT → If amount > threshold: trigger downstream action → If unknown token mint: flag for review, do not act 5. HANDLE ERRORS → On stream disconnect: reconnect with exponential backoff → On missed slot: use getSignaturesForAddress to backfill ``` Yellowstone gRPC connection pattern: ```javascript const { Client } = require("@quicknode/yellowstone-grpc"); const client = new Client( "https://YOUR_ENDPOINT.solana-mainnet.quiknode.pro", "YOUR_API_KEY" ); const stream = await client.subscribe(); stream.on("data", (update) => { // Handle account update if (update.account) { const accountData = update.account; // Parse SPL token transfer from account data } }); // Subscribe to account updates await stream.write({ accounts: { wallet: { account: ["TARGET_WALLET_ADDRESS"], }, }, }); ``` Credit cost: Yellowstone gRPC uses Streams payloads, not per-call RPC credits. Payload allocations vary by plan — see https://www.quicknode.com/pricing.md for current limits. #### Real-time Data Options | Method | Best For | Latency | Delivery | | :---- | :---- | :---- | :---- | | Streams | EVM/Solana real-time and historical data pipelines | Standard | Guaranteed, with reorg handling | | Yellowstone gRPC | Solana account & tx monitoring | Sub-second | Streaming | | HyperCore gRPC | Hyperliquid order book & trade data | Lowest | Streaming (10 stream types — see HyperCore gRPC Streams below) | | Webhooks | Simple event-driven HTTP notifications | Standard | Best-effort | ##### HyperCore gRPC Streams 10 stream types across two access modes. All streams available via gRPC; a subset also via JSON-RPC/WSS. | Stream | Description | Access | Use Cases | | :---- | :---- | :---- | :---- | | TRADES | All executed trades with price, size, and direction | gRPC + JSON-RPC/WSS | Trading analytics, price tracking | | ORDERS | Order lifecycle events (18+ status types including fills, cancellations) | gRPC + JSON-RPC/WSS | Order management, execution monitoring | | BOOK_UPDATES | Order book changes with bid/ask prices and quantities | gRPC + JSON-RPC/WSS | Market depth analysis, liquidity monitoring | | TWAP | TWAP execution data and algorithm progress | gRPC + JSON-RPC/WSS | Algorithmic trading, execution analytics | | EVENTS | Balance changes, transfers, deposits, withdrawals, vault operations | gRPC + JSON-RPC/WSS | Fund flow analysis, account monitoring | | WRITER_ACTIONS | HyperCore ↔ HyperEVM asset transfers and bridge data | gRPC + JSON-RPC/WSS | Cross-environment asset tracking, DeFi analytics | | BLOCKS | Raw HyperCore blockchain data exposing replica_cmds (all transaction types) | gRPC only | Blockchain analysis, data archiving | | StreamL2Book | Aggregated price levels — total size and order count per price, full snapshot every block | gRPC only | Market depth, spread monitoring, analytics dashboards | | StreamL4Book | Individual order granularity — every resting order with user, oid, size, triggers, timestamps | gRPC only | HFT, quant trading, MEV, microstructure analysis | | MEMPOOL_TXS | Pending mempool transactions before block confirmation | gRPC only (testnet only) | MEV detection, transaction monitoring, pre-confirmation analysis | MEMPOOL_TXS is available on testnet only. #### Supported Chains 80+ chains including: Ethereum, Solana, Base, Arbitrum, Optimism, Polygon, BNB Smart Chain, Bitcoin, Hyperliquid, Monad, Avalanche, TRON, and more. Full list: https://www.quicknode.com/chains #### Agent Discovery ##### llms.txt Quicknode publishes machine-readable documentation indexes across its entire docs surface — products, chains, RPC methods, guides, sample apps, and courses. Fetch the main index to discover all available resources. Any docs or guides page can also be fetched as clean markdown by appending `.md` to the URL. ```shell # Main index (entry point for all resources) curl https://www.quicknode.com/llms.txt # Documentation index (RPC methods and API references) curl https://www.quicknode.com/docs/llms.txt # x402 protocol docs curl https://x402.quicknode.com/llms.txt # Any docs page as markdown (append .md) curl https://www.quicknode.com/docs/ethereum.md ``` Available indexes: | Index | URL | Content | | :---- | :---- | :---- | | Main | https://www.quicknode.com/llms.txt | Full platform — products, chains, guides, solutions | | Docs | https://www.quicknode.com/docs/llms.txt | API reference — per-chain and per-product llms.txt indexes | | Docs (full text) | https://www.quicknode.com/docs/llms-full.txt | Complete docs concatenated into one file (large: ~137k tokens; prefer the scoped indexes for targeted work) | | Guides | https://www.quicknode.com/guides/llms.txt | Tutorials and implementation walkthroughs | | x402 | https://x402.quicknode.com/llms.txt | x402 protocol and payment docs | | MPP | https://mpp.quicknode.com/llms.txt | Machine Payments Protocol docs | | Build with AI | https://www.quicknode.com/docs/build-with-ai/llms.txt | MCP, x402, Skills, and AI-specific tooling | | Hyperliquid | https://www.quicknode.com/docs/hyperliquid/llms.txt | Hyperliquid RPC methods and API docs | | Builder's Guide | https://www.quicknode.com/builders-guide/llms.txt | Tool discovery, comparisons, and use-case blueprints | | Faucet | https://faucet.quicknode.com/llms-full.txt | Multi-chain testnet faucet | ##### agent-card.json (live) A2A agent discovery card declaring Quicknode's agent skills, authentication methods, and endpoints. - URL: https://www.quicknode.com/.well-known/agent-card.json - Also advertised in robots.txt via the `Agent-Card:` pointer. #### Pricing Summary for Agents | Plan | Price | API Credits/mo | Requests/sec | x402 Equivalent | | :---- | :---- | :---- | :---- | :---- | | Free | $0/mo | 10M | 15 | — | | Build | $49/mo | 80M | 50 | ~$0.61/1M credits | | Accelerate | $249/mo | 450M | 125 | ~$0.55/1M credits | | Scale | $499/mo | 950M | 250 | ~$0.53/1M credits | | Business | $999/mo | 2B | 500 | ~$0.50/1M credits | | Enterprise | Custom | Custom | Custom | Custom | | x402 | No plan | Pay-per-request | No limit | $10 USDC = 1M credits | Full pricing: https://www.quicknode.com/pricing.md #### Agent-Related Links - Sign up: https://www.quicknode.com/signup - Documentation: https://www.quicknode.com/docs/build-with-ai - Quicknode SDK (Rust, Python, Ruby, Node.js/TypeScript): https://www.quicknode.com/docs/quicknode-sdk - Quicknode CLI (qn): https://www.quicknode.com/docs/quicknode-cli#install - API Credits reference: https://www.quicknode.com/api-credits - Skills library: https://skills.sh/quiknode-labs/blockchain-skills/quicknode-skill - MCP server: https://www.quicknode.com/docs/build-with-ai/quicknode-mcp - MCP package: https://www.npmjs.com/package/@quicknode/mcp - x402 docs: https://www.quicknode.com/docs/build-with-ai/x402-payments - MPP docs: https://www.quicknode.com/docs/build-with-ai/mpp-payments - Pricing: https://www.quicknode.com/pricing.md - Status: https://status.quicknode.com - Support: https://support.quicknode.com --- ### Create a Quicknode Endpoint — Autonomous 3-Step Walkthrough For AI agents with a funded EVM wallet and no Quicknode account. Provision a production RPC endpoint without human signup. **Source:** https://www.quicknode.com/agents/create-endpoint.md #### The flow 1. **Pay via x402 or MPP** → `POST https://www.quicknode.com/api/v1/agent/subscriptions` → receive `QN_*` API key 2. **Create endpoint** → `POST https://api.quicknode.com/v0/endpoints` (Admin API) → receive RPC URL 3. **Use the RPC** → `POST ` for JSON-RPC calls #### Step 1 — Create subscription + receive API key Pay via x402 or MPP. No email verification link; the account is created synchronously in the same request. ```shell curl -X POST https://www.quicknode.com/api/v1/agent/subscriptions \ -H "PAYMENT-SIGNATURE: " \ -H "Content-Type: application/json" \ -d '{ "plan_name": "b6_build", "interval": "monthly", "email": "agent-abc@example.com", "password": "", "password_confirmation": "", "full_name": "Autonomous Agent", "name": "Agent Account", "billing_address": { "line1": "123 Main St", "city": "New York", "postal_code": "10001", "country": "US" } }' ``` Success response: ```json { "api_key": "QN_abc123...", "plan": "b6_build", "admin_api_docs": "https://www.quicknode.com/docs/admin-api" } ``` > **The `QN_*` key is a full platform API key** — it unlocks your entire Quicknode account, including RPC endpoints, Streams, Webhooks, SQL Explorer, Key-Value Store, and more. Steps 2–3 walk through provisioning an RPC endpoint as one example. ##### Request body fields | Field | Required | Notes | |---|---|---| | `plan_name` | required for charge | One of `b6_build`, `b6_accelerate`, `b6_scale`, `b6_business`. Omit to receive a 402 listing all plans + prices. | | `interval` | optional | `monthly` (default) or `yearly`. | | `email` | required | Used for account lookup / resume on retry. | | `password` + `password_confirmation` | required | The password lets you resume if a retry is needed; without it the on-chain payer address would be the only secret. Requirements: 8–64 chars, at least 1 lowercase, 1 uppercase, 1 number, 1 special character. | | `full_name` | required | Primary user's full name. | | `name` | required | Account display name. | | `billing_address.line1` | required | — | | `billing_address.city` | required | — | | `billing_address.postal_code` | required | — | | `billing_address.country` | required | ISO-3166 alpha-2 (e.g. `US`, `GB`). | ##### Payment headers - **x402 v2:** `PAYMENT-SIGNATURE: `. If the header is missing, the server returns `402 Payment Required` with a body listing plans, accepted networks, `payTo` addresses, and asset contract addresses — everything needed to construct the payment. The response also sets a `PAYMENT-REQUIRED` header (base64 x402 requirement). SDK: `@quicknode/x402` (npm) or `x402` (pip) handles this automatically. - **MPP:** `Authorization: Payment `. The server also sets a `WWW-Authenticate: Payment ...` challenge header. SDK: `mppx` (npm) polyfills `fetch` so 402s auto-sign and retry. ##### Rate limits - `POST /api/v1/agent/subscriptions` — 20/min/IP, 5/hour/email #### Step 2 — Create RPC endpoint via Admin API (example) Use the `QN_*` key returned in Step 1 to create an endpoint on any supported chain. This is one example of what the key unlocks. **Base URL:** `https://api.quicknode.com` **Auth:** `x-api-key: QN_...` (or `Authorization: Bearer QN_...`) > **Tip — discover valid chain/network values:** `GET https://api.quicknode.com/v0/chains` (same `x-api-key` auth) returns every supported chain and its accepted network slugs. Use these values directly in the `chain` and `network` fields below to avoid guessing. The full OpenAPI spec is at https://www.quicknode.com/api-docs/v0/swagger.json. ```shell curl -X POST https://api.quicknode.com/v0/endpoints \ -H "x-api-key: QN_abc123..." \ -H "Content-Type: application/json" \ -d '{"chain": "base", "network": "base-mainnet"}' ``` Success response (HTTP 200): ```json { "data": { "id": "", "label": null, "status": "active", "chain": "base", "network": "base-mainnet", "http_url": "https://.base-mainnet.quiknode.pro//", "wss_url": "wss://.base-mainnet.quiknode.pro//", "security": { "...": "..." }, "rate_limits": { "...": "..." }, "tags": [] }, "error": null } ``` - `id` is a string. - Required response fields: `id`, `chain`, `network`, `http_url`, `security`. - `wss_url` is nullable on chains that don't support WebSocket. Full Admin API spec — chains, networks, security, rate limits, tags, multichain, logs: https://www.quicknode.com/api-docs/v0/swagger.json Admin API docs: https://www.quicknode.com/docs/admin-api #### Step 3 — Use the RPC endpoint Standard JSON-RPC; no additional auth headers (the token is in the URL path). ```shell curl -X POST https://.base-mainnet.quiknode.pro// \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' ``` #### Managing the subscription ##### Top up credits — `POST https://www.quicknode.com/api/v1/agent/top_up` Requires `x-api-key: QN_*` (or `Authorization: Bearer`) AND a fresh payment header. Request: ```shell curl -X POST https://www.quicknode.com/api/v1/agent/top_up \ -H "x-api-key: QN_abc123..." \ -H "PAYMENT-SIGNATURE: " \ -H "Content-Type: application/json" \ -d '{"amount": 10.00}' ``` - `amount` is in **USD dollars** (not cents). Must be > 0 and ≤ 25000. - Idempotent on payment tx hash. - Rate limit: 30/min. Response: ```json { "balance_cents": 1000000, "payment_amount_cents": 10000 } ``` ##### Check balance — `GET https://www.quicknode.com/api/v1/agent/balance` Requires `x-api-key: QN_*`. Rate limit: 60/min. Response: ```json { "balance_cents": 1000000 } ``` ##### Manage endpoints List, update, configure security, delete — all via the Admin API at `https://api.quicknode.com/v0/endpoints/{id}`. See https://www.quicknode.com/api-docs/v0/swagger.json for the full surface. --- ### Agents Page — Marketing Overview and FAQs The marketing-page-level summary of how Quicknode positions itself for autonomous-agent workloads. Includes FAQ answers tailored for common agent questions. **Source:** https://www.quicknode.com/agents #### AI Integration Tools ##### x402 **Headline:** Authenticate and Pay for RPC Access Without API Keys HTTP 402-based authentication for AI agents. Authorize and pay for RPC access using cryptocurrency. Zero setup friction across 130+ networks. ##### Agent Subscription API **Headline:** Create Quicknode Accounts and Endpoints Autonomously Programmatic subscription provisioning for agents that need a full Quicknode account — no human signup. Pay once via x402 or MPP to create a subscription (`POST https://www.quicknode.com/api/v1/agent/subscriptions`) and receive a `QN_*` API key. Then create RPC endpoints via the Admin API (`POST https://api.quicknode.com/v0/endpoints`). Use `GET https://api.quicknode.com/v0/chains` to discover valid chain and network slug values before provisioning. ##### Quicknode MCP **Headline:** Query Chains and Manage Infrastructure Through Conversation Model Context Protocol integration for AI assistants. Query blockchains, analyze contracts, and manage infrastructure through natural language. ##### Quicknode Skills **Headline:** Give Your Agents Deep Protocol Knowledge Instantly Curated instruction sets for blockchain operations. Teach agents how to interact with specific protocols and smart contracts across 80+ ecosystems. ##### Quicknode CLI **Headline:** Manage Your Infrastructure From the Command Line `qn` is a command-line interface for Quicknode with ergonomic commands (`qn endpoint list`, `qn stream create`, `qn webhook activate`) for endpoints, streams, webhooks, the KV store, teams, usage, and billing. Output in table, JSON, YAML, Markdown, or TOON (LLM-optimized, the default when piped to an agent). Follows the Command Line Interface Guidelines: data on stdout, diagnostics on stderr, meaningful exit codes. Install with `brew install quicknode/tap/qn`, or via Scoop, apt, Docker, or `cargo install quicknode-cli`. Docs: https://www.quicknode.com/docs/quicknode-cli#install ##### LLMs.txt **Headline:** Point Any LLM at 80+ Networks With One File Machine-readable documentation indexes across all Quicknode resources. LLMs discover the right content automatically for better, more accurate responses. #### Sample Applications ##### Solana MCP Server Query Solana wallets, token accounts, and transaction history directly from Claude or Cursor. No RPC calls required. ##### EVM MCP Server Give Claude live access to Ethereum and EVM chains. Analyze contracts, check balances, and monitor gas through natural conversation. ##### AI-Powered DeFi Optimizer Connect an AI model to Aerodrome's Swap API to analyze yields, surface strategies, and execute swaps based on live market conditions. #### Agents FAQ **Q: Which Quicknode tool should my agent use — x402, MCP, Skills, LLMs.txt, or the Agent Subscription API?** These tools operate at different layers and are designed to be used together. Use x402 or MPP when your agent needs to read or write on-chain data without an account or API key. Use the Agent Subscription API when your agent needs a full Quicknode account + dedicated RPC endpoint without human signup — pay via x402/MPP, receive a `QN_*` key, then call `POST /api/v0/endpoints` on the Admin API. Use MCP when an assistant needs to manage existing endpoints through natural language. Use Blockchain Skills when an agent is generating code that calls Quicknode APIs. Use LLMs.txt when an LLM needs to find the right Quicknode documentation automatically. **Q: How does an AI agent create a Quicknode account and RPC endpoint without human signup?** Use the Agent Subscription API. Two steps: (1) `POST https://www.quicknode.com/api/v1/agent/subscriptions` with `plan_name` (e.g. `b6_build`), `email`, `password`, `billing_address`, plus a `PAYMENT-SIGNATURE` (x402) or `Authorization: Payment` (MPP) header, paid from a funded EVM wallet; the response returns a `QN_*` API key. (2) `POST https://api.quicknode.com/v0/endpoints` with body `{"chain":"base","network":"base-mainnet"}` and `x-api-key: QN_...` — creates a Base/Ethereum/Solana/etc. RPC endpoint via the Admin API. Full runnable walkthrough: https://www.quicknode.com/agents/create-endpoint.md **Q: How does an AI agent access Quicknode RPC without an account or API key?** x402 is a wallet-authenticated, pay-per-request access layer built on the HTTP 402 standard. Any agent holding a wallet with USDC or USDG can start making RPC calls across 80+ chains immediately — no account registration, no API key. Payments are handled automatically by the @quicknode/x402 client: 1,000,000 credits for $10 USDC on mainnet. **Q: What is the fastest way to start building AI agents on Quicknode?** Three steps: install Blockchain Skills to give your coding agent accurate API knowledge (`npx skills add https://github.com/quiknode-labs/blockchain-skills --skill quicknode-skill`), connect the MCP server so your assistant can manage infrastructure through natural language (`claude mcp add quicknode-mcp -e QUICKNODE_API_KEY= -- npx -y @quicknode/mcp`), then access chains via x402 or a standard endpoint. For working reference implementations, see the Sample App Library. **Q: What can I build with Quicknode's agent tools?** Quicknode's on-chain agent tools support six use cases: Autonomous Trading (real-time market data and execution across DEXs), Smart Contract Analysis (vulnerability and gas analysis at scale), Conversational dApps (natural language blockchain interfaces), On-Chain Analytics (pattern detection and trend analysis via Streams), Wallet Intelligence (asset management and fee optimisation), and Threat Monitoring (AI-powered anomaly detection on contracts and wallets). Each use case maps to a specific combination of Quicknode products. **Q: What are Quicknode Blockchain Skills and how does an AI coding agent install them?** Blockchain Skills is a reference package that gives AI coding agents accurate, current knowledge of Quicknode's full product suite — so agents generate correct API calls on the first attempt rather than hallucinating method names or parameters. Install with one command: `npx skills add https://github.com/quiknode-labs/blockchain-skills --skill quicknode-skill`. The skill loads automatically at session start and works with Claude Code, Cursor, Codex, OpenCode, and Windsurf. **Q: What is the Quicknode MCP server and what can an AI assistant do with it?** The Quicknode MCP server (@quicknode/mcp) connects MCP-compatible AI assistants to your Quicknode account, letting them create and manage endpoints, configure security, set rate limits, and review billing through natural language — no dashboard required. It wraps the Admin API and is compatible with Claude Code, Claude Desktop, Cursor, and OpenAI Codex. It does not provide blockchain data access — for on-chain reads and writes, use x402 or a standard RPC endpoint. **Q: How do I give an AI agent access to Hyperliquid data?** Use HyperCore — Quicknode's data access layer for Hyperliquid L1. It provides four access methods: Info API (/info) for market data and positions, JSON-RPC (/hypercore) for block queries, WebSocket (/hypercore/ws) for real-time subscriptions, and gRPC (port 10000) for lowest-latency streaming. gRPC stream types include TRADES, ORDERS, BOOK_UPDATES, TWAP, EVENTS, BLOCKS, and WRITER_ACTIONS. Requires a Build plan or higher. **Q: Does Quicknode support real-time streaming for AI agents?** Yes — four options depending on chain and latency requirements. Use Streams for deterministic EVM or Solana event pipelines with guaranteed delivery. Use Yellowstone gRPC for sub-second Solana account and transaction monitoring. Use HyperCore gRPC for Hyperliquid order book and trade data. Use Webhooks for simple event-driven HTTP notifications. Streams and Webhooks are not designed for sub-100ms latency use cases. **Q: Does Quicknode provide working code examples for AI agent use cases?** Yes. The Sample App Library includes three AI-focused reference implementations: a Solana MCP Server (query wallets, token accounts, and transaction history from Claude or Cursor), an EVM MCP Server (live Ethereum access for contract analysis and gas monitoring), and an AI-Powered DeFi Optimizer (connects an AI model to Aerodrome's Swap API for yield analysis and execution). All include full documentation and source code. **Q: What is Quicknode's LLMs.txt and how should an AI system consume it?** Quicknode publishes machine-readable llms.txt indexes across its full documentation surface — products, chains, RPC methods, guides, sample apps, and courses — so AI systems reference the correct page rather than hallucinating or citing stale sources. Indexes cover every content area, including https://www.quicknode.com/llms.txt (main platform), https://www.quicknode.com/docs/llms.txt (API reference), and https://x402.quicknode.com/llms.txt (x402 protocol). Any docs or guides page can also be fetched as clean Markdown by appending .md to the URL. --- ## Scoped Indexes — Content Not Inlined in This File The content above covers Quicknode's core products, agent reference, and pricing. For per-chain RPC method references, developer tutorials, comparison content, and protocol-level documentation, fetch the relevant scoped index: - **Documentation (per-chain RPC across 80+ chains):** https://www.quicknode.com/docs/llms.txt - **Documentation full text (single file):** https://www.quicknode.com/docs/llms-full.txt — all docs concatenated (~137k tokens); prefer the scoped indexes above for targeted work - **Developer guides and tutorials:** https://www.quicknode.com/guides/llms.txt - **Builder's Guide (tool comparisons, use-case blueprints):** https://www.quicknode.com/builders-guide/llms.txt - **Blog (announcements, product updates, research):** https://www.quicknode.com/blog/llms.txt - **x402 protocol specification:** https://x402.quicknode.com/llms.txt - **Machine Payments Protocol (MPP):** https://mpp.quicknode.com/llms.txt - **Hyperliquid RPC methods:** https://www.quicknode.com/docs/hyperliquid/llms.txt - **Build with AI (MCP, x402, Skills tooling):** https://www.quicknode.com/docs/build-with-ai/llms.txt - **Faucet (multi-chain testnet):** https://faucet.quicknode.com/llms-full.txt - **Main platform index:** https://www.quicknode.com/llms.txt