Hyperliquid has spent two years building toward a single thesis: 

Every financial market: crypto, equities, commodities, events should run on the same execution engine, with shared liquidity and composable margin. 

Each proposal and action in terms of HIPs (Hyperliquid Improvement Proposals) is continually expanding the surface area of what's tradable on HyperCore.

• First, HIP-1 gave the chain native tokens.
• Then, HIP-2 bootstrapped liquidity. 
• Last year (2025), HIP-3 opened perpetual futures to permissionless deployment. 

Just days ago, HIP-4 went live on Hyperliquid testnet, and it expands Hyperliquid into a new design space and market mechanics with outcome contracts.

What is it? Is it simply “prediction markets on Hyperliquid”? How does it work?

Let’s answer each question with a breakdown of the primitives HIP-4 introduces and how they fit within the overall Hyperliquid infrastructure.

HIP-4 as a Primitive: What are Outcome Contracts?

Outcome contracts are binary financial instruments on Hyperliquid tied to whether a specific event occurs. They trade between 0 and 1, where the price represents the market’s implied probability of that event occurring. 

• If the event happens, the contract settles at 1. 
• If it doesn't, it settles at 0.

Because the settlement values are fixed, the payoff structure is straightforward.

The Layman’s Math of Outcome Contracts 

Assume a trader buys a YES contract at price P, the payoff at settlement is:

• Profit if event occurs: 1−P
• Loss if event does not occur: P

Example:

If a contract trades at 0.60, the market is implying a 60% probability that the event will occur. And here’s the scenario if a trader buys YES at 0.60:

Math, money, and payoffs aside, understanding how outcome contracts behave and what becomes possible because of it requires a little more depth.

Outcome Contracts Inside HyperCore

Outcome contracts run directly inside HyperCore, the core execution layer responsible for spot and perpetual markets on Hyperliquid. Meaning, they use the same onchain orderbook infrastructure, matching engine, and trading environment that existing markets use.

• Order book: Every outcome market gets its own central limit order book (CLOB), operating the same as spot and perp markets operate on HyperCore.
• Account system: Outcome contract positions live inside the same Hyperliquid trading account that a trader uses for Hyperliquid DEX.

Outcome contracts being native to HyperCore also makes life easier for builders and developers looking to innovate within the Hyperliquid ecosystem.

Because outcome contracts inherit the same infrastructure as any other HyperCore market in terms of: 

• transaction throughput, 
• latency profile, 
• validator set handling finality, and more.

This way, builders querying outcome market state, order book depth, or settlement events can use the same infrastructure they'd use for Hyperliquid DEX.

The next step is understanding how these markets actually operate once they are deployed.

How Outcome Markets Work on Hyperliquid

Once deployed inside HyperCore, outcome contracts follow a simple lifecycle: creation > auction > continuous trading > settlement. 

While the process seems self-explanatory, there’s a nuance to each step that helps Hyperliquid maximize this market offering:

Stake Requirement

The builder (deployer) must stake 1M $HYPE tokens to deploy their outcome market. 

The stake is slashable if a builder attempts to manipulate the oracle or to trigger invalid state transitions. Any partial or fully slashed $HYPE will be burned.

Event Schema

During deployment, the builder defines the event schema:

• Event title
• Resolution time
• Resolution source
• Authorized oracle updater

Optional addition: Challenge window for optimistic early resolution + disputes

Also, deployers can set an additional fee share of up to 50% on top of Hyperliquid's base fees.

Deployment & Slotting

Markets are deployed into slots within a builder’s event DEX.

Once resolved, the slot can be recycled with a new event, meaning a single 1M $HYPE commitment can support a rolling series of markets. 

Opening Auction

After deployment, a ~15-minute single-price clearing auction runs, during which users submit orders (“buy YES up to price P”).

Remember, nothing executes in this phase.

When it closes, the engine picks the clearing price that maximizes matched volume, and every matched order fills at that single price. 

Unfilled orders carry into continuous trading at their original limits.

The actual math behind determining the opening price. Source

Orderbook Trading

After the auction, the market transitions to continuous orderbook trading.

Orders follow price-time priority. Traders can submit limit and market orders just like in other Hyperliquid markets.

The contract price reflects the market’s implied probability of the event occurring and remains bounded between 0.001 and 0.999 until the event resolves.

Settlement

When the event resolves, the authorized oracle posts the final outcome:

• 1 if the event occurs
• 0 if it does not

Trading halts, open orders are canceled, and all positions settle automatically to their final PnL in USDH.

Markets may optionally include a challenge window, allowing oracle outputs to be disputed before settlement becomes final.

Now, we know how the outcome markets work, the math, and the process. Let’s pivot to understanding why this matters for Hyperliquid as an ecosystem and for all participants within it.

The Composability Thesis: Hyperliquid as a Global Financial Execution Layer

Hyperliquid’s roadmap has been consistent from the start: expand the surface area for trading within a single execution engine.

The idea is simple. 

It's building a single execution layer where every market type — spot, perpetuals, and now outcome contracts — runs on the same infrastructure, settles through the same engine, and sits inside the same trading account. More importantly, every new market type deepens the same liquidity pool rather than fragmenting it.

That last part is what composability actually means here. 

Consider a concrete example: a trader holds a long ETH perpetual. They believe ETH rallies if the Fed cuts rates, but want protection if it doesn't. 

Anywhere else, the trader would need to take two separate positions on two separate platforms, each with its own collateral pool.

On Hyperliquid, the perp and the outcome contract sit in the same account. 

Alternatively, this composability carries advantages for builders and developers alike:

1. A market maker active in spot can extend their infrastructure to outcome markets without a new integration.
2. Builders looking at Hyperliquid get unlimited design space which used to require multiple institution-grade infrastructure before and a lot of coordination in between to make it work.

Well, this isn’t a new experiment that Hyperliquid did. They have been at the same goal all along.

Hyperliquid has been very explicit regarding their long-term vision.

The Blockchain To House All Finance: A single blockchain capable of hosting every financial market on one execution layer.

Now, composability is only as useful as the builders innovating on it. Let’s think more practically about builders and operators on Hyperliquid.

What HIP-4 Changes for Builders, Liquidity Providers, and Market Creators on Hyperliquid

HIP-4 doesn't affect everyone on Hyperliquid equally. Let's zoom out and think of implications for the major 2-3 roles onchain.

Builders

For builders, HIP-4 turns event markets into deployable infrastructure rather than standalone applications. This opens room for new types of products:

• Cross-market arbitrage bots
• Event trading interfaces
• Layered structured products
• Market analytics and probability data products
• Prediction market frontends

Since the infrastructure is purpose-built and reliable, builders can build a wide range of interfaces and market-discovery layers on top of outcome contracts.

Liquidity Providers

For liquidity providers and market makers, outcome markets currently offer limited functionalities. Bounded payoff is a turnoff for any LP looking to maximize gains.

Also, outcome markets as probability instruments are more passive compared to perp markets for LPs where exposure is continuous and funding rates drive position decisions, increasing the profit ceiling.

Maybe, over time, this could lead to an entirely new liquidity category on Hyperliquid: event-probability market-making.

LPs and market makers don’t gain a direct win-win from HIP-4.

Market Creators

The 1M $HYPE stake is the barrier. At current prices, that's a significant capital commitment, but slot recycling changes the unit economics meaningfully. 

A single stake supporting a rolling series of markets amortizes that cost over time. 

This enables deployers to operate rolling event markets around recurring events such as:

• macroeconomic releases
• earnings announcements
• elections or governance votes
• major product launches

So, market creators have to think about slot utilization, sequencing market rollouts, and market timing far more than whether to stake a million $HYPE.

What next? Builders need good tooling and data access to genuinely leverage the new design space of outcome markets.

Why Infrastructure Matters for Outcome Markets

Outcome markets are event-driven. 

A simple statement but this architectural distinction has direct implications that don't exist in continuous markets like spot or perpetuals.

> In a perpetual market, a missed update means a slightly stale price. 

> In an outcome market, a missed event means a broken interface, a failed hedge, or a position that didn't settle correctly. 

The cost of infrastructure failure is asymmetric.

For builders and traders interacting with these markets, that behavior raises the importance of reliable infrastructure. Applications need consistent access to:

• real-time orderbook data
• market state and event metadata
• account balances and position updates
• transaction submission for orders and cancellations

Because outcome markets trade on HyperCore’s orderbook, these interactions happen through RPC endpoints and APIs that expose market data and execution interfaces.

In practice, builders developing event trading interfaces, analytics dashboards, or automated strategies need infrastructure that can reliably handle spikes in activity when new information hits the market.

This is where infrastructure providers such as Quicknode become useful. 

Building on Hyperliquid with Quicknode

By offering managed Hyperliquid RPC endpoints, data access, and developer tooling, Quicknode allows teams to focus strictly on building products and solutions.

Quicknode's HyperCore integration, which is currently in public beta, promises to carry infra superpowers like:

• Streams support for Hypercore datasets, enabling filtered, push-based delivery of Hyperliquid data
• gRPC APIs designed for high-volume, low-latency data pipelines
• JSON-RPC and WebSocket-related methods for compatibility with existing workflows

More Quicknode resources for Hyperliquid builders:

1. Hyperliquid API Overview | Quicknode Docs
2. Build a Real-Time Hyperliquid Whale Alert Bot
3. Read HyperCore Oracle Prices in HyperEVM
4. Real-time risk monitoring and liquidation analytics API for HyperLend Protocol on Hyperliquid
5. Comparison of the top 6 Hyperliquid RPC providers for HyperCore and HyperEVM

SDKs & Tools

• Hyperliquid Python SDK — also on PyPI
• Hyperliquid API Examples — clone-and-run examples in Python, TypeScript, Rust & Go
• Hyperliquid SDK Examples — advanced SDK usage patterns
• HyperCore CLI — stream & backfill HyperCore data from the terminal
• hyperliquidapi.com — zero-custody Hyperliquid trading API

Stay tuned for more insights—subscribe to our blog for the latest in blockchain infrastructure.

For teams building on top of HIP-4, the infrastructure layer is the difference between a product that works when it matters and one that doesn't.

What’s Next for Hyperliquid?

The tradable surface area on HyperCore just expanded with HIP-4 going live on testnet. With outcome contracts, Hyperliquid is now pricing events.

That shift expands the design space for builders and market participants.

Developers can deploy recurring event markets, liquidity providers can quote probability instruments alongside traditional markets, and traders can express views not just on prices but on outcomes.

What next is deployment of markets, maturity of tools and developer resources, and of course Hyperliquid's evergreen pursuit of widening the range of markets that can live inside the same trading infrastructure.

Frequently Asked Questions (FAQs)

1. Is HIP-4 just prediction markets on Hyperliquid?

Not exactly. Prediction markets are one application of outcome contracts.

Outcome contracts are the underlying financial primitive i.e. binary instruments that settle to 0 or 1 based on an event outcome. Prediction markets simply use that primitive to price the probability of future events. 

On Hyperliquid, outcome contracts can support many kinds of event-based markets beyond traditional prediction use cases.

2. Is HIP-4 live?

As of March 2026, HIP-4 outcome trading is live on Hyperliquid testnet. Mainnet launch will follow a two-phase approach: curated canonical markets first, permissionless builder deployment second. No mainnet date has been confirmed.

3. What is the best Hyperliquid RPC provider for 2026?

Quicknode offers the most comprehensive solution with full HyperCore and HyperEVM support, gRPC streaming, and the broadest protocol coverage. The best provider ultimately depends on your specific needs—high-frequency trading, cost optimization, or multi-chain infrastructure.

4. Can I switch between Hyperliquid RPC providers easily?

Yes, switching providers is straightforward since most use standard JSON-RPC and WebSocket interfaces. You typically only need to update your endpoint URL.

However, if you've built features around provider-specific tools like Quicknode's analytics dashboard or custom APIs, you may need to adjust those integrations. The core blockchain interactions remain compatible across providers.

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

AI agents aren’t headline-worthy anymore just because they can act. That part is becoming expected. 

Today, an AI agent can call APIs, communicate with other agents, access tools, make payments, and coordinate workflows. 

In many ways, they already behave like digital workers. 

But there's no standard way to identify them, verify who they are, or define what they're authorized to do.

ERC-8004 is Ethereum's answer to that and this piece breaks down what it is, how it works, and whether it's ready to be taken seriously.

Identity Crisis of the Agent Economy

Today, when an AI agent makes payments or interacts with an API, there's no verifiable and standard way to answer:

1. Who is this agent and who deployed this agent?
2. Does it have a transaction history or reputation?
3. What permissions or roles does it have?

On the other end, humans, over decades, have designed portable identities to carry trust, reputation, and accountability with them. 

Legal identities, licenses, credit history, financial statements, and more. 

Today, since AI agents are handling real money, real data, and real decisions on behalf of real users, they need a reliable way to answer these questions at scale.

The AI Agents Stack Grew Fast and Incomplete

In less than 5 years, the infrastructure around AI agents has expanded and matured drastically. In this time, 3 key execution tracks came to life:

1. MCP standardized how agents access tools, making it possible for agents to query infrastructure, trigger workflows, and interact with external services.
2. A2A gave a structured messaging framework allowing agents to communicate with each other.
3. x402 gave them native payment rails, meaning agents can transact in stablecoins at the HTTP layer without needing humans.

Each protocol solved its specific problem well and today, execution is no longer a major headache for AI agents.

But, each of them runs into an identity or reputation wall very quickly. 

Simply put, these protocols do not have the capability to answer who the agent is. That's the gap ERC-8004 is built to close.

What ERC-8004 Actually Is

ERC-8004 is an identity and reputation coordination standard designed for AI agents on Ethereum.

The proposal for this standard was authored by Marco De Rossi (MetaMask), Davide Crapis (Ethereum Foundation), Jordan Ellis (Google), and Erik Reppel (Coinbase).

The ERC-8004 standard introduces 3 onchain registries:

1. Identity Registry

Each agent is represented by a unique onchain identifier which is further minted as an ERC-721 token. That NFT points to a structured JSON file, called an agent card, containing the agent's name, functionalities, service endpoints (MCP, A2A, web), and payment address.

The onchain component anchors identity. The offchain metadata provides context.

2. Reputation Registry

The reputation layer allows interactions and feedback to be recorded against an agent’s identity. It lets authorised agents and users post feedback in bounded numerical scores and categorical tags like response time or uptime. 

This way, an agent's performance is made portable and queryable for other agents to learn from before interacting with them.

3. Validation Registry

This registry is a standardized mechanism for recording verifiable evidence that an agent:

• Completed a task
• Produced a correct or acceptable output
• Met predefined constraints or guarantees

Remember: this registry only defines how validation results are recorded, not which validation method to be used. Therefore, the registry is designed to support multiple validation strategies from social consensus to crypto-economic slashing.

It is, however, important to note that this registry isn't finished yet. Until it is shipped as infrastructure, the validation registry is a design space.

Together, these three registries create a neutral coordination layer: a way to discover agents > inspect their track record > and verify claims.

From here, the natural question follows: why not use existing identity systems instead?

How ERC-8004 Differs from OAuth, DIDs, and ENS

If identity is the problem, why not use what already exists?

Developers today are familiar with OAuth, API keys, decentralized identifiers (DIDs), wallet addresses, and naming systems like ENS. Each provides a form of identification or authentication.

Why build something new?

Simple answer: Because ERC-8004 isn't solving the same problem.

Here's a quick table to understand the purpose of these systems and why ERC-8004 is necessary.

Zooming out, each of these systems was designed with a specific trust surface in mind. And none of them were designed for AI agents except ERC-8004.

In theory, an agent registered under ERC-8004 can have an,

• ENS name as its human-readable identifier,
• DID for user-facing interactions, and
• ERC-8004 specifically for agent-to-agent discovery and trust.

This way, ERC-8004 treats the other methods as composable primitives within its identity layer.

Now, how does the ERC-8004 discovery actually work in the real world?

How ERC-8004 Actually Works End-To-End (Without Code)

Step 1: Register

A developer deploys an agent and registers it in the Identity Registry.

The agent receives an onchain identity with associated metadata describing its capabilities, exposed endpoints, and payment details.

Step 2: Discover

Another agent or developer can now query the registry directly or via third-party indexers to discover agents using indexed metadata, capabilities, or available reputation signals.

Step 3: Evaluate

Before interacting, the querying agent inspects the candidate’s Reputation Registry history, including prior outcomes, attestations, and linked evidence.

It decides whether the agent’s track record meets its risk threshold.

Step 4: Interact

If acceptable, the agent connects using the advertised interface (MCP, A2A, or HTTP) and executes the task.

Step 5: Pay and Record

Payment is issued via x402 or another compatible mechanism. Outcome data and feedback may be written back to the Reputation Registry, updating the agent’s onchain track record for future discovery.

This is the coordination layer ERC-8004 introduces. Now, how does the full AI Agents tech stack actually look like for builders when it's assembled?

The Emerging Agent Stack

Today, the AI agent tech stack is a set of mature primitives working in combination. Here's a quick snapshot of what a builder has at their disposal:

Each layer makes the others more useful for AI agents.

• An agent can discover another agent via ERC-8004.
• It can pay that agent via x402.
• It can invoke services through MCP-compatible endpoints.

The value compounds when the layers interlock.

For builders, this stack has a practical implication: the infrastructure already exists to build agents that can be discovered by never-met-before agents, across organizational boundaries, compensated automatically, with a verifiable track record attached to every interaction.

Where Quicknode Sits in the Agent Stack

Quicknode already powers key layers of this stack.

• Agents querying ERC-8004 registry contracts need reliable RPC access and that's Quicknode's core infrastructure. 
• On the execution side, the Quicknode MCP Server connects AI assistants directly to blockchain data: RPC endpoints, indexing, and streaming, without custom integration work. 
• And Quicknode's x402 integration means agents can pay for RPC compute the same way they pay any other agent in the stack.

In effect, Quicknode supports identity lookups, execution access, and native agent payments and all with the enterprise-grade infrastructure and support that developers and teams need.

With all these information and tools handy, have we zeroed in on a complete infrastructure for the agent economy?

Does ERC-8004 Complete the AI Agent Infrastructure?

Not entirely. Not yet.

See, the agent economy will need a robust trust layer. The only open question, right now, is who defines it. There are two directions: 

• Build it now as an open standard, or 
• Wait until big tech with centralized directories to decide access and incentives for all.

ERC-8004 is the first serious attempt at the former: a permissionless, audited, institutionally-backed standard that no single entity controls.

It establishes the coordination surface where trust can emerge and thereby lays the groundwork for an open agent economy.

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

If you are building on Bitcoin or Bitcoin Cash with Quicknode, you already have reliable RPC access to the network.

For many use cases, that is enough.

But if your application depends on address history, balance tracking, or deposit monitoring, you may be stretching raw RPC beyond what it was designed to do efficiently.

This is where Blockbook comes in.

The Gap Between Raw Blockchain Data and Application Needs

Bitcoin and Bitcoin Cash are UTXO-based blockchains. Standard RPC endpoints expose raw blockchain primitives:

• Blocks
• Transactions
• UTXO state
• Validation logic

They are optimized for node-level access.

Applications, however, operate at the address level.

Most real-world products need:

• Full transaction history for a specific address
• Current balances across many addresses
• Fast confirmation checks for deposits
• Reliable UTXO lookups
• Continuous monitoring at scale

You can build this on top of RPC.

Many teams do.

But over time, that typically turns into:

• Repeated getrawtransaction and gettxout calls
• Frequent block scanning
• Custom indexing logic
• Internal UTXO tracking layers
• Additional databases to reconstruct address state

It works.

But it increases engineering complexity, infrastructure costs, and operational overhead.

What Blockbook Solves

Blockbook is an indexed backend purpose-built for UTXO chains.

Instead of reconstructing address state through repeated RPC calls, Blockbook provides:

• Indexed transaction history by address
• Fast balance queries
• Efficient UTXO retrieval
• Optimized support for wallet and deposit workloads

In practical terms, it shifts your architecture from:

Application → RPC endpoint → Custom indexer → Database

to:

Application → Indexed backend

Fewer moving parts. Less custom infrastructure. Cleaner deposit monitoring.

Who Benefits Most from Blockbook

Blockbook is especially valuable for teams building:

• Wallets
• Exchanges with deposit tracking
• Block explorers
• Merchant payment systems
• Accounting or reconciliation platforms

If your product monitors many addresses, tracks incoming funds, or depends on accurate address history, an indexed backend becomes essential as you scale.

BTC Blockbook and BCH Blockbook on QuickNode

Quicknode offers:

• BTC Blockbook
• BCH Blockbook

as 1-click add-ons to your existing endpoints.

You keep your current RPC access and add indexed capabilities where your workload requires it.

When to Consider Adding Blockbook

You may want to evaluate Blockbook if:

• Transaction lookups dominate your BTC or BCH usage
• You run frequent reconciliation jobs
• You maintain internal UTXO tracking logic
• Your application performance depends on address queries
• Your API credit usage is driven by repeated transaction checks

These patterns signal an index-driven workload, not a block-driven one.

Blockbook was built specifically for that.

A Simpler Backend for UTXO Applications

Bitcoin’s protocol is simple.

Application-layer infrastructure on top of it is not.

If your product depends on address-level visibility and UTXO tracking, adding Blockbook can reduce complexity, lower overhead, and improve performance.

Not sure if it’s the right fit?

Our team is happy to review your workload and help you decide.

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

Quicknode now supports x402 pay-per-request access, giving developers and AI agents instant, wallet-authenticated access to blockchain endpoints across 130+ networks. This includes RPC, WebSocket, REST, and gRPC interfaces. Pay with USDC on Base, Solana, or Polygon and start making calls in minutes.

x402 is an additive access method that complements Quicknode's existing plans. Teams running production workloads benefit from Quicknode's standard plans with SLAs, dedicated support, and credit-based billing. x402 adds a new option for use cases where lightweight, permissionless access is the priority.

This post covers what x402 is, how it works with Quicknode, what you can build with it, and how to get started.

What is x402?

x402 is an open payment protocol developed by Coinbase that brings native payments to HTTP. It revives the long-reserved HTTP 402 "Payment Required" status code and turns it into a working payment layer for the internet.

The concept is straightforward: when a client makes a request to an x402-enabled endpoint without payment, the server responds with a 402 status and includes payment instructions (price, accepted tokens, network, and wallet address). The client signs a USDC payment authorization, attaches it to the request header, and retries. The server verifies the payment through a facilitator, settles it onchain, and returns the requested data.

This is especially significant for AI agents. Traditional payment systems require human-driven signups, credential management, and billing cycles. x402 removes all of that. An agent with a wallet can autonomously discover, pay for, and consume API services without any human intervention.

Why Quicknode Supports x402

Quicknode provides blockchain infrastructure to developers and enterprises across 80+ chains and 130+ networks. Accessing that infrastructure typically involves creating an account and managing API keys, which works well for teams building production applications.

x402 adds a complementary access path for a growing category of users: AI agents, quick prototypers, and developers who want to test something before committing to a plan. With x402 enabled on Quicknode endpoints, anyone (or anything) with a wallet can:

• Access RPC, WebSocket, REST, and gRPC endpoints across 130+ blockchain networks
• Pay-per-request with USDC using a drawdown credit model. Fund your balance once, and each request automatically draws down from your credits, so there's no per-call payment latency.
• Authenticate using wallet-based auth (Sign-In with X / SIWx), supporting both EVM and Solana wallets
• Get started with up to 10,000 free requests using devnet USDC

The payment network is decoupled from the endpoints you query. That means you can pay with USDC on Base and make Solana calls, or pay with Solana USDC and query Ethereum, or pay with Polygon USDC. The chain you pay on does not need to match the chain you are querying.

x402 vs Standard Quicknode Plans

x402 is additive. It does not replace Quicknode's standard plans. Teams with production workloads should continue using standard SLA plans, dedicated support, and higher rate limits.

Supported Payment Networks

Quicknode's x402 implementation currently supports USDC payments on:

• Base (mainnet and Sepolia testnet)
• Solana (mainnet and devnet)
• Polygon (mainnet and Amoy testnet)

Additional payment networks are actively being added. The x402 protocol is chain-agnostic by design, so expanding support is straightforward as new facilitators come online.

For testing, developers can use devnet USDC on Base Sepolia, Solana devnet, or Polygon Amoy to get up to 10,000 free requests against any of Quicknode's production endpoints.

How It Works: The Technical Flow

Here is what happens under the hood when an agent or developer makes an x402-enabled request to Quicknode:

1. Initial request: The client sends an HTTP request to the Quicknode x402 endpoint without payment headers.
2. 402 response: The server responds with HTTP 402 and a PAYMENT-REQUIRED header containing payment details: the price per request, accepted tokens (USDC), supported networks (Base, Solana, Polygon), and the wallet address to pay.
3. Wallet authentication: The client authenticates using SIWx (Sign-In with X). Quicknode's implementation uses SIWx to issue JWT tokens, optimizing performance by avoiding per-request signature verification overhead (which would add 10-20ms per call).
4. Payment authorization: The client signs a USDC transfer authorization using EIP-3009 (for EVM) or a Solana signing method equivalent. This is a gasless operation for the client.
5. Retry with payment: The client retries the original request with the signed payment in the X-PAYMENT header.
6. Verification and settlement: The facilitator verifies the signed authorization, settles the USDC transfer onchain, and confirms the payment.
7. Response: Quicknode returns the requested data.

The x402 client libraries handle steps 2 through 6 automatically. From a developer's perspective, the code appears to be a standard HTTP request.

What You Can Build

AI Agents with Autonomous Blockchain Access

The most immediate use case is enabling AI agents to interact with blockchain data without pre-provisioned API keys. An agent can:

• Query token prices and portfolio balances across chains
• Monitor wallet activity and transaction history
• Execute blockchain reads for DeFi protocols
• Access historical block data for analysis

All without a human having to set up an account first.

MCP Server for AI-Assisted Infrastructure Management

Quicknode's official MCP server (@quicknode/mcp) brings blockchain infrastructure management directly into AI assistants like Claude and Cursor. With the MCP server, an AI assistant can set up and configure Quicknode endpoints across multiple networks, monitor usage and billing, and manage infrastructure through natural language. This pairs well with x402: use the MCP server to provision and manage your Quicknode infrastructure, and use x402 for lightweight, wallet-authenticated endpoint access.

Install via npx:

npx -y @quicknode/mcp

See the package on npm: npmjs.com/package/@quicknode/mcp

Blockchain Skills for AI Coding Agents

Quicknode also offers Blockchain Skills, a lightweight reference package that gives AI coding agents accurate, up-to-date knowledge of the full Quicknode product suite. One command adds it to Claude Code, Cursor, Codex, Windsurf, or any skills-compatible agent:

npx skills add quiknode-labs/blockchain-skills

At around 240 tokens, it gives your agent the right endpoints, correct parameters, and current best practices without bloating the context window. Fully open source at github.com/quiknode-labs/blockchain-skills. Browse it on the Skills registry at skills.sh/quiknode-labs/blockchain-skills.

Pay-Per-Request Development and Prototyping

Developers who want to test an idea across multiple chains can use x402 to access any of Quicknode's supported networks without committing to a plan. Spin up a prototype, pay a few cents in USDC for the RPC calls you actually make, and move on.

HyperCore CLI with x402

Quicknode's open-source HyperCore CLI tool also supports x402 pay-per-request access. Developers can stream and backfill Hyperliquid datasets (trades, orders, fills, TWAP, book updates, events, blocks) directly from the terminal, paying per request with a wallet instead of needing a Quicknode account.

Install it globally:

npm install -g @quicknode/hypercore-cli

The CLI supports real-time streaming over WebSocket and gRPC, auto-reconnect with gap recovery, historical backfill, and output to JSON, CSV, or SQLite.

Content and API Monetization

Beyond consuming x402-enabled services, developers can also build their own x402-powered APIs using Quicknode's open-source tooling:

• x402-rails: A Ruby gem for adding x402 paywalls to Rails applications
• x402-payments: A Ruby gem for generating signed payment headers
• qn-x402-examples: Example implementations for both EVM and Solana payment flows

The @quicknode/x402 npm Package

The @quicknode/x402 npm package is the recommended way to interact with Quicknode's x402 gateway. It wraps the full authentication and payment flow into a single install: SIWX wallet auth, JWT session management, and x402 payment handling.

Previously, integrating with x402 on Quicknode required manually handling the SIWX signing, JWT token lifecycle, and payment header construction. This package abstracts all of that. Agents and developers can install the package, connect a wallet, and start making authenticated, paid requests in minutes.

npm i @quicknode/x402

The package supports both EVM and Solana wallets and works across all supported payment networks (Base, Solana, Polygon).

See it on npm: npmjs.com/package/@quicknode/x402

Source: github.com/quiknode-labs/quicknode-x402

Getting Started

Prerequisites

• A crypto wallet (any EVM-compatible wallet or Solana wallet)
• USDC on Base, Polygon or Solana (or devnet USDC for free testing)
• Node.js 18+ and the @quicknode/x402 package (npm i @quicknode/x402)

Quick Start with Devnet USDC (Free)

For testing, you can use devnet USDC to make up to 10,000 free requests:

1. Get Base Sepolia USDC from the Circle USDC faucet
2. Or get Solana devnet USDC from the Solana faucet
3. Or get Polygon Amoy USDC from the Circle USDC faucet
4. Follow the Getting Started guide

Production Setup

For production usage with real USDC:

1. Fund your wallet with USDC on Base, Solana, or Polygon
2. Install the @quicknode/x402 package (npm i @quicknode/x402)
3. Point your requests at the Quicknode x402 endpoint

The per-request payment is minimal, making this viable for high-volume agent workloads and development testing alike.

Open Source and Ecosystem

Quicknode has invested heavily in the x402 ecosystem beyond just enabling payments on its own endpoints:

• x402 Explorer: A sample app for testing x402 payment flows
• x402 Video Paywall Demo: A sample showing how to paywall video content with x402
• x402 Rails Integration: A guide for adding x402 to Ruby on Rails APIs
• x402 Paywall Guide: A comprehensive walkthrough of implementing x402
• llms.txt: Machine-readable documentation for LLM and agent discoverability. The protocol itself is open source and maintained by Coinbase at github.com/coinbase/x402.
• @quicknode/x402 package: npmjs.com/package/@quicknode/x402

Frequently Asked Questions

What is x402 on Quicknode? x402 on Quicknode is an alpha capability that enables wallet-authenticated, pay-per-request access to Quicknode endpoints (RPC, WebSocket, REST, and gRPC) using USDC. It uses the HTTP 402 Payment Required standard and is built on Coinbase's open x402 protocol.

Does x402 replace Quicknode accounts or plans? No. x402 is additive. It provides a complementary access path alongside Quicknode's standard plans. Teams running production workloads should continue using standard plans for SLAs, dedicated support, and higher rate limits. x402 is designed for AI agents, rapid prototyping, and permissionless access.

Does x402 require a Quicknode account? No. x402 access is wallet-authenticated. You need a crypto wallet and USDC, not a Quicknode account or API key.

What payment networks are supported? USDC payments are currently supported on Base (mainnet and Sepolia testnet), Solana (mainnet and devnet), and Polygon (mainnet and Amoy testnet). Additional payment networks are being added. The payment network does not need to match the chain you are querying.

Can AI agents use x402 autonomously? Yes. x402 is designed for autonomous agent access. An agent with a funded wallet can discover, authenticate, pay for, and consume Quicknode endpoints without any human intervention.

Is x402 production-ready? x402 on Quicknode is currently in alpha. It is functional and available for use, but does not carry the same SLA guarantees as standard Quicknode plans. For production workloads requiring uptime guarantees and dedicated support, use a standard Quicknode plan.

How much does each request cost? Pay-per-request pricing is minimal and denominated in USDC. Developers can test for free using devnet USDC, which provides up to 10,000 free requests against production RPC endpoints.

What wallets are supported for authentication? Any EVM-compatible wallet or Solana wallet. Authentication uses SIWx (Sign-In with X), which supports both EVM and Solana wallet signing.

Technical Summary

Resources

• Guide: Access Quicknode Endpoints with x402 Payments
• Examples: github.com/quiknode-labs/qn-guide-examples
• Video walkthrough: How to Get Started with x402 on Quicknode
• x402 Protocol Explainer: What is the x402 Payment Protocol?
• Sample Apps: Quicknode Sample App Library
• HyperCore CLI: npmjs.com/package/@quicknode/hypercore-cli
• llms.txt: x402.quicknode.com/llms.txt
• x402 Ecosystem: x402.org/ecosystem
• MCP Server: npmjs.com/package/@quicknode/mcp
• Blockchain Skills: github.com/quiknode-labs/blockchain-skills
• @quicknode/x402 package: npmjs.com/package/@quicknode/x402

Quicknode provides blockchain infrastructure to developers and enterprises across 80+ chains and 130+ networks. Get started with a standard plan or access endpoints instantly with x402 pay-per-request access.

Mainnet is not the end of the job. It is where the pressure starts.

Developers show up. Traffic arrives. Suddenly usage is public. Things that felt fine in testnet are suddenly visible to everyone.

Uptime still matters, but it is no longer judged alone. Explorers, data access, tooling and response times all get evaluated at the same time.

This is the moment where assumptions get tested. And it's where many launches start to wobble.

Where launches actually fail

Most teams plan to “add the rest later”.

Infrastructure comes from one place. Explorers from another. Data, tooling and protection from somewhere else. Each piece works on its own. The system does not.

When something breaks under launch pressure, ownership gets blurry.
Dashboards go stale. Builders hit limits without warning. Telegram fills up with questions no one can answer quickly.

First impressions form fast. They are hard to reverse.

What credible launches do differently

Teams that launch cleanly treat mainnet as a system moment, not a checklist.

Infrastructure and ecosystem surfaces go live together. Responsibility is clear from day one. There is one operator accountable for how the chain behaves under real use.

That clarity matters. Teams spend time helping builders instead of coordinating vendors. This is where credibility is earned or lost.

Introducing ChainKit

ChainKit is Quicknode’s launch ready ecosystem for chains.

It brings production infrastructure and the core ecosystem surfaces a chain needs into one managed system, operated by Quicknode.

One integration. One accountable partner.

Instead of stitching together services and hoping they hold under load, teams launch with a system designed to operate under real use.

What ChainKit covers

ChainKit is designed around the surfaces a chain needs to operate and grow in public, not a checklist of tools.

Infrastructure that holds under real traffic.
RPC, validators, scaling, and security designed for sustained and burst demand, including traffic spikes up to 50k RPS.

Public surfaces that make a chain real.
Custom branded explorers and visibility that show activity clearly from day one.

Data and tooling developers expect immediately.
Indexing, APIs, and abstractions that let teams build without waiting.

Protection for users and the network.
Monitoring and safeguards that reduce damage when things go wrong.

All of this is operated as one system, with clear ownership.

What this changes for teams

Launch with ecosystem readiness.
Core surfaces like infrastructure, visibility and data are live together, not added weeks later.

Clear ownership across critical layers.
Responsibility is unambiguous and response is faster.

Reliability beyond RPC.
Performance and uptime extend across explorers, data, and tooling, not just endpoints.

Public credibility from day one.
Developers experience a chain that works as a whole, not a collection of parts.

Scale without rearchitecture.
Teams grow usage without switching vendors or rebuilding integrations.

If this feels obvious, it usually means you have lived through a launch already.

Proven under real launch pressure

• 30+ live chain partnerships
• Weeks, not months to launch readiness
• Up to 50k RPS under sustained traffic
• 99.99 percent uptime on Quicknode infrastructure

A pattern we see repeatedly

Different chains face different pressures. Some launch under compressed timelines. Others face sustained developer demand. In every case, the same lesson shows up. Coordination and ownership matter more than individual tools.

Explore Quicknode chain case studies

Get Started with ChainKit

Go from planning to production in weeks, not months. Quicknode manages the stack while you focus on growth. Reach out to explore how ChainKit fits your chain. Contact a Chain Specialist

Learn more about ChainKit at quicknode.com/chainkit

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

We are proud to announce support for MegaETH, an Ethereum Layer 2 network that delivers real-time blockchain performance. This launch represents a major leap forward for developers building latency-sensitive applications, from high-frequency DeFi to fully onchain gaming.

MegaETH is designed to push blockchain performance to hardware limits. With transaction throughput exceeding 100,000 TPS and block times as low as 10 milliseconds, MegaETH brings Web2-level responsiveness to the Ethereum ecosystem. For developers who need instant transaction finality without sacrificing security, this is a game-changer.

By integrating MegaETH into our platform, we're giving builders access to the infrastructure required to deploy the next generation of decentralized applications, ones that feel as fast and responsive as traditional web services.

MegaETH joins our extensive library of supported chains, reinforcing our commitment to providing developers with access to the most innovative blockchain networks.

Why Builders Choose Quicknode for MegaETH

• Ultra-Low Latency Access: Our infrastructure is optimized for MegaETH's real-time architecture, ensuring your applications maintain sub-second responsiveness even during peak network activity.
• Enterprise Reliability: With 99.99% uptime and globally distributed nodes, we provide the stability required for high-frequency trading platforms, gaming applications, and production DeFi protocols.
• Instant Sync to Tip: Deploy endpoints that stay current with MegaETH's rapid block production, critical for applications that depend on real-time state updates.
• Zero Rate Limits: Build without constraints. Our MegaETH endpoints are designed to handle the high request volumes that real-time applications demand.

Choosing Quicknode for your MegaETH deployment ensures your application is built on infrastructure engineered for speed and scale.

About MegaETH

MegaETH is a next-generation Ethereum Layer 2 network built for real-time performance. The network introduces a novel architecture that separates transaction ordering, execution, and validation across specialized node types. This approach eliminates the bottlenecks that limit traditional rollups.

The network uses a high-performance sequencer that processes transactions in memory, enabling near-instant execution. State updates are then propagated to replica nodes and published to EigenDA for data availability, while Ethereum mainnet provides settlement security.

Key Features:

• Real-Time Execution: Block times as low as 10 milliseconds enable applications that demand instant feedback, such as onchain trading and multiplayer gaming.
• 100,000+ TPS: MegaETH's parallel execution model delivers throughput that rivals centralized systems while maintaining full decentralization of block validation.
• Full EVM Compatibility: Deploy existing Solidity smart contracts using familiar Ethereum tooling like Hardhat, Foundry, and Remix without modification.
• EigenDA Integration: High-throughput data availability ensures the network can sustain massive transaction volumes without congestion.
• Ethereum Security: MegaETH inherits Ethereum's battle-tested security model, with fraud proofs and decentralized validation ensuring trustless operation.

MegaETH is purpose-built for applications that were previously impossible onchain: fully onchain order books, real-time physics engines for games, high-frequency trading bots, and consumer apps that feel instant.

What You Can Build on MegaETH

MegaETH's performance characteristics unlock new categories of decentralized applications:

High-Frequency DeFi: Build perpetual exchanges, central limit order books, and arbitrage systems where every millisecond matters. Real-time price feeds and instant order execution eliminate the latency that typically disadvantages onchain traders.

Onchain Gaming: Create multiplayer games with instant state updates for combat, trading, and leaderboards. MegaETH's tick rate supports the kind of real-time interactivity that blockchain gaming has always promised but rarely delivered.

Consumer Applications: Ship products that feel as responsive as Web2. Payment apps, social platforms, and content systems can now run entirely onchain without compromising user experience.

AI Agents: Deploy autonomous systems that execute thousands of micro-transactions with reliable, near-instant confirmation. MegaETH's deterministic execution makes it ideal for AI-driven DeFi strategies and onchain automation.

Get Started on MegaETH

With MegaETH now supported in our dashboard, developers can spin up endpoints and start building immediately.

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

If you're building on Hyperliquid right now, you already know the public RPC won't cut it. Since August 2025, the public endpoint has been capped at just 100 requests per minute. For a chain regularly processing billions in daily perp volume with sub-second finality, that limit means you need private RPC infrastructure from day one.

But choosing a Hyperliquid provider isn't as simple as picking the cheapest option. Hyperliquid's dual-layer architecture, with HyperCore handling the native L1 order book and HyperEVM running Ethereum-compatible smart contracts, means you need to think carefully about which layer (or both) your application actually needs. Not every provider supports both, and the ones that do offer very different levels of depth.

We looked at the five providers currently offering production-grade Hyperliquid RPC: Quicknode, Alchemy, Chainstack, Dwellir, HypeRPC by Imperator and Hydromancer. Here's how they compare as of February 2026.

Why Hyperliquid infrastructure is different

Before jumping into the providers, it helps to understand what makes Hyperliquid's RPC requirements unique compared to other chains.

Hyperliquid is the dominant decentralized perpetual futures exchange, holding roughly 62% of all perp DEX open interest with daily perp volumes that have ranged from $4B to $8.9B in recent months (and spiking well above that during major market events). The HYPE token sits at around #12 by market cap (~$8.2 billion), and the protocol has seen a string of major catalysts recently: HIP-3 launched permissionless perp markets in October 2025, HIP-4 is bringing prediction markets to testnet, Ripple Prime integrated institutional brokerage connectivity on February 4, Coinbase listed HYPE on February 5, and 21Shares filed for a HYPE ETF.

What matters for infrastructure is the architecture. HyperCore is a custom Rust-based execution environment that handles all order-book operations with ~0.2-second finality and throughput of around 200,000 orders per second. HyperEVM, which went live on mainnet on February 17, 2025, runs standard Ethereum smart contracts under the HyperBFT consensus, with a dual-block design (1-second small blocks, 60-second large blocks).

Providers need to support both layers, multiple protocols (HTTP, WebSocket, and ideally gRPC), and up to seven distinct HyperCore data streams including trades, orders, book updates, TWAP, events, blocks, and writer actions. One important caveat: no private RPC provider can access proprietary HyperCore trading methods like order placement and cancellation. Those still route exclusively through Hyperliquid's public API at api.hyperliquid.xyz.

Quicknode: full HyperCore + HyperEVM with the broadest protocol support

Quicknode entered the Hyperliquid ecosystem in mid-2025 and launched the HyperCore public beta on January 20, 2026. This is the key differentiator: Quicknode delivers all seven HyperCore data streams through gRPC, Streams, JSON-RPC, and WebSocket, all from a single unified endpoint that also serves HyperEVM. No other managed infrastructure provider offers this breadth of HyperCore coverage.

HyperCore is where the trading happens. It processes 200,000 orders per second and billions in daily volume. Quicknode gives you access to all seven native data stream types: trades (every fill in real-time), orders (placement and cancellation events), book updates (L2 order book deltas), TWAP (time-weighted average prices), events (liquidations, funding), blocks (full block data), and writer actions (onchain write operations).

The gRPC interface supports bidirectional streaming with native zstd compression (roughly 70% bandwidth reduction) and sub-millisecond latency. WebSocket provides real-time streaming for six data types. JSON-RPC and HTTP support historical queries, with up to 200 blocks per request. And Streams gives you filtered, push-based delivery so you can subscribe per market or event type instead of ingesting the full Hyperliquid data firehose and filtering downstream.

For HyperEVM, Quicknode serves two endpoint paths: /evm for standard Ethereum JSON-RPC (compatible with Foundry, Hardhat, Web3.js, Ethers.js, and Viem) and /nanoreth for an extended historical archive with full debug and trace methods, plus WebSocket access. You can also deploy smart contracts and read HyperCore oracle prices directly onchain.

HyperCore beta access is included on all paid plans (Build and above) with no add-on required. Usage is metered in API credits based on data volume, with Hyperliquid-specific credit multipliers documented at quicknode.com/api-credits/hyperliquid.

Overage rates run approximately $0.50 to $0.62 per million credits, depending on your plan tier, and annual billing gets you a 15% discount. On the compliance side, Quicknode holds SOC 1 Type II, SOC 2 Type II, and ISO 27001 certifications with a 99.99% uptime SLA. The platform supports 80+ chains, serves 700K+ developer accounts, and processed over 5 trillion requests in 2025 alone, with global routing across 14+ regions and 5+ cloud providers.

Quicknode has also published several Hyperliquid developer guides, including tutorials for building portfolio trackers and reading HyperCore oracle prices in HyperEVM, plus a protocol analysis that tracked Hyperliquid's rise to 76.7% perp DEX market share at its peak.

Alchemy

Alchemy focuses on HyperEVM. As of January 2026, Alchemy is an EVM-only provider for Hyperliquid and does not offer dedicated HyperCore infrastructure. Where Alchemy really stands out is its permanent free tier: 30 million compute units per month, which translates to roughly 1.2 million average requests at no cost. That's substantially more generous than any other provider on this list.

Alchemy uses a compute unit model where different methods cost different amounts: eth_blockNumber is 10 CU, eth_call is 26 CU, eth_getLogs is 60 CU, and eth_sendRawTransaction is 40 CU. At the average of about 25 CU per request, the effective cost on Pay As You Go works out to roughly $0.000011 per request.

The platform provides HTTP and WebSocket endpoints for HyperEVM mainnet and testnet, full archive data on all plans, debug/trace on PAYG and above, and Smart Wallet integration with email/social login and gas sponsorship. Alchemy holds SOC 2 Type II certification and claims 15x greater throughput than the public Hyperliquid RPC.

The trade-off is clear: Alchemy does not offer gRPC streaming or dedicated HyperCore infrastructure for Hyperliquid. If you're building a DeFi app on HyperEVM and want to keep costs low during development, Alchemy is a great starting point. If you need HyperCore data for trading or analytics, you'll need to look elsewhere.

Chainstack

Chainstack launched Hyperliquid support on May 20, 2025 and offers a straightforward pricing model of the bunch: 1 API call equals 1 request unit, regardless of which method you're calling. No credit multipliers, no variable weights. If you're scaling a Hyperliquid workload where your request mix changes over time, this makes cost estimation really simple.

The only exception: archive node requests cost 2 request units instead of 1. Chainstack also offers an Unlimited Node add-on starting at $149/month that removes per-request billing within your RPS tier, and dedicated nodes at $0.50/hour with unmetered requests.

Chainstack supports both HyperEVM and offers HyperCore info queries (account data, fills, market metadata) but does not provide dedicated gRPC streaming infrastructure. You get HTTP and WebSocket endpoints, archive nodes, and debug/trace APIs. It does not offer gRPC streaming for Hyperliquid. Some nice extras include a built-in testnet faucet (1 HYPE per 24 hours, no Twitter auth required), an HyperEVM method availability table tracking 100+ methods with live status, and an MCP Server with "Mastering Hyperliquid" best practices.

Compliance is solid: SOC 2 Type II and ISO 27001, with a 99.99% uptime SLA on dedicated nodes. Chainstack has also published more Hyperliquid content than any other provider, with eight blog posts and tutorials covering trading bot guides, onchain activity trackers, and their own provider comparison.

Dwellir

Dwellir is a Swedish company (founded 2021, based in Uppsala) that has built what is probably the most specialized Hyperliquid infrastructure of any multi-chain provider. Their offering goes well beyond standard RPC to include dedicated gRPC streaming, an L2/L4 order book server, co-located execution environments, and historical data archives.

Their general RPC platform uses a clean 1:1 pricing model starting at $5 one-time for Starter and $49/month for Developer. But their Hyperliquid-specific pricing is a separate, more granular structure:

The $1,150/month dedicated node is where things get interesting for high-volume users. It bundles HyperEVM JSON-RPC, HyperCore gRPC, and order book access with zero metering or rate limits. Worth noting: Dwellir's HyperCore gRPC offering includes three streaming endpoints (Blocks, Fills, and Orderbook) plus three unary query types, with a 24-hour data retention window and no native compression. By comparison, Quicknode's HyperCore beta delivers seven stream types with native zstd compression, filtered per-market push delivery via Streams, and full historical archive access. The trade-off is that Dwellir's order book server and co-located execution environments offer specialized trading infrastructure that Quicknode doesn't replicate.

Their order book server delivers 5x more depth than the public API (100 levels per side vs. 20), with L4 individual-order visibility including user addresses, order IDs, and timestamps. Edge servers in Singapore and Tokyo sit close to Hyperliquid's validator set, and they've benchmarked a 24.1% median latency improvement over the public feed across 2,662 trades. Co-located execution lets you run single-tenant VPS instances alongside dedicated Hyperliquid nodes, eliminating network round-trips entirely.

The main gap: Dwellir has no published compliance certifications (no SOC 2 or ISO 27001), which could be a blocker for institutional teams. They have published over 10 Hyperliquid-focused blog posts and tutorials, including guides for building liquidation trackers and copy-trading bots.

HypeRPC (by Imperator)

HypeRPC is operated by Imperator.co, a multi-chain validator operator. It launched on March 20, 2025. Currently focused on HyperEVM (HyperCore L1 support is under active development), HypeRPC differentiates through validator-backed infrastructure co-located near Hyperliquid validators, with servers in EU and Japan.

HypeRPC switched to a compute unit model in September 2025. Overage rates are $0.50 per million CU in EU or $0.75 per million CU in Japan. The Japan region carries a 50% surcharge on plan pricing, which reflects its proximity to validators and the latency advantage that comes with it. They report average latency of about 40ms with demonstrated peak throughput of 45,000 RPS.

The company also hosts HLH, the first in-person Hyperliquid hackathon (held in Seoul), which shows real commitment to the ecosystem. Up to 20% discounts are available on 12-month billing.

The current limitation is the lack of public HyperCore support. HypeRPC has built HyperCore API endpoints that mirror the foundation's (1:1 mapping), but these don't appear to be publicly available yet. If your application only needs HyperEVM, HypeRPC is a solid Hyperliquid-focused option. If you need HyperCore data streaming today, you may need to pair it with another provider, though this gap could close as HypeRPC expands its offering

Hydromancer

Hydromancer BV is a Netherlands-registered HyperCore-native API and data platform built by the former HyperDash team (acquired by pvp.trade). While HypeRPC provides standard EVM RPC endpoints, Hydromancer provides enhanced HyperCore API schemas with unique endpoints you can't get anywhere else.

These include builderFills, batchClearinghouseStates (query 1,000+ wallets at once), liquidationFills, L4 orderbook streaming with address visibility, and a complete HIP-3 DEX data stack. Pricing starts at $300/month (Starter), scaling to $1,200 (Growth), $2,500 (Scale), and custom Enterprise tiers. No rate limits. Over 30 live apps depend on it, including HyENA, pvp.trade, Redstone, and tread.fi.

Hydromancer does not provide standard EVM RPC. It serves a different layer of the stack. Builders who need both HyperEVM RPC and rich HyperCore data would pair Hydromancer with a standard provider like Quicknode.

Pricing models compared: what you'll actually pay

The five providers use three fundamentally different pricing approaches, and which one works best depends entirely on your workload.

Credit/CU-based models (Quicknode, Alchemy, HypeRPC) assign variable weights to different API methods. A simple eth_blockNumber call might cost 10 CU on Alchemy while a debug_traceTransaction costs far more. Your workload composition determines your effective cost: a read-heavy DeFi dashboard burns through credits much more slowly than a debugging-intensive dev workflow.

Flat request-based models (Chainstack, Dwellir's general platform) count every call equally. eth_call and eth_getLogs both cost exactly 1 request unit on Chainstack (archive requests are the one exception at 2x). This makes billing predictable and simple.

Specialized tiered models (Dwellir's Hyperliquid pricing, Hydromancer) charge flat monthly fees for specific data products like gRPC streaming and order book servers. Dwellir's $1,150/month dedicated node with unlimited everything is the simplest option for high-volume users who want to stop worrying about per-request costs.

For a typical Hyperliquid trading bot making 10 million requests per month (mostly eth_call, eth_getBalance, and WebSocket subscriptions), here's roughly what you'd pay:

• Quicknode Build: ~$49 (credit consumption depends on method multipliers)
• Chainstack Growth: $49 (20M requests included)
• Dwellir Developer: $49 (25M requests included)
• HypeRPC Professional: $99 (200M CU included, plenty of headroom)
• Alchemy PAYG: ~$100 to $115 (at ~25 CU average)

For high-volume HyperCore data pipelines requiring gRPC streaming, the field narrows fast: Quicknode (included on all paid plans via HyperCore beta), Dwellir ($699/month + usage or $1,150 dedicated), and eventually HypeRPC (under development).

Feature comparison at a glance

Frequently Asked Questions

What is the best Hyperliquid RPC provider for 2026?                                     

Quicknode offers the most comprehensive solution with full HyperCore and HyperEVM support, gRPC streaming, and the broadest protocol coverage. The best provider ultimately depends on your specific needs—high-frequency trading, cost optimization, or multi-chain infrastructure.

Which Hyperliquid RPC providers support gRPC streaming?

Quicknode leads with native gRPC streaming support for real-time access to Hyperliquid's order book and market data, making it ideal for low-latency trading applications. HypeRPC also offers gRPC streaming, though with a more focused feature set. This capability is essential for high-frequency trading and applications requiring sub-millisecond latency.

How much does Hyperliquid RPC access cost?

Pricing varies significantly by provider and usage volume. Quicknode offers flexible pricing starting with a free trial, with paid plans scaling based on your request volume. Alchemy provides up to 300M compute units free of charge each month to developers. Most production-grade plans range from $50-$500+ per month, depending on throughput requirements, with enterprise options available for high-volume applications.

Do I need a dedicated node, or can I use a shared RPC provider?

For most applications, RPC providers like Quicknode offer the best in-class performance and reliability at a lower cost. Dedicated nodes are necessary for high-frequency trading, applications requiring guaranteed uptime SLAs above 99.99%, or workloads exceeding 100M+ requests per month.

Can I switch between Hyperliquid RPC providers easily?

Yes, switching providers is straightforward since most use standard JSON-RPC and WebSocket interfaces. You typically only need to update your endpoint URL. However, if you've built features around provider-specific tools—like Quicknode's analytics dashboard or custom APIs—you may need to adjust those integrations. The core blockchain interactions remain compatible across providers.

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

Block Explorer, the new visibility layer for ecosystems powered by Quicknode.

Every Chain Deserves to Be Seen

Most ecosystems still rely on generic explorers that make every network look the same. Data gets scattered, brands fade and the story of a chain’s growth becomes harder to see.

We built Block Explorer to change that, starting with EVM-based networks and expanding as new architectures emerge.

Why Visibility Matters Now

As more networks launch and compete for developers, visibility has become as important as scalability or performance. Chains need a home they own, one that showcases their ecosystem, helps users explore and gives builders confidence in the data behind it.

Until now, the options weren’t great:

• Forking open source explorers is complex to maintain
• Third-party explorers limit customization and fragment data
• Building from scratch drains engineering time better spent on core protocol work

Block Explorer closes that gap. It’s a fast, flexible, fully managed solution designed for ecosystems that want to own how their story is seen.

What Block Explorer Delivers

Built for ecosystems, not templates
Custom branding and theming give every chain its own identity. Frontend modules and public APIs make it simple to create experiences that reflect your community instead of a generic layout.

Performance developers can rely on
Backed by Quicknode’s global infrastructure, explorers index and display data in real time. Smart contract decoding, account aware views and fast search keep things smooth for users and developers alike. Block Explorer is built to support modern wallet patterns, including decoded multicalls and contract traces.

Launch fast, scale easily
Go live with your explorer in weeks, not months. Flexible pricing designed to support emerging networks and scale as ecosystems grow.

Infrastructure that grows with you
Quicknode’s infrastructure is designed to scale with partner ecosystems as they grow. As networks attract users and activity, their visibility scales automatically. It’s a long-term partnership, not a one-off deployment.

Predictable Pricing. No Hidden Costs.
One predictable price covers design, build, support and managed indexing. No surprise RPC costs.

For developers, Block Explorer integrates Contract Verification, decoded read/write contract views and modular APIs so technical teams can build and access data from your ecosystem with ease.

Proof in Action: Lens Explorer

The first live implementation of Block Explorer comes from Lens Network, a high-performance blockchain stack for SocialFi. Block Explorer combines wallet-aware search, usernames, and social data in a single interface, showing how a network can bring its community to life through a branded, data-rich experience.

“Decentralized social only scales when builders can move fast and users feel at home. Collaborations like this accelerate mass adoption and move the Lens community forward.”
— Suji Yan, Founder of Mask Network

Lens proves what’s possible. Any ecosystem can now do the same.

A Strategic Partner for Ecosystems

Block Explorer is more than a standalone product. It’s part of Quicknode’s broader platform for chain infrastructure, data, and visibility, alongside tools like Streams and Webhooks, built to help networks understand and act on their data in real time.

As new chains join the Quicknode platform, Block Explorer becomes one of the tools available to them. The more an ecosystem grows, the stronger its visibility and community engagement become and the more value we build together.

“Block Explorer is the visibility and utility layer that makes ecosystem data usable, discoverable, and growth-ready.”
— Gayle Jenkins, Principal Product Manager, Quicknode

See Your Chain Come to Life

Block Explorer turns on-chain data into a living, branded experience that your ecosystem controls, all powered by Quicknode’s reliable, real-time infrastructure.

If you’re building a chain or scaling an ecosystem, we’d love to help you tell your story. Get in touch

Block Explorer is part of ChainKit, Quicknode’s launch-ready platform for chains to ship, scale, and grow with confidence.

Powered by Quicknode

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

As Solana trading becomes more competitive, accurate execution matters more than ever. Prices move fast, routes change by the block, and theoretical swap quotes often fail at execution time. For developers building trading apps, wallets, and bots, unreliable pricing directly impacts user trust and performance. We are proud to support the Titan DeFi Swap Meta-Aggregation API in the Quicknode Marketplace. This integration brings Solana's leading meta DEX aggregator to Quicknode users, enabling developers to access the best swap prices across the Solana ecosystem through a single WebSocket connection.

By integrating Titan's swap API, we are empowering developers to build trading applications, wallets, and DeFi protocols that consistently deliver optimal pricing. This support allows builders to tap into Titan's infrastructure, which has processed billions in swap volume and powers swaps for major applications, including Backpack Wallet.

The Titan DeFi Swap Meta-Aggregation API joins our Marketplace of add-ons, reinforcing our commitment to providing developers with the tools they need to build competitive Solana applications.

Why Builders Choose Quicknode

• One-Click Activation: Add Titan's swap API to your existing Quicknode endpoint without managing additional infrastructure or API keys.
• Unified Billing: Manage your swap API usage alongside your RPC and other Marketplace add-ons in a single dashboard.
• Enterprise Reliability: Build on Quicknode's globally distributed infrastructure with 99.99% uptime.

About Titan

Titan is Solana's first and leading meta DEX aggregator. Rather than pulling quotes from individual liquidity pools, as traditional aggregators do, Titan aggregates across multiple aggregators to find the absolute best price for every swap.

Key Features:

• Meta-Aggregation: Sources quotes from Titan's proprietary Argos router alongside, OKX, and other top Solana aggregators, selecting the best route for each swap.
• Real-Time Streaming: WebSocket-based API delivers quote updates every 400ms, allowing applications to track changing market conditions and execute at the optimal moment.
• Simulation Accuracy: All routes are simulated on the same block using fresh on-chain data, showing the actual expected result of each swap rather than theoretical best-case pricing.
• Composable Instructions: Every quote includes the individual Solana instructions needed to execute, enabling developers to compose swaps with their own program logic.
• Zero Platform Fees: Titan does not add platform fees to swaps. Developers can optionally add their own provider fees when building user-facing applications.

Get Started on Titan Swap API

With the Titan DeFi Swap Meta-Aggregation API now available in the Quicknode Marketplace, developers can start building immediately.

1. Visit the Titan Swap add-on page: https://marketplace.quicknode.com/add-on/titan-swap
2. Activate the add-on on your Solana endpoint 
3. Connect via WebSocket using the provided endpoint URL
4. Integrate using the TypeScript SDK (@titanexchange/sdk-ts) or Rust crates

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

Quicknode is making Hypercore powered access to Hyperliquid data available in public beta.

This release gives builders production-ready access to Hyperliquid data through Streams, gRPC, and JSON-RPC, without the operational burden of running and maintaining custom infrastructure.

This is a public beta, and we expect to make updates as we learn from real usage as teams run Hypercore at scale.

Why this matters for Hyperliquid builders

Hyperliquid’s architecture enables high-performance trading systems, real-time order books, and rich onchain trading semantics. As teams move from experimentation into production, the way data is delivered becomes as important as the data itself.

Hyperliquid operates at very high throughput, producing blocks at ~12 blocks per second under normal conditions, which quickly turns raw data access into an operational challenge as systems scale.

Many teams begin with familiar patterns:

• Polling JSON-RPC endpoints
• Using WebSockets broadly for real-time updates
• Running nodes or building custom indexers to fill gaps

This approach can work early on. Over time, it becomes harder to operate reliably as volume increases, systems grow more complex, and latency requirements tighten.

The Hypercore public beta introduces a more durable data delivery model for these conditions.

What’s included in the public beta

This public beta makes the following Hypercore-powered capabilities available for Hyperliquid:

• Streams support for Hypercore datasets, enabling filtered, push-based delivery of Hyperliquid data
• gRPC APIs designed for high-volume, low-latency data pipelines
• JSON-RPC and WebSocket-related methods for compatibility with existing workflows

Access is provided via endpoint creation, reflecting a production-focused beta.
No add-on is required. Hypercore capabilities for Hyperliquid are available on all paid Quicknode plans.

How Hypercore changes the data model

Hypercore indexes and structures Hyperliquid data centrally, shifting teams away from collect-everything pipelines toward filtered, upstream data delivery based on what their systems actually need.

Instead of collecting everything and filtering downstream, teams can:

• Subscribe to specific datasets such as trades, orders, book updates, or blocks. For example, trading teams can subscribe only to specific markets or event types instead of ingesting the full Hyperliquid data stream
• Apply filtering upstream before data reaches their systems
• Choose delivery mechanisms that better suit sustained, real-time workloads

Streams and gRPC are well suited for continuous, high-throughput pipelines, while JSON-RPC and WebSockets remain available where request-response or event-based access makes sense.

The goal is not to replace familiar access patterns, but to give teams more control over how data is delivered as their systems grow.

Pricing

Hypercore usage is metered in API credits based on data volume across Streams, gRPC, and WebSocket-related methods.

View current pricing: https://www.quicknode.com/api-credits/hyperliquid

Beta posture and next steps

The focus is on real usage under production conditions, understanding behaviour at scale, and incorporating feedback from teams building serious systems on Hyperliquid. We expect to iterate based on what we learn as usage grows.

Broader amplification, case studies, and live formats can follow once early usage and proof points emerge.

If you’re building on Hyperliquid and want to explore a more scalable data delivery model, you can get started today.

Create an endpoint | Read the documentation

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

2025 marked a clear shift in how Web3 was built and operated.

Applications moved deeper into production, traffic scaled materially, and infrastructure expectations increased across the ecosystem. Builders focused less on experimentation and more on reliability, throughput, and actual performance in the real world.

This post looks back at what that shift looked like in practice, using Quicknode’s 2025 usage data to highlight how builders shipped, where activity concentrated, and how infrastructure scaled to support it.

Here’s what that looked like on Quicknode ⬇️

The Scale

5 trillion requests processed in 2025.

That’s not a vanity number. It involves sustained production traffic across live applications, exchanges, analytics platforms, and protocols that run every day.

• ~14 billion requests per day
• 158,000 requests per second
• 99.99% uptime

Infrastructure doesn’t get credit when it works. It only gets noticed when it doesn’t. In 2025, the bar moved higher, and systems teams expected platforms not to flinch under load.

This mirrors a broader shift highlighted in a16z crypto’s State of Crypto 2025: as crypto infrastructure matured, reliability and throughput overtook experimentation as the primary requirement.

How Builders Actually Shipped in 2025

The story of 2025 wasn’t about new primitives. It was about execution.

Builders optimized for real users, real latency, and real-time data.

• Most used RPC method: eth_call
• Real-time favorite: geyserSubscribe
• Peak production behavior: sustained read-heavy workloads and live subscriptions

Reads dominated. Streaming mattered. Builders prioritized observability and responsiveness over speculative complexity.

This aligns with Electric Capital’s 2025 developer data, which shows a continued shift toward application-layer maturity and production-first workflows.

Where The Blocks Got Built

Usage followed developers, not hype.

Top chains by usage:

1. Ethereum
2. Solana
3. Base
4. Arbitrum
5. Polygon PoS

Fastest-growing chain by usage: Hyperliquid

Layer 2 traffic: ~40–45% of total requests

The takeaway is not that one chain “won.” It’s that multi-chain became the default operating model.

Electric Capital’s 2025 report shows that roughly one in three blockchain developers now works across multiple chains. Production infrastructure had to support that reality without fragmentation or operational overhead.

From Raw Data To Production

As applications scaled, so did their data requirements.

Builders moved away from bespoke pipelines and toward managed streaming, transformation, and delivery.

• Product highlight: Webhooks
• Top Marketplace add-on: Jupiter Swap API
• Streams & Webhooks:
  • 5B+ blocks processed per month
  • 330M webhook payloads delivered since July 2025

On Solana specifically:

• 923K+ SOL staked
• 2K+ active staking accounts

The pattern was clear: fewer custom systems, more production-grade primitives that teams could trust.

The Library

Documentation stopped being a nice-to-have in 2025. It became infrastructure.

• Guides and sample apps shipped: 72
• Top guide: Jito Bundles
• Most viewed Builders Guide: Top 10 Solana Sniper Bots

As teams moved from learning to operating, they needed clarity, examples, and reference architectures they could apply directly. Good docs reduced time-to-production. Bad docs became blockers.

Builders Everywhere

Growth wasn’t evenly distributed, but it was global.

• Fastest-growing region: APAC
• On-the-ground presence: 7 events across 4 continents — ETHDenver, Solana Accelerate, ETHCC, Token2049, Breakpoint, and more...

This tracks closely with broader ecosystem data from a16z’s State of Crypto 2025. While Ethereum retained the largest active developer base globally, regions like APAC continued to see outsized growth in both new builders and production usage.

Looking Back, Looking Forward

In 2024, Quicknode crossed 3 trillion requests.

In 2025, that number grew to 5 trillion.

That growth didn’t come from hype cycles. It came from teams shipping real products, scaling real systems, and expecting infrastructure to keep up.

As the crypto industry continues to mature, the work increasingly looks less like experimentation and more like engineering.

That’s where infrastructure earns its place.

Here’s to the builders who shipped in 2025, and to the systems that held while they did.

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

We are proud to support the XRPL EVM Sidechain, a pivotal development that brings Ethereum smart contract capabilities to the XRP Ledger (XRPL). This launch represents a massive step forward in interoperability, combining the established liquidity and speed of the XRPL with the developer-friendly environment of the EVM.

By integrating the XRPL EVM Sidechain, we are empowering developers to build decentralized applications (dApps) that leverage XRP as a native asset within a familiar Ethereum environment. This support allows builders to tap into one of the most passionate communities in crypto while utilizing the robust, enterprise-grade infrastructure that Quicknode is known for.

The XRPL EVM Sidechain joins our extensive library of supported chains, reinforcing our commitment to interoperability and blockchain utility at scale.

Why Builders Choose Quicknode

• Proven Performance: We provide low-latency access to the XRPL EVM Sidechain, ensuring your dApps remain responsive even during peak network activity.
• Enterprise Reliability: With 99.99% uptime and globally distributed nodes, we provide the stability required for institutional and DeFi applications.
• Optimized Infrastructure: Our endpoints are tuned to handle the specific consensus mechanisms of the sidechain, ensuring efficient query responses and reliable transaction broadcasting.

Choosing us for your XRPL EVM deployment ensures your application is built on a foundation designed for growth and cross-chain interoperability.

About XRPL EVM Sidechain

The XRPL EVM Sidechain is a distinct network running parallel to the mainchain (XRP Ledger), enabling value to move between the two without compromising the speed, efficiency, and throughput of the mainchain via a secure bridge. It allows for the execution of Solidity smart contracts, which the XRPL mainnet does not natively support. This enables a vast array of DeFi, NFT, and gaming use cases previously unavailable to the XRP ecosystem.

Key Features:

• EVM Compatibility: Deploy existing Solidity smart contracts and use standard Ethereum tooling (Remix, Hardhat, Truffle) without modification.
• XRP as Gas: The network uses XRP as the native currency for transaction fees, driving new utility for the token.
• Secure Bridging: A decentralized bridge allows for the seamless transfer of XRP and other assets between the XRPL Mainnet and the EVM Sidechain.
• CometBFT Consensus: Built on CometBFT, the chain offers instant finality and high throughput, distinct from the Proof-of-Work mechanisms of legacy Ethereum.
• Interoperability: Designed to bring the vast liquidity of the XRPL into the programmable world of EVM-based DeFi.

This sidechain is built for developers who want to innovate within the XRP ecosystem without sacrificing the rich tooling and libraries of the Ethereum world.

Get Started on XRPL EVM

With the XRPL EVM Sidechain now supported in our dashboard, developers can begin bridging the gap between these two powerful ecosystems immediately.

Create an account or log in to your existing one.

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

We are proud to support Monad, a new Layer 1 blockchain designed to deliver Ethereum compatibility at unprecedented scale and speed. Monad shares our vision for creating blockchain infrastructure that is both fast and reliable enough to power the next generation of decentralized applications. Building on our successful testnet integration, where we scaled to handle over 40 billion monthly requests and achieved 25,000 average RPS, this collaboration combines Monad's breakthrough parallel execution technology with our enterprise-grade infrastructure, providing developers with the performance they need to build consumer-scale applications.

Supporting Monad is part of our broader mission to help next-generation chains bring real performance to builders. Monad joins more than 80 chains supported on our platform, extending our focus on high-performance L1s designed for real consumer scale. Read more about our proven collaboration in the Monad case study.

Why Builders Choose Quicknode

• Proven Performance We deliver faster blockchain API responses on average, serving hundreds of thousands of developers worldwide.
• Enterprise Reliability With 99.99% uptime and global support, we keep mission-critical applications running smoothly at scale.
• Optimized Infrastructure Our infrastructure is specifically tuned to handle the high throughput and parallel execution demands of modern Layer 1 networks like Monad.

Choosing us for Monad ensures your projects are powered by infrastructure that scales with your ambition.

About Monad

Monad is a high-performance Layer 1 blockchain that achieves 10,000 transactions per second with 400-ms block times and instant finality. By introducing parallel execution to the EVM, Monad dramatically increases throughput while maintaining complete compatibility with existing Ethereum tools and smart contracts.

Key Features:

• Parallel Execution Process thousands of transactions simultaneously instead of sequentially, dramatically improving throughput
• EVM Compatibility Deploy existing Solidity contracts and use familiar Ethereum development frameworks without modification
• 400-ms Block Times Near-instant transaction confirmation for responsive user experiences
• Optimistic Processing Execute transactions optimistically and resolve conflicts efficiently to maximize performance
• MonadBFT Consensus High-performance consensus mechanism designed specifically for parallel execution environments

Monad is designed for applications that require both scalability and compatibility. DeFi protocols requiring high-frequency trading, gaming applications with thousands of concurrent users, and consumer applications expecting instant feedback can all run efficiently on Monad using the same tools developers already know.

About Quicknode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, we empower builders to deploy and scale next-generation applications across Web3.

Introduction

Eight years ago, we set out to build blockchain infrastructure that’s fast, reliable, and accessible, and that same mission continues to guide us today. What began as a focused RPC service for a handful of developers has grown into a platform trusted by hundreds of thousands of builders worldwide.

Over the years, one thing has become clear to us: great infrastructure isn’t about flashy features. It’s about reliability, performance, and trust. It’s about building something so seamless it fades into the background, allowing developers to focus entirely on creating.

The Evolution

When we started Quicknode, Web3 was still taking shape. The tools were early, the ecosystem was fragile, and developers often struggled to find consistent performance. We built Quicknode to change that and to give builders a foundation they could trust.

Since then, both the industry and our platform have transformed. What once felt experimental has become the backbone of global innovation. Builders today demand more: greater reliability, enterprise-grade performance, and partners who match their pace and ambition.

Today, Quicknode powers everything from emerging Layer 1s to enterprise-scale financial systems. Alongside our flagship Core RPC service across 77+ chains, we deliver industry-leading real-time blockchain data through Streams, advanced indexing, and analytics that help builders scale sustainably. We support enterprises with compliance, dedicated infrastructure, and the scalability needed to operate with ease.

As we’ve grown, we recognized the need for a brand that better represents our maturity and the builders and organizations we serve. This rebrand is a reflection of that evolution, a signal of our commitment to being the complete infrastructure for every scale of builder, from early innovators to global enterprises. It’s not about us; it’s about what you can build with us, without compromise.

What’s Changing Now

This rebrand marks a new chapter in how we show up for our builders and partners. It brings every product, capability, and experience together under one cohesive brand that clearly reflects the trust, scale, and performance we deliver every day.

Our goal wasn’t to reinvent Quicknode, but to express it more completely. The new identity sharpens our focus on what we already do best: empowering builders and organizations to move faster and scale smarter. It reflects our commitment to providing a complete platform that gives every team the tools they need to succeed. 

What Remains

Through every stage of growth, our mission has stayed the same: give builders a foundation they can trust and the freedom to create without friction. The same principles that defined Quicknode from day one still guide every decision we make today.

We still move quickly, listen closely, and focus on helping our customers succeed. We’re still the same team committed to precision, performance, and care - only stronger, more experienced, and more determined to keep raising the bar for what great infrastructure should be.

Looking Ahead

This rebrand marks the next step in our journey to build the invisible layer that powers the onchain Internet. When we succeed, developers won’t have to think about infrastructure at all. They’ll simply build.

To our customers, thank you for your trust, feedback, and partnership. You push us to raise the bar every day. To the next generation of builders, we can’t wait to see what you’ll create.

The new Quicknode brand is now live at Quicknode.com. Explore the site, experience what’s changed, and see how we’re building the foundation for what comes next.

Build Without Compromise.

— Alex & Dima

About QuickNode

Founded in 2017, Quicknode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 77+ blockchains, and performance trusted by industry leaders, QuickNode empowers builders to deploy and scale next-generation applications across Web3.

Start building today at Quicknode.com

Money has taken many forms: stones, shells, metal coins, and paper notes. 

But one thing has always stayed the same: its creation and control have rested with governments and banks, only visible to us through their regulations and reserves.

Bitcoin, in 2008/09, was the first meaningful shift of decentralized digital value accessible outside centralized oversight. But, it wasn’t for stability or everyday use.

That’s where stablecoins come in. 

These digital dollars maintain traditional currency's price stability while operating on blockchains, allowing anyone to verify the underlying reserves in real-time.

In 2025, with $316 billion in circulation and monthly transactions exceeding $1.25 trillion, stablecoins are an essential piece of the global financial infrastructure.

This blog will cover the adoption of stablecoins, major and relevant plays by institutions, the regulatory stance, and everything in-between. 

The Rise of Stablecoins in 2025

Stablecoins have quietly become one of the largest settlement systems on the internet. 

By the numbers:

• $316+ billion total stablecoins in circulation
• $1.25 trillion is September 2025’s stablecoins transaction volume
• 316.0 million unique addresses have used stablecoins in the last 12 months

This extraordinary growth is the showcase of trust and utility that stablecoins have garnered from retail users, builders, institutions, governments, and everyone in-between. The breadth and pace of stablecoin adoption are unprecedented — no other form of money has scaled so widely, so fast.

Now, what moved the needle the most for stablecoins?

3 Key Drivers of Stablecoin Adoption in 2025

There are a few developments and initiatives that have together contributed to these out-of-the-world numbers. But, the most impactful ones are:

Regulatory Clarity on Stablecoins

The GENIUS Act established the first comprehensive US federal framework for stablecoins, providing regulatory clarity that institutions demanded.

Similarly, MiCa by the European Union, Stablecoin Ordinance in Hong Kong, and more regulatory actions have furthered the trust in stablecoins.

Strategic Positioning of TradFi Institutions

Traditional financial institutions have moved decisively into the space. JP Morgan has processed over $1.5 trillion worth of stablecoin transactions, while Stripe's $1.1 billion acquisition of Bridge represented the largest crypto purchase by a major payments company.

Even among non-issuers, the strategic positioning is pretty evident. 

• Cloudflare announced its NET Dollar focused on AI micropayments.
• While Visa and Mastercard have integrated stablecoins into their settlement infrastructures rather than competing directly.

USDT and USDC Growing into Global Liquidity Rails

The two dominant stablecoins — Tether (USDT) and Circle’s USD Coin (USDC) — continue to anchor most of the ecosystem’s liquidity.

Their integration with traditional finance has been pivotal:

• Tether holds $127 billion in short-term Treasuries, becoming the 7th-largest buyer of US government debt in 2024
• Circle's USDC grew 78% YoY, fueled by its $1.1 billion IPO and institutional banking partnerships
• Together, they hold $150+ billion in US Treasury securities, positioning them as the 17th-largest holder of US debt globally

Both now serve as settlement layers for major banks, payment processors, and multinational corporations.

The next question isn’t whether stablecoins work — it’s how institutions, fintechs, and protocols are building around them. 

That’s where the next section begins: the major players defining the digital dollar ecosystem.

The New Players Reshaping the Digital Dollar Ecosystem

While USDT and USDC dominate the stablecoin landscape with their established infrastructure and liquidity, a new wave of enterprise-backed stablecoins is emerging with specialized use cases and strategic advantages.

PayPal PYUSD — The First Mainstream Consumer Stablecoin

PayPal’s PYUSD stands out as the first major consumer stablecoin launched by a regulated payments giant. It has grown from $500 million to $1.4 billion in 2025 which is a 150% increase making it the 9th-largest stablecoin.

Issued in partnership with Paxos Trust, PYUSD is fully backed by U.S. dollar deposits and Treasuries and operates on Ethereum and Solana currently.

World Liberty Financial USD1

World Liberty Financial’s USD1 is one of the fastest growing stablecoins reaching a $2.9 billion market cap within six months.

USD1 positions itself as a compliance-first and institution-grade tokenized dollar. The focus is around corporate treasuries, payment processors, and financial institutions seeking fully transparent, audited reserves.

One of the prime examples of USD1’s utility is when MGX, an investment fund, used USD1 to invest nearly $2 billion in Binance which is arguably the largest institutional crypto investment in history.

Cloudflare NET Dollar

Cloudflare’s NET Dollar is perhaps the most unconventional entrant in this space.

While not a payments company or a crypto exchange, Cloudflare operates at the infrastructure layer of the internet, powering over 20% of global web traffic.

And the NET dollar aims to be the stablecoin vehicle for AI agent micropayments and machine-to-machine transactions.

Think AI agents paying for compute cycles, API calls, or access fees autonomously in real time — a use case traditional payments simply can’t handle.

For Cloudflare, stablecoins are a way to embed value transfer directly into the web’s infrastructure, the same way data packets move today.

Each of these initiatives signals a different frontier of stablecoin evolution:

• PayPal PYUSD → consumer and merchant adoption through familiar fintech channels
• World Liberty USD1 → institutional trust and regulatory alignment
• Cloudflare NET Dollar → programmable infrastructure and AI-native payments

Together, they move stablecoins from a financial instrument to an economic substrate — powering commerce, computation, and compliance in equal measure.

Zooming out, there’s a much bigger development taking shape: an emerging stablecoin stack that could form the backbone of the financial internet itself.

The Stablecoin Stack: What the Future Financial Internet Looks Like

At its core, a stablecoin is just a tokenized dollar. 

But around it, an entire architecture is coming together, connecting how value is stored, verified, moved, and programmed across both traditional and decentralized systems. This ‘stablecoin stack’ sits between banks, blockchains, and businesses, quietly redefining how the world’s payment infrastructure operates.

24/7 Global Settlement Layer

Stablecoins have already surpassed traditional payment rails in both speed and availability. They settle in seconds, across time zones, skipping all intermediaries.

The settlement layer is where stablecoins have made the most progress, thanks to both:

• Public chains (Ethereum, Solana, Base) processing billions in daily transfers
• Private networks (JPMorgan's Onyx, Visa's USDC settlements, Circle's CCTP) bringing the same model into regulated environments

With both of this, the stablecoin becomes the universal settlement asset: programmable, verifiable, and interoperable.

Identity and Compliance Layer

The regulatory and compliance infrastructure is developing unevenly. 

The GENIUS Act in the US and MiCA in the EU are setting standards for stablecoin issuers: capital adequacy, reserve transparency, and redemption rights.

At the protocol level, on-chain identity and privacy-preserving compliance tools are still in development. Once they go live, participants can prove identity and compliance without revealing sensitive data which will make stablecoins very privacy-first and safe money. 

Application Layer

This is where stablecoins are starting to blend into the products people already use.

Fintech platforms, web3 applications, and even AI systems are embedding stablecoins directly into their workflows: payroll, remittances, streaming payments, data access, and subscription logic.

Stripe’s crypto payouts and PayPal’s PYUSD bring instant, on-chain settlement to mainstream commerce.

And there are more opportunities. For instance, Cloudflare’s NET Dollar could enable machine-to-machine micropayments for compute and APIs.

This is where stablecoins stop being ‘crypto’ and start being invisible money, powering user experiences that feel as seamless as the internet itself.

The stablecoin stack may still be under construction, but its trajectory is clear — money is moving toward networks that are open, programmable, and borderless.

And as each layer matures, stablecoins are starting to look less like a crypto product and more like the internet’s native settlement standard.

The Road Ahead: Stablecoins and the Future of Digital Money

Stablecoins are a fundamental rewiring of how value moves through the global economy.

Banks maintain their core functions while gaining programmability. Payment processors preserve their merchant relationships while reducing settlement friction. The result is a financial internet where money moves with the same speed and minimal friction as information does today.

Honestly, not everything is solved. Interoperability, privacy, and compliance automation remain open questions. But, the foundation is strong.

The next phase of adoption will hinge less on speculation and more on integration: banks embedding stablecoin rails into treasury systems, fintechs using them for instant cross-border payouts, and regulators refining the frameworks that make these assets safe for global use.

About QuickNode

Founded in 2017, QuickNode provides world-class blockchain infrastructure to developers and enterprises. With 99.99% uptime, support for 80+ blockchains, and performance trusted by industry leaders, QuickNode empowers builders to deploy and scale next-generation applications across Web3.

Start building today at quicknode.com