# Quicknode Documentation (Full)

> Key documentation pages concatenated into a single file, approximately 127k tokens. For targeted lookups prefer the scoped index at https://www.quicknode.com/docs/llms.txt.

Last updated: 2026-09-04

---

## API Documentation for Web3

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


Interact with RPC, REST, and gRPC endpoints across 80+ blockchains using ready-to-run examples in JavaScript, Python, Go, and more. Use Quicknode products like Streams, Webhooks, and IPFS to build and run blockchain applications from one platform.

## Send Your First Request

Make a JSON-RPC call to get the latest block number on Ethereum:

```bash
curl https://docs-demo.quiknode.pro/ \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{"method":"eth_blockNumber","params":[],"id":1,"jsonrpc":"2.0"}'
```

```javascript
const response = await fetch('https://docs-demo.quiknode.pro/', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    method: 'eth_blockNumber',
    params: [],
    id: 1,
    jsonrpc: '2.0',
  }),
});
const data = await response.json();
console.log(data.result);
```

```python
import requests

url = "https://docs-demo.quiknode.pro/"
payload = {"method": "eth_blockNumber", "params": [], "id": 1, "jsonrpc": "2.0"}
response = requests.post(url, json=payload)
print(response.json()["result"])
```

## Products

- **[Streams](/docs/streams)**: Custom real-time blockchain data pipelines with filtering and transformation logic.
- **[Webhooks](/docs/webhooks)**: Real-time blockchain data feed and alerting for on-chain events.
- **[SQL Explorer](/docs/sql-explorer)**: Direct SQL access to indexed blockchain datasets like trades, orders, positions, and liquidations, without managing infrastructure.
- **[Key-Value Store](/docs/key-value-store)**: Large-scale dataset storage accessible through a REST API on your Quicknode endpoint.
- **[IPFS](/docs/ipfs)**: Upload and retrieve data on IPFS through the Quicknode gateway.
- **[Add-ons](/docs/add-ons)**: Endpoint add-ons that extend Quicknode with extra capabilities.
- **[Custom RPC Options](/docs/custom-rpc-options)**: Dedicated infrastructure for enterprise workloads.
- **[Earn](/docs/earn)**: Non-custodial USDC yield optimizer that automatically rebalances capital across Morpho vaults.

## Guides

Long-form tutorials and walkthroughs (440+ guides) are indexed at [guides/llms.txt](https://www.quicknode.com/guides/llms.txt).

## Developer Tooling

- **[SDK](/docs/sdk)**: Official SDK for calling Quicknode product APIs from Rust, Python, Node.js, and Ruby.
- **[CLI](/docs/cli)**: The `qn` command-line tool for managing endpoints, Streams, Webhooks, Key-Value Store data, usage, billing, and teams from a terminal, script, or CI job.
- **[Admin API](/docs/admin-api)**: REST API for managing Quicknode account resources, endpoints, teams, billing, usage, logs, metrics, endpoint security, rate limits, and tags.

---

---
title: Agent Subscriptions
description: Create a Quicknode account and subscription programmatically using x402 or MPP payments. Receive a full platform API key and provision RPC endpoints without human signup.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


The Agent Subscription API (`POST /api/v1/agent/subscriptions`) creates a Quicknode account and activates a paid plan in a single HTTP request. Payment is settled via x402 or MPP using the same wallet-based payment SDKs you already use for [agentic payments](/docs/build-with-ai/agentic-payments). The response returns a `QN_*` full platform API key that unlocks the full Quicknode product suite (RPC endpoints, Streams, Webhooks, SQL Explorer, Key-Value Store, Admin API), so the agent can provision infrastructure without a human signing up through the dashboard.

The same x402 and MPP protocols that gate per-request RPC access are reused here, but in a different mode: instead of paying for one RPC call with no persistent state, a single subscription payment creates a persistent account with plan-based rate limits and a long-lived API key.

  

TL;DR

-   A single POST to `/api/v1/agent/subscriptions` with an x402 or MPP payment creates a Quicknode account synchronously and returns a `QN_*` full platform API key with no email confirmation or dashboard signup required
-   Use the same payment SDKs as agentic payments (`@quicknode/x402` or `mppx`); the SDK handles signing the 402 challenge so you never construct payment headers by hand
-   Once you have the key, use the full Quicknode platform like any other account: provision RPC endpoints and configure security via the [Admin API](/docs/admin-api), set up [Streams](/docs/streams) and [Webhooks](/docs/webhooks), query with [SQL Explorer](/docs/sql-explorer), and read/write to the [Key-Value Store](/docs/key-value-store)

Other Agentic Payments options

For per-RPC-call access without creating an account, see [x402](/docs/build-with-ai/x402-payments) and [MPP](/docs/build-with-ai/mpp-payments). All three are part of [Agentic Payments](/docs/build-with-ai/agentic-payments).

## Prerequisites

  

-   A funded wallet on a [supported payment network](/docs/build-with-ai/agentic-payments) with a supported stablecoin
-   One of the Quicknode payment SDKs:
    -   x402: [`@quicknode/x402`](https://www.npmjs.com/package/@quicknode/x402)
    -   MPP: [`mppx`](https://www.npmjs.com/package/mppx) plus [`viem`](https://www.npmjs.com/package/viem) for key handling
-   Node.js 20+ (both SDKs depend on global `fetch`)

## How It Works

The agent onboarding takes three steps. The 402 handshake and payment signing happen inside step 2; from your code's perspective, the SDK turns the whole exchange into a single `fetch` call.

  

1.  **(Optional) Discover plans.** Send the subscription request without a payment header to receive a 402 response listing all available plans, prices, accepted payment networks, and payment recipients. Skip this if you already know the plan ID you want.
2.  **Create the subscription.** The SDK detects the 402 challenge from the server, signs the payment with your wallet, retries the request, and returns the `QN_*` full platform API key. The Quicknode account is created synchronously in the same response.
3.  **Start using Quicknode.** With the full platform API key, the agent has the same access as an account created through the dashboard signup flow: provision RPC endpoints, configure [Streams](/docs/streams) and [Webhooks](/docs/webhooks), write to the [Key-Value Store](/docs/key-value-store), manage teams and billing through the [Admin API](/docs/admin-api), and more. The Quick Start below provisions an RPC endpoint and calls `eth_blockNumber` as one concrete example, but the same key works against the rest of the platform identically.

## Plans

Plan IDs sent in the `plan_name` field map to the public plan names on [pricing](https://www.quicknode.com/pricing):

| plan_name | Public name |
| --- | --- |
| b6_build | Build |
| b6_accelerate | Accelerate |
| b6_scale | Scale |
| b6_business | Business |

If you don't know which plan to use, see [Discover Plans](#discover-plans) below; the server returns the live plan list as part of the 402 response.

## Quick Start

The script below runs the full onboarding end-to-end: it creates the subscription with the payment SDK, then uses the returned `QN_*` full platform API key to provision an RPC endpoint and call `eth_blockNumber` against it as a smoke test. Endpoint provisioning is just one example of what the API key unlocks; the same key works against the rest of the [Admin API](/docs/admin-api).

  

Real funds required

Subscriptions are paid with real stablecoins on a mainnet payment network. The examples below pay with USDC on Base Mainnet (x402) and PathUSD on Tempo Mainnet (MPP). Make sure your wallet is funded on the chosen payment network before running the script.

**x402**

Install the SDK:

```bash
npm install @quicknode/x402
```

Run the script:

```typescript
import { createQuicknodeX402Client } from '@quicknode/x402'



// 1. Configure the x402 client. The SDK signs and attaches the

//    PAYMENT-SIGNATURE header automatically on any request that

//    returns HTTP 402 from the Quicknode API.

const client = await createQuicknodeX402Client({

  baseUrl: 'https://www.quicknode.com',

  network: 'eip155:8453', // payment network: Base Mainnet

  evmPrivateKey: process.env.PRIVATE_KEY as `0x${string}`,

})



// 2. Create the subscription. The SDK handles the 402 challenge,

//    signs the payment with your wallet, and retries.

const subscriptionRes = await client.fetch(

  'https://www.quicknode.com/api/v1/agent/subscriptions',

  {

    method: 'POST',

    headers: { 'Content-Type': 'application/json' },

    body: JSON.stringify({

      plan_name: 'b6_build', // Build plan

      interval: 'monthly',

      email: 'agent-abc@example.com',

      password: process.env.ACCOUNT_PASSWORD,

      password_confirmation: process.env.ACCOUNT_PASSWORD,

      full_name: 'Autonomous Agent',

      name: 'Agent Account',

      billing_address: {

        line1: '123 Main St',

        city: 'New York',

        postal_code: '10001',

        country: 'US',

      },

    }),

  },

)



const { api_key } = await subscriptionRes.json()

// api_key: "QN_abc123..."



// 3. Create an RPC endpoint using the full platform API key.

const endpointRes = await fetch('https://api.quicknode.com/v0/endpoints', {

  method: 'POST',

  headers: {

    'x-api-key': api_key,

    'Content-Type': 'application/json',

  },

  body: JSON.stringify({ chain: 'base', network: 'mainnet' }),

})



const { data } = await endpointRes.json()

const { http_url } = data



// 4. Send a JSON-RPC call to the new endpoint. The auth token is

//    embedded in the URL path, so no extra headers are required.

const rpcRes = await fetch(http_url, {

  method: 'POST',

  headers: { 'Content-Type': 'application/json' },

  body: JSON.stringify({

    jsonrpc: '2.0',

    method: 'eth_blockNumber',

    params: [],

    id: 1,

  }),

})



const { result } = await rpcRes.json()

console.log('Block number:', parseInt(result, 16))
```

**MPP**

Install the SDK:

```bash
npm install mppx viem
```

Run the script:

```typescript
import { Mppx, tempo } from 'mppx/client'

import { privateKeyToAccount } from 'viem/accounts'



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



// 1. Activate MPP. This polyfills globalThis.fetch so 402 challenges

//    are intercepted, signed, and retried automatically inside fetch.

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



// 2. Create the subscription. The polyfilled fetch detects the

//    402, signs the payment, and retries with the Authorization

//    Payment header.

const subscriptionRes = await fetch(

  'https://www.quicknode.com/api/v1/agent/subscriptions',

  {

    method: 'POST',

    headers: { 'Content-Type': 'application/json' },

    body: JSON.stringify({

      plan_name: 'b6_build', // Build plan

      interval: 'monthly',

      email: 'agent-abc@example.com',

      password: process.env.ACCOUNT_PASSWORD,

      password_confirmation: process.env.ACCOUNT_PASSWORD,

      full_name: 'Autonomous Agent',

      name: 'Agent Account',

      billing_address: {

        line1: '123 Main St',

        city: 'New York',

        postal_code: '10001',

        country: 'US',

      },

    }),

  },

)



const { api_key } = await subscriptionRes.json()

// api_key: "QN_abc123..."



// 3. Create an RPC endpoint using the full platform API key.

const endpointRes = await fetch('https://api.quicknode.com/v0/endpoints', {

  method: 'POST',

  headers: {

    'x-api-key': api_key,

    'Content-Type': 'application/json',

  },

  body: JSON.stringify({ chain: 'base', network: 'mainnet' }),

})



const { data } = await endpointRes.json()

const { http_url } = data



// 4. Send a JSON-RPC call to the new endpoint.

const rpcRes = await fetch(http_url, {

  method: 'POST',

  headers: { 'Content-Type': 'application/json' },

  body: JSON.stringify({

    jsonrpc: '2.0',

    method: 'eth_blockNumber',

    params: [],

    id: 1,

  }),

})



const { result } = await rpcRes.json()

console.log('Block number:', BigInt(result))
```

Paying with Solana?

Use [`@quicknode/x402-solana`](https://github.com/quiknode-labs/x402-solana), the Solana Kit integration for x402 on Quicknode, to sign x402 payments with a Solana keypair instead of an EVM private key. Once configured, the subscription request body and Admin API steps are identical to the x402 example above. See the [How to Access Solana RPC with x402](https://www.quicknode.com/guides/solana-development/ai-agents/how-to-access-solana-rpc-with-x402-solana) guide for setup details.

```bash
npm install @quicknode/x402-solana
```

After this runs, you have a Quicknode account on the chosen plan, an RPC endpoint URL, and a successful `eth_blockNumber` response. The agent now has the same access as any other Quicknode account: the `api_key` works against the full [Admin API](/docs/admin-api) (multichain, security rules, additional endpoints, billing) and across the rest of the Quicknode product suite (Streams, Webhooks, Key-Value Store).

### Subscription response

A successful subscription response looks like:

```json
{

  "api_key": "QN_abc123...",

  "plan": "b6_build",

  "admin_api_docs": "https://www.quicknode.com/docs/admin-api"

}
```

### Endpoint response

A successful endpoint creation response looks like:

```json
{

  "data": {

    "id": "<endpoint_id>",

    "label": null,

    "status": "active",

    "chain": "base",

    "network": "mainnet",

    "http_url": "https://<name>.base-mainnet.quiknode.pro/<token>/",

    "wss_url": "wss://<name>.base-mainnet.quiknode.pro/<token>/",

    "security": {},

    "rate_limits": {},

    "tags": []

  },

  "error": null

}
```

`wss_url` is `null` on chains that do not support WebSocket. To enable multichain on the endpoint (a single URL that routes across all Quicknode-supported chains), call `POST /v0/endpoints/<endpoint_id>/enable_multichain` with the `x-api-key` header.

## Discover Plans

If your agent needs to choose a plan dynamically, send the subscription request without a payment header. The server returns HTTP 402 with the available plans, accepted payment networks, asset contract addresses, and recipient (`payTo`) addresses in the body. A `PAYMENT-REQUIRED` header (base64-encoded x402 requirement) is also set.

```bash
curl -X POST https://www.quicknode.com/api/v1/agent/subscriptions \

  -H "Content-Type: application/json" \

  -d '{}'
```

The agent can parse the 402 body, pick a plan, and retry the request through the SDK.

## API Reference

### Endpoints

| Method | Path | Auth | Purpose |
| --- | --- | --- | --- |
| POST | /api/v1/agent/subscriptions | Payment header (x402 or MPP) | Create account and subscription |
| POST | /api/v1/agent/top_up | API key + payment header | Add credits to an existing subscription |
| GET | /api/v1/agent/balance | API key | Read current credit balance |

All endpoints share the same host: `https://www.quicknode.com`.

### Subscription request body

| Field | Required | Notes |
| --- | --- | --- |
| plan_name | Yes | One of: b6_build, b6_accelerate, b6_scale, b6_business. Omit to receive a 402 listing all plans and prices. |
| interval | No | monthly (default) or yearly. |
| email | Yes | Used for account lookup and retry resumption. |
| password | Yes | Enables retry or resume if the request needs to be retried. Must be 8–64 characters and include at least one lowercase letter, one uppercase letter, one number, and one special character. |
| password_confirmation | Yes | Must match password. |
| full_name | Yes | Primary user's full name. |
| name | Yes | Account display name. |
| billing_address.line1 | Yes | Street address. |
| billing_address.city | Yes |  |
| billing_address.postal_code | Yes |  |
| billing_address.country | Yes | ISO 3166-1 alpha-2 code (e.g. US, GB). |

### Payment headers (wire format)

The `@quicknode/x402` and `mppx` SDKs construct these headers for you. This section is a reference for clients that need to integrate at the HTTP level (for example, a non-Node runtime or a custom proxy).

#### x402

The signed payment is sent as a `PAYMENT-SIGNATURE` header containing a base64-encoded x402 v2 payload. If the header is absent, the server returns HTTP 402 with the plan and payment requirement details, and a `PAYMENT-REQUIRED` header carrying the base64-encoded x402 requirement.

```text
PAYMENT-SIGNATURE: <base64-encoded x402 v2 signed payload>
```

The payload structure and signing rules are defined by the [x402 specification](https://github.com/coinbase/x402). For background on how the SDK assembles it, see [x402 Payments](/docs/build-with-ai/x402-payments).

#### MPP

The signed payment is sent as an `Authorization: Payment` header carrying the MPP credential. If the header is absent, the server returns HTTP 402 with a `WWW-Authenticate: Payment` challenge that includes the payment method, intent, amount, and recipient.

```text
Authorization: Payment <mpp credential>
```

The credential format and challenge response are defined by the [MPP IETF Internet-Draft](https://datatracker.ietf.org/doc/draft-ryan-httpauth-payment/). For background on how the SDK handles it, see [MPP Payments](/docs/build-with-ai/mpp-payments).

## Subscription Management

### Top up credits

Adds credits to the subscription. Requires both the API key and a fresh payment header, so the SDK handles signing again.

**x402**

```typescript
const topUpRes = await client.fetch(

  'https://www.quicknode.com/api/v1/agent/top_up',

  {

    method: 'POST',

    headers: {

      'x-api-key': api_key,

      'Content-Type': 'application/json',

    },

    body: JSON.stringify({ amount: 10.0 }),

  },

)



const { balance_cents } = await topUpRes.json()
```

**MPP**

```typescript
// Mppx.create({ methods: [tempo({ account })] }) was already called in setup.

const topUpRes = await fetch(

  'https://www.quicknode.com/api/v1/agent/top_up',

  {

    method: 'POST',

    headers: {

      'x-api-key': api_key,

      'Content-Type': 'application/json',

    },

    body: JSON.stringify({ amount: 10.0 }),

  },

)



const { balance_cents } = await topUpRes.json()
```

### Check balance

Read-only; only the API key is required.

```typescript
const balanceRes = await fetch(

  'https://www.quicknode.com/api/v1/agent/balance',

  {

    headers: { 'x-api-key': api_key },

  },

)



const { balance_cents } = await balanceRes.json()
```

### Manage endpoints

List, update, configure security, and delete endpoints via the Admin API at `https://api.quicknode.com/v0/endpoints/{id}`. See the [full Admin API spec](https://www.quicknode.com/api-docs/v0/swagger.json) for available operations including security rules, rate limit overrides, tags, and multichain configuration.

## Rate Limits

| Endpoint | Limit | Scope |
| --- | --- | --- |
| POST /api/v1/agent/subscriptions | 20/min, 5/hour | IP + email |
| POST /api/v1/agent/top_up | 30/min | API key |
| GET /api/v1/agent/balance | 60/min | API key |

## Guard Rails

  

-   **Duplicate email protection**: Attempting to create an account with an existing email returns an error. Use the `email` and `password` fields to resume a failed or retried request.
-   **No free trials**: All subscriptions are production-grade from the first request.
-   **Password enables retry**: If a request fails after payment is sent, retry with the same `email` and `password` to resume rather than create a duplicate account.
-   **Synchronous creation**: Account creation and subscription activation happen in the same request. There is no async job or webhook to wait for.

## What the Subscription Unlocks

After provisioning, the `QN_*` API key provides access to the full Quicknode platform via the Admin API:

  

-   **Endpoints**: provision and manage blockchain endpoints across all supported chains and networks
-   **Security configuration** per endpoint: allowlists, JWT auth, origin restrictions
-   **Rate limit configuration** per endpoint
-   **Full product suite**: access all Quicknode products with API support
-   **Admin API surface**: usage monitoring, billing, team management

See the [Admin API docs](/docs/admin-api) and the [full spec](https://www.quicknode.com/api-docs/v0/swagger.json) for all available operations.

## Resources

[

agents.md

Full Agent API surface: auth methods, rate limits, pricing, supported chains

→](https://www.quicknode.com/agents.md)[

create-endpoint.md

Step-by-step walkthrough with curl examples and response shapes

→](https://www.quicknode.com/agents/create-endpoint.md)[

x402 Payments

Per-request RPC access via the x402 protocol

→](https://www.quicknode.com/docs/build-with-ai/x402-payments)[

MPP Payments

Per-request RPC access via the Machine Payments Protocol

→](https://www.quicknode.com/docs/build-with-ai/mpp-payments)[

Admin API Docs

Manage endpoints, billing, security, and teams via the Admin API

→](https://www.quicknode.com/docs/admin-api)[

Admin API Swagger Spec

Full OpenAPI specification for the Admin API

→](https://www.quicknode.com/api-docs/v0/swagger.json)[

Pricing

Available plans and pricing

→](https://www.quicknode.com/pricing)

tip

For managing Quicknode infrastructure through natural language, see [Quicknode MCP](/docs/build-with-ai/quicknode-mcp).

---

---
title: Agentic Payments
description: Quicknode supports two wallet-based payment protocols, x402 and MPP, for one-shot RPC calls or to programmatically create a Quicknode account via Agent Subscriptions.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


Quicknode supports two wallet-based payment protocols that let any application or AI agent pay for Quicknode requests with stablecoins. Both protocols build on HTTP `402 Payment Required` but take different approaches to payment negotiation and settlement. They support two access modes: one-shot RPC calls without an account, or paying for an [Agent Subscription](/docs/build-with-ai/agent-subscriptions) to receive a Quicknode full platform API key and unlock the full product suite, complete with the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin) for building the app itself and [Quicknode MCP](/docs/build-with-ai/quicknode-mcp) for managing the resulting account by natural language.

-   **[x402](/docs/build-with-ai/x402-payments)** is an open standard by Coinbase. Quicknode maintains client libraries (`@quicknode/x402`, `@quicknode/x402-solana`) that handle authentication and payment automatically. The x402 proxy is available at `x402.quicknode.com`.
-   **[MPP](/docs/build-with-ai/mpp-payments)** (Machine Payments Protocol) is an IETF Internet-Draft by Tempo Labs and Stripe. It uses standard HTTP authentication headers and supports multiple payment methods. The MPP proxy is available at `mpp.quicknode.com`.

Both protocols provide access to all [supported blockchain networks](https://www.quicknode.com/docs/platform/supported-chains-node-types).

  

TL;DR

-   Two wallet-based payment protocols settle Quicknode requests via HTTP 402: x402 (Coinbase open standard) and MPP (IETF Internet-Draft by Tempo Labs + Stripe)
-   Two ways to use them:
    -   **One-shot RPC calls** (no account): pay per request or via credit drawdown, agent makes calls directly against `x402.quicknode.com` or `mpp.quicknode.com`
    -   **Create a Quicknode account**: use the same protocols against [Agent Subscriptions](/docs/build-with-ai/agent-subscriptions) to receive a `QN_*` full platform API key and unlock the full Quicknode product suite (RPC endpoints, Streams, Webhooks, SQL Explorer, Key-Value Store, Admin API)
-   x402 supports pay-per-request and credit drawdown; MPP supports charge and session billing. Both handle payment negotiation automatically via their SDKs
-   The payment chain is independent of the RPC chain: pay on one network, query any Quicknode-supported blockchain

## Quickstart: Make an RPC call in seconds

No signup, API key, or credit card required

Quicknode is currently running a limited promotion: every wallet gets 1,000,000 free requests across Quicknode's x402 and MPP endpoints. These requests are paid for with free testnet tokens, so you don't need to spend real funds. No Quicknode account, billing information, or API key is required. Get started in seconds with Quicknode's CLI.

Run these four commands in order. This quickstart uses x402 to fund a local payment wallet with free Base Sepolia testnet USDC and make an Ethereum mainnet RPC request.

1.  1
    
    Install the Quicknode CLI
    
    ```bash
    brew install quicknode/tap/qn
    ```
    
2.  2
    
    Generate a payment wallet
    
    ```bash
    qn wallet generate --vm evm --name payer
    ```
    
3.  3
    
    Get test USDC
    
    ```bash
    qn rpc x402 drip --payment-wallet payer --payment-network base-sepolia
    ```
    
4.  4
    
    Call Ethereum mainnet
    
    ```bash
    qn rpc call eth_blockNumber \
    
    --network ethereum-mainnet \
    
    --x402 \
    
    --payment-wallet payer \
    
    --payment-network base-sepolia \
    
    --payment-asset USDC \
    
    --max-amount 1000
    ```
    

The final command pays with testnet USDC on Base Sepolia while querying Ethereum mainnet. The payment network and RPC network are independent, so you can pay on one network and query another.

## Comparison

|  | x402 | MPP |
| --- | --- | --- |
| Origin | Coinbase (open-source spec) | Tempo Labs + Stripe (IETF Internet-Draft) |
| Wire format | Custom payment headers | Standard HTTP auth scheme (WWW-Authenticate / Authorization / Payment-Receipt) |
| Payment methods | Stablecoins (see x402 Payments for supported networks) | Stablecoins (see MPP Payments for details) |
| Billing patterns | Pay-per-request or credit drawdown (see x402 Payments for pricing) | Charge or session (see MPP Payments for pricing) |
| Session support | Credit drawdown with SIWX auth and JWT sessions | Native payment channels with off-chain vouchers and batched settlement |
| SDKs | @quicknode/x402, @quicknode/x402-solana | mppx (TypeScript), solana-mpp |
| Protocols | JSON-RPC, REST, gRPC-Web, WebSocket | JSON-RPC, REST, gRPC-Web, WebSocket |
| Status | Alpha | Alpha |

## x402

[x402](/docs/build-with-ai/x402-payments) on Quicknode supports two access patterns:

Each wallet gets a single free tier of 1,000,000 API credits / month across Quicknode's agentic payment surfaces, including x402 and MPP. RPC requests consume 1 API credit each, while SQL Explorer consumes the API credits used by the query. The bucket resets on the first of the month, and paid usage continues at the applicable per-model rate after the free tier is exhausted.

-   **Pay-per-request**: $0.001 per request. No authentication, no session state. Each request is self-contained using the standard x402 protocol.
-   **Credit drawdown**: Authenticate once with SIWX (Sign-In with X), purchase a credit bundle ($10 for 1,000,000 requests), and consume credits per call. Better cost economics for sustained usage, and required for gRPC-Web and WebSocket.

For supported payment networks and tokens, see [x402 Payments](/docs/build-with-ai/x402-payments). The payment network is decoupled from the RPC network, so you can pay on one chain and query another.

  

tip

For a step-by-step walkthrough, see the [x402 Getting Started guide](https://www.quicknode.com/guides/x402/access-quicknode-endpoints-with-x402-payments).

## MPP

[MPP](/docs/build-with-ai/mpp-payments) (Machine Payments Protocol) on Quicknode supports two intent types:

-   **Charge**: $0.001 per request. One on-chain settlement per call. The simplest integration path.
-   **Session**: $0.00001 per request ($10 per million). The client deposits into an escrow contract and signs off-chain vouchers for each request. Settlement is batched.

For supported payment networks and methods, see [MPP Payments](/docs/build-with-ai/mpp-payments). The `mppx` SDK polyfills `fetch` to handle 402 challenges automatically.

---

---
title: Build Web3 Plugin
description: Install the Build Web3 plugin so your AI coding agent can plan, build, and improve Web3 apps with accurate Quicknode product knowledge.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


**[Build Web3 plugin](https://github.com/quicknode/agent-plugins/)** helps AI coding agents plan, build, review, and prepare Web3 apps for production.

The plugin installs two components:

-   [`build-web3`](https://www.skills.sh/quicknode/agent-plugins/build-web3) skill: guides app design, selects chains and stacks, generates starters, reviews existing projects, and fixes approved issues. It also includes Quicknode product references so the agent can use the correct methods, parameters, and schemas when needed.
-   [Quicknode MCP server](/docs/build-with-ai/quicknode-mcp): reads live blockchain data with read-only JSON-RPC calls, and manages Quicknode infrastructure such as endpoints, security, rate limits, logs, usage, and billing. Requires a Quicknode account.

If you only need the build, review, and security workflows, you can install the [`build-web3`](https://www.skills.sh/quicknode/agent-plugins/build-web3) skill on its own without the Quicknode MCP server.

## Installation

**Plugin**

Installs the skill and the MCP server. Pick your client below.

  

-   Claude Code
-   Codex
-   Cursor
-   Other Clients

Add the marketplace, then install the plugin:

```bash
/plugin marketplace add quicknode/agent-plugins
```

```bash
/plugin install build-web3@quicknode-agent-plugins
```

Start a new session. Claude Code then loads the skill and registers the `quicknode` MCP server. The first MCP tool call opens the Quicknode OAuth flow in your browser.

Add the marketplace, then install the plugin:

```bash
codex plugin marketplace add https://github.com/quicknode/agent-plugins.git

codex plugin add build-web3@quicknode-agent-plugins
```

Verify the install:

```bash
codex plugin list
```

Start a new Codex thread. Codex then loads the skill and the MCP tools.

Cursor installs the MCP server and the skill separately.

**MCP server**: use the [deeplink in the install guide](https://github.com/quicknode/agent-plugins/blob/main/docs/install/cursor.md), or add the server to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project):

```json
{

  "mcpServers": {

    "quicknode": {

      "type": "http",

      "url": "https://mcp.quicknode.com/mcp"

    }

  }

}
```

You do not need an `auth` block. The server uses OAuth 2.1 with Dynamic Client Registration. Cursor registers itself and opens the consent page on first connect.

**Skill**: install it with the skills CLI:

```bash
npx skills add quicknode/agent-plugins --skill build-web3
```

VS Code, Windsurf, and Zed use the same two steps. See the [per-client install guides](https://github.com/quicknode/agent-plugins/tree/main/docs/install).

Other clients install the two parts separately.

**Skill**: install it with the skills CLI:

```bash
npx skills add quicknode/agent-plugins --skill build-web3
```

**MCP server**: point any MCP client at `https://mcp.quicknode.com/mcp`. See [Quicknode MCP](/docs/build-with-ai/quicknode-mcp).

## What the Skill Covers

The skill loads a small router file first. It then reads only the reference it needs for the task. This keeps the agent's context small.

### Build Guidance

These references describe the app shape and the decisions behind it, before any provider or product.

| Reference | Covers |
| --- | --- |
| `use-case-playbooks` | Bots, trackers, prediction markets, indexers, and wallet-paid agents |
| `app-architectures` | Frontend, backend worker, indexer, and data pipeline shapes |
| `chains-and-stacks` | EVM, Solana, and Hyperliquid, and the starter stack for each |
| `starter-patterns` | Minimal starter layout, entry point, and environment placeholders |
| `data-and-infra` | RPC, real-time events, historical data, storage, analytics, and payments |
| `security-and-production` | Endpoint exposure, security controls, and environment separation |
| `quicknode-provider` | How to map app capabilities to Quicknode |
| `quicknode-products` | The product catalog and which product fits which need |
| `agent-access-and-automation` | Keyless agent access and account automation |
| `addons` | Add-ons that replace custom infrastructure |

### Quicknode Product References

Each reference gives method tables, setup code, schemas, and a link to the matching page in these docs.

| Category | Products |
| --- | --- |
| Infrastructure | Core RPC API, IPFS |
| Real-Time Data | Streams, Streams Backfills, Webhooks, Solana gRPC, HyperCore gRPC / Hyperliquid |
| Indexed Data | SQL Explorer, Agent Identity (ERC-8004), Blockbook, Metaplex DAS API, Ordinals & Runes API |
| Trading & DeFi | Swap API |
| Platform | Admin API, Key-Value Store, Quicknode SDK |
| Agent Surface | x402, MPP, Agent Subscriptions, Quicknode CLI, Quicknode MCP |

## Example Prompts

**Build:**

```text
Help me plan a minimal Web3 app.
```

```text
Build a TypeScript script that streams USDC transfers on Base into Postgres.
```

**Improve:**

```text
Help me harden my Web3 app for mainnet.
```

```text
Audit this repo for exposed endpoint URLs and committed secrets.
```

**Read live blockchain data (MCP):**

```text
What is the current block number on Base, and the current slot on Solana?
```

**Manage infrastructure (MCP):**

```text
Create a Base mainnet endpoint and add a rate limit of 100 requests per second.
```

**Query products:**

```text
Write a SQL Explorer query that returns the top 20 Hyperliquid traders by volume this week.
```

  

Safety defaults

The agent uses testnet when you do not name a network. It never asks for private keys. It asks you to confirm before it sends transactions, spends funds, or changes endpoint security.

tip

The skill loads on its own for a build or security task. For a product question, name the skill in your prompt: "use the build-web3 skill to write a Streams filter for USDC transfers on Base".

## Resources

[

Plugin Repository

Source for the Build Web3 plugin, open source and MIT licensed

→](https://github.com/quicknode/agent-plugins)[

Plugin README

Per-client install guides and MCP configuration

→](https://github.com/quicknode/agent-plugins/tree/main/plugins/build-web3)[

Quicknode MCP

Configure the bundled MCP server in any compatible assistant

→](/docs/build-with-ai/quicknode-mcp)[

LLM-Optimized Docs

llms.txt indexes so agents can find the full Quicknode documentation

→](/docs/build-with-ai/llms-txt)[

Solana and Anchor Skill

A separate skill for Solana program development with Anchor

→](https://github.com/quiknode-labs/solana-anchor-claude-skill)

---

---
title: Build with AI
description: Build Web3 apps with AI coding agents on Quicknode. Install the Build Web3 plugin, read live blockchain data and manage your account through MCP or the CLI, or call endpoints with no signup.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


Quicknode gives AI agents and coding assistants blockchain infrastructure and the tools to use it. Build a Web3 app with your agent, manage your account through chat or a terminal, or let an agent pay per call with no signup.

  

Start building with AI

Install the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin). Your agent can then plan, build, and improve Web3 apps, and it knows every Quicknode product. In Claude Code:

```bash
/plugin marketplace add quicknode/agent-plugins

/plugin install build-web3@quicknode-agent-plugins
```

Want the skill without the plugin or the MCP server? One command covers any agent:

```bash
npx skills add quicknode/agent-plugins --skill build-web3
```

Then ask your agent to build something:

```text
Build a script that streams USDC transfers on Base into Postgres.
```

The agent designs the app, selects the products it needs, and writes code with correct method names and schemas. See the [plugin page](/docs/build-with-ai/build-web3-plugin) for Codex, Cursor, and other clients.

## What Do You Want to Do?

| I want to | Use | Account |
| --- | --- | --- |
| Build a Web3 app with my coding agent | [Build Web3 Plugin](/docs/build-with-ai/build-web3-plugin) | Not required |
| Read live blockchain data in natural language | [Quicknode MCP](/docs/build-with-ai/quicknode-mcp) | Required |
| Manage my account in natural language | [Quicknode MCP](/docs/build-with-ai/quicknode-mcp) | Required |
| Manage my account from a terminal or CI job | [CLI](/docs/cli) | Required |
| Manage my account from my own code | [SDK](/docs/sdk) | Required |
| Call RPC endpoints with a wallet, no signup | [x402](/docs/build-with-ai/x402-payments) or [MPP](/docs/build-with-ai/mpp-payments) | Not required |
| Create an account and API key from an agent | [Agent Subscriptions](/docs/build-with-ai/agent-subscriptions) | Created for you |
| Point my agent at the full documentation | [LLM-Optimized Docs](/docs/build-with-ai/llms-txt) | Not required |

## How Access Works

The Account column above has three values. Each one maps to an access model.

### API Key

Create a [Quicknode account](https://www.quicknode.com/signup) and generate an API key. This is the standard access model. It covers every product API, based on your [pricing plan](https://www.quicknode.com/pricing).

### Agentic Payments (x402 and MPP)

Two wallet-based payment protocols give access to the **Core API** with no account. This includes all blockchain endpoints: RPC, REST, gRPC, and WebSocket. Both protocols handle payment negotiation through their client SDKs.

  

-   **[x402](/docs/build-with-ai/x402-payments)**: Open standard by Coinbase. Supports pay-per-request and credit drawdown.
-   **[MPP](/docs/build-with-ai/mpp-payments)**: IETF Internet-Draft by Tempo Labs and Stripe. Supports charge and session-based access.

### Agent Subscriptions

The [Agent Subscription API](/docs/build-with-ai/agent-subscriptions) creates a Quicknode account and activates a subscription in one payment request, through x402 or MPP. The response returns a full platform API key (`QN_*`).

That key gives the same access as a dashboard signup with a plan. Use it when an agent must manage infrastructure, monitor usage, or reach products such as Streams, Webhooks, Key-Value Store, and the Admin API.

## Quicknode APIs

All Quicknode product APIs are standard HTTP, JSON-RPC, REST, gRPC, and WebSocket endpoints. Any client can call them directly, including AI agents. No special tooling is needed. See the [documentation home](/docs/welcome) for every product API.

The Admin API is the base for every Quicknode developer tool. The [SDK](/docs/sdk), the [CLI](/docs/cli), and [Quicknode MCP](/docs/build-with-ai/quicknode-mcp) are three interfaces to the same account operations. All three also make read-only JSON-RPC calls through Tooling Access, with no endpoint to provision. Pick the one that fits your workflow.

---

---
title: LLM-Optimized Docs
description: Quicknode publishes llms.txt indexes so AI tools and LLMs can discover and reason about Quicknode's full developer resource library, including RPC methods, developer tooling, guides, sample apps, and ecosystem documentation.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


Quicknode publishes `llms.txt` indexes across its documentation, guides, and developer resources. These plain-text files follow the [llms.txt standard](https://llmstxt.org/) and are designed to help AI tools, LLMs, and developers using AI find and reference the right content for any blockchain development task. The indexes cover Quicknode's full content surface: products, pricing, supported chains, add-ons, RPC methods and API references across all supported networks, developer tooling like the SDK, CLI, and Admin API, development guides, sample applications, courses, and ecosystem resources.

```bash
# Fetch the main Quicknode documentation index for LLMs

curl https://www.quicknode.com/docs/llms.txt
```

  

TL;DR

-   Quicknode publishes plain-text `llms.txt` indexes across docs, guides, sample apps, and courses. Point any AI agent or RAG pipeline at an index URL to give it access to the right content surface
-   Indexes cover RPC methods, API references, developer tooling, guides, sample applications, pricing, supported chains, and ecosystem resources
-   Append `.md` to any Quicknode content URL for a clean Markdown version suitable for LLM input or RAG ingestion

## Available Indexes

| Index | URL | Content |
| --- | --- | --- |
| Main platform | [quicknode.com/llms.txt](https://www.quicknode.com/llms.txt) | Products, chains, and platform resources |
| Documentation | [quicknode.com/docs/llms.txt](https://www.quicknode.com/docs/llms.txt) | RPC methods, API references, product docs, and developer tooling such as the SDK, CLI, and Admin API |
| Guides | [quicknode.com/guides/llms.txt](https://www.quicknode.com/guides/llms.txt) | Development guides and tutorials |
| x402 | [x402.quicknode.com/llms.txt](https://x402.quicknode.com/llms.txt) | x402 payment protocol documentation |
| MPP | [mpp.quicknode.com/llms.txt](https://mpp.quicknode.com/llms.txt) | MPP payment protocol documentation |
| Builder's Guide | [quicknode.com/builders-guide/llms.txt](https://www.quicknode.com/builders-guide/llms.txt) | Web3 tool comparisons and ecosystem resources |
| Sample App Library | [quicknode.com/sample-app-library/llms.txt](https://www.quicknode.com/sample-app-library/llms.txt) | Sample applications and code examples |
| Courses | [quicknode.com/courses/llms.txt](https://www.quicknode.com/courses/llms.txt) | Blockchain development courses |

## Copy for AI

Quicknode documentation, guides, sample apps, and course pages include a **Copy page** button that lets you open the current page directly in Claude, ChatGPT, or Perplexity, or copy it as Markdown for use in any LLM.

You can also append `.md` to any Quicknode content URL to get a clean Markdown version, suitable for pasting into an LLM or using in a RAG pipeline. For example: `https://www.quicknode.com/docs/ethereum.md`

## Usage

Point your AI coding agent or assistant at any index URL to give it access to the relevant documentation surface. For RAG pipelines, each index is plain text and organized by content category, making it straightforward to fetch, chunk, and ingest. The main platform index serves as a discovery layer for routing questions to the appropriate sub-index.

  

tip

To help AI coding agents plan, build, and improve Web3 apps, with accurate Quicknode product knowledge built in, see the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin). To manage your Quicknode infrastructure through a conversational AI interface, see [Quicknode MCP](/docs/build-with-ai/quicknode-mcp). To script Quicknode workflows from a terminal or CI job, see the [CLI](/docs/cli).

---

---
title: MPP Payments
description: Access Quicknode's blockchain infrastructure with pay-per-request stablecoin payments using the MPP protocol. No account or API keys required.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


MPP (Machine Payments Protocol) on Quicknode provides pay-per-request access to blockchain endpoints across all supported networks. MPP is an open protocol by Tempo Labs and Stripe, submitted as an [IETF Internet-Draft](https://datatracker.ietf.org/doc/draft-ryan-httpauth-payment/), that enables machine-to-machine stablecoin micropayments via standard HTTP authentication headers.

Any application or AI agent with a wallet can start making RPC calls immediately. No account, API keys, or subscription required.

MPP is an additive access method. It does not replace Quicknode's standard plans. Teams running production workloads benefit from standard plans with SLAs, dedicated support, and higher rate limits. MPP is designed for AI agents, rapid prototyping, and use cases where permissionless, per-request access is the priority.

  

TL;DR

-   MPP can be used two ways: **one-shot RPC calls** with a funded wallet and no account (covered on this page), or paying for an [Agent Subscription](/docs/build-with-ai/agent-subscriptions) to create a Quicknode account and receive a full platform API key for the full product suite
-   Two one-shot billing modes: Charge ($0.001/request, one on-chain settlement per call) and Session ($0.00001/request, escrow deposit with batched off-chain voucher settlement)
-   Install `mppx`, which polyfills `fetch` to intercept 402 responses and handle payment negotiation automatically

info

MPP on Quicknode is currently in alpha.

```bash
# Fetch machine-readable MPP documentation for AI agents

curl https://mpp.quicknode.com/llms.txt
```

## Quick Start

Install the `mppx` package:

```bash
npm install mppx viem
```

This example uses the Tempo payment method with PathUSD. [Fund your wallet](https://docs.tempo.xyz/guide/getting-funds) before making requests.

```typescript
import { Mppx, tempo } from 'mppx/client'

import { privateKeyToAccount } from 'viem/accounts'



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



// Polyfills globalThis.fetch to handle 402 challenges automatically

Mppx.create({

  methods: [tempo({ account })],

})



// Replace /tempo-mainnet with any supported network slug

const response = await fetch('https://mpp.quicknode.com/tempo-mainnet', {

  method: 'POST',

  headers: { 'Content-Type': 'application/json' },

  body: JSON.stringify({

    jsonrpc: '2.0',

    id: 1,

    method: 'eth_blockNumber',

    params: [],

  }),

})



const { result } = await response.json()

console.log('Block number:', BigInt(result))
```

With the polyfill active, standard `fetch` calls handle payment negotiation automatically. The client detects 402 responses, signs the required payment, and retries the request. The payment method is independent of the chain you query, so replace `/tempo-mainnet` in the URL with any [supported network](https://www.quicknode.com/chains) slug to call a different chain.

  

Looking for other setup options?

Use the [`mppx` CLI](#cli) to make paid RPC calls directly from the terminal. For paying with Solana USDC instead, see [Solana Setup](#solana-setup).

## Supported Protocols

MPP endpoints support the following protocols:

-   JSON-RPC
-   REST

## Pricing

MPP supports two billing patterns (intents) that determine how payments are structured:

|  | Charge | Session |
| --- | --- | --- |
| Cost per request | $0.001 | $0.00001 ($10 per million requests) |
| Endpoint | POST /:network/\\* | POST /session/:network/\\* |
| Settlement | One on-chain transaction per request | Off-chain vouchers, batched on-chain settlement |
| Best for | Simple integrations, low volume | High volume, agents, metered usage |

## Intent Types

### Charge

The charge intent is the simplest path. Each request triggers a single on-chain payment. There is no session state, no escrow, and no setup. The `mppx` SDK handles the 402 challenge and payment signing automatically.

### Session

The session intent uses payment channels for high-frequency access. The flow:

  

1.  The client deposits funds into an escrow contract (approximately 500ms initial setup).
2.  Each subsequent request sends a cumulative EIP-712 signed voucher instead of an on-chain transaction.
3.  The server verifies each voucher with a single `ecrecover` call, with no RPC or database lookup needed.
4.  The server closes the channel on its own schedule, settling in batches on-chain.
5.  Unused funds from the deposit are refunded when the channel closes.

```typescript
import { Mppx, tempo } from 'mppx/client'

import { privateKeyToAccount } from 'viem/accounts'



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



// Session-only — payment channels for 100x cheaper requests

Mppx.create({

  methods: [tempo.session({ account })],

})



// First request opens channel on-chain (~500ms),

// subsequent requests use off-chain vouchers (microseconds)

// Replace /tempo-mainnet with any supported network slug

const response = await fetch('https://mpp.quicknode.com/session/tempo-mainnet', {

  method: 'POST',

  headers: { 'Content-Type': 'application/json' },

  body: JSON.stringify({

    jsonrpc: '2.0',

    id: 1,

    method: 'eth_blockNumber',

    params: [],

  }),

})



console.log(await response.json())
```

## Supported Payment Networks

Stablecoin payments are accepted on the following networks:

| Network | Token |
| --- | --- |
| Tempo Testnet (chain 42431) | PathUSD |
| Tempo Mainnet (chain 4217) | PathUSD / USDC.e |
| Solana Mainnet | USDC |

The payment network is independent of the chain you query. For example, you can pay with PathUSD on Tempo and query Ethereum, Solana, or any other supported chain.

### Free Tier

Each wallet gets a single free tier of 1,000,000 API credits / month across Quicknode's agentic payment surfaces, including MPP and x402. RPC requests consume 1 API credit each, while SQL Explorer consumes the API credits used by the query. The bucket resets on the first of the month, and paid usage continues at the applicable per-model rate after the free tier is exhausted.

## Solana Setup

For Solana-native integrations, use the `solana-mpp` package:

```bash
npm install solana-mpp mppx @solana/web3.js @solana/spl-token
```

```typescript
import { Mppx, solana } from 'solana-mpp/client'

import { Keypair } from '@solana/web3.js'



const keypair = Keypair.generate()



Mppx.create({ methods: [solana({ wallet: keypair })] })



// Replace /solana-mainnet with any supported network slug

const response = await fetch('https://mpp.quicknode.com/solana-mainnet', {

  method: 'POST',

  headers: { 'Content-Type': 'application/json' },

  body: JSON.stringify({

    jsonrpc: '2.0',

    id: 1,

    method: 'getSlot',

    params: [],

  }),

})



const { result } = await response.json()

console.log('Slot:', result)
```

## CLI

The `mppx` CLI lets you make paid RPC calls directly from the terminal:

```bash
npm install -g mppx



# Create a wallet (stored in keychain)

mppx account create



# Charge intent — $0.001/request (replace /tempo-mainnet with any supported network)

mppx -X POST -H 'Content-Type: application/json' \

  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' \

  https://mpp.quicknode.com/tempo-mainnet



# Session intent — $0.00001/request (replace /session/tempo-mainnet accordingly)

mppx -X POST -H 'Content-Type: application/json' \

  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' \

  https://mpp.quicknode.com/session/tempo-mainnet
```

## Rate Limits

MPP endpoints are rate limited to 1,000 requests per 10 seconds per IP:network combination.

## Payment Receipts

Every successful response includes a `Payment-Receipt` header. You can parse it with the `mppx` SDK:

```typescript
import { Receipt } from 'mppx'



const receipt = Receipt.fromResponse(response)

console.log(receipt.status)    // "success"

console.log(receipt.reference) // tx hash (charge) or channelId (session)
```

## How It Works

The `mppx` SDK handles the full payment flow automatically. Under the hood, each request follows this sequence:

  

1.  **Send a request.** POST a JSON-RPC or REST call to `https://mpp.quicknode.com/:network` (charge) or `https://mpp.quicknode.com/session/:network` (session).
2.  **Receive a payment challenge.** The server responds with HTTP 402 and a `WWW-Authenticate: Payment` header containing the payment method, intent, amount, and recipient.
3.  **Sign and retry.** The client signs a token transfer and retries the request with an `Authorization: Payment` header carrying the payment credential.
4.  **Receive the response.** The server settles the payment, proxies the RPC request, and returns the result with a `Payment-Receipt` header containing the transaction reference.

```text
# Challenge (server → client, on 402)

WWW-Authenticate: Payment id="...", realm="mpp.quicknode.com",

  method="tempo", intent="charge", request="<base64url JSON>"



# Credential (client → server)

Authorization: Payment <credential>



# Receipt (server → client, on success)

Payment-Receipt: <receipt>
```

## MPP vs Standard Quicknode Plans

|  | MPP | Standard Plans |
| --- | --- | --- |
| Authentication | Wallet-based (HTTP Payment auth) | Account-based (API key) |
| Billing | Pay per request (stablecoins) | [Monthly/Yearly subscription](https://www.quicknode.com/pricing) |
| Setup required | Wallet + stablecoin | Account + API key |
| Status | Alpha | Production SLA |
| Best for | Agents, prototyping, permissionless access | Teams, production workloads |

## Resources

[

mppx SDK

Official TypeScript SDK for MPP

→](https://www.npmjs.com/package/mppx)[

solana-mpp

Solana payment method for MPP

→](https://www.npmjs.com/package/solana-mpp)[

MPP Documentation

Full MPP protocol documentation

→](https://mpp.dev/overview)[

IETF Internet-Draft

Payment HTTP authentication scheme specification

→](https://datatracker.ietf.org/doc/draft-ryan-httpauth-payment/)[

Tempo Payment Method

Tempo-specific payment method documentation

→](https://mpp.dev/payment-methods/tempo)[

mppx CLI Reference

CLI tool for making MPP payments from the terminal

→](https://mpp.dev/sdk/typescript/cli)

tip

For managing Quicknode infrastructure through natural language, see [Quicknode MCP](/docs/build-with-ai/quicknode-mcp). To help AI coding agents plan, build, and improve Web3 apps with accurate Quicknode product knowledge, see the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin). For the x402 payment protocol, see [x402 Payments](/docs/build-with-ai/x402-payments).

---

---
title: Quicknode APIs
description: Quicknode's blockchain APIs are standard HTTP endpoints that any AI agent or LLM-powered application can call directly for RPC, data pipelines, storage, and account management.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


Quicknode exposes its full product suite through standard HTTP, JSON-RPC, REST, gRPC, and WebSocket endpoints. These are the same APIs that power production dApps and infrastructure. Because they use standard protocols, any application, AI agent, or LLM-powered tool can call them directly without special SDKs or wrappers.

  

TL;DR

-   Core API, Streams, Webhooks, Key-Value Store, and Admin API are all standard HTTP/JSON-RPC/REST/gRPC/WebSocket endpoints, no special SDK needed
-   API keys authenticate account-based access. Get one via the [Quicknode dashboard](https://dashboard.quicknode.com/) or programmatically through [Agent Subscriptions](/docs/build-with-ai/agent-subscriptions)
-   For accountless access, wallet-based per-request access with no signup is available for Core API endpoints, use [x402](/docs/build-with-ai/x402-payments) or [MPP](/docs/build-with-ai/mpp-payments) payments

## Authentication

Quicknode APIs authenticate with an API key tied to your account. You can generate and manage API keys from the [Quicknode dashboard](https://dashboard.quicknode.com/) or programmatically through [Agent Subscriptions](/docs/build-with-ai/agent-subscriptions).

All requests include the API key either as part of the endpoint URL or as a header, depending on the API:

```bash
# JSON-RPC — API key is part of the endpoint URL

curl https://your-endpoint-name.network-name.quiknode.pro/your-api-key/ \

  -X POST \

  -H "Content-Type: application/json" \

  -d '{"method":"eth_blockNumber","params":[],"id":1,"jsonrpc":"2.0"}'



# REST API — API key as a header

curl https://api.quicknode.com/streams \

  -H "x-api-key: YOUR_API_KEY"
```

  

tip

If you prefer wallet-authenticated, pay-per-request access with no account required, see [x402 Payments](/docs/build-with-ai/x402-payments) or [MPP Payments](/docs/build-with-ai/mpp-payments).

## Supported Protocols

Quicknode endpoints support multiple protocols depending on the chain and product:

-   **JSON-RPC** — Standard RPC calls over HTTP for all supported chains
-   **REST** — RESTful endpoints for Streams, Webhooks, Key-Value Store, and Admin APIs
-   **gRPC** — High-throughput streaming for Solana gRPC (Yellowstone-compatible Geyser gRPC) and Hyperliquid (Hypercore)
-   **WebSocket** — Real-time subscriptions for event-driven workflows

## Available APIs

| API | Description | Docs |
| --- | --- | --- |
| Core API | Interact with RPC, REST, and gRPC endpoints across all supported blockchains | [View](https://www.quicknode.com/docs/welcome) |
| Streams API | Create and manage real-time blockchain data pipelines | [View](https://www.quicknode.com/docs/streams/rest-api) |
| Webhooks API | Configure event-driven notifications for onchain activity | [View](https://www.quicknode.com/docs/webhooks/rest-api/getting-started) |
| SQL Explorer API | Run SQL queries against indexed onchain data via REST | [View](https://www.quicknode.com/docs/sql-explorer/using-rest-api) |
| Key-Value Store API | Read and write to serverless key-value storage | [View](https://www.quicknode.com/docs/key-value-store/rest-api/getting-started) |
| Admin API | Programmatically manage endpoints, usage, security, and billing — or do it conversationally through Quicknode MCP | [View](https://www.quicknode.com/docs/admin-api) |
| IPFS API | Pin and retrieve files on IPFS through the Quicknode gateway | [View](https://www.quicknode.com/docs/ipfs) |

Each API has full documentation with method references, parameters, and ready-to-run examples. Point your agent at the [docs index](https://www.quicknode.com/docs/llms.txt) or install the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin), which helps it plan and build a Web3 app and ships with accurate knowledge of these APIs out of the box.

## SDK

Manage your whole Quicknode setup from code. The [SDK](/docs/sdk) gives you typed clients for the Admin, Streams, Webhooks, and Key-Value Store APIs in Rust, Python, Node.js, and Ruby, so you can create and configure endpoints, set security rules, handle billing, manage teams, run Streams and Webhooks, and read or write the Key-Value Store, all as native method calls. It handles authentication, request and response types, and pagination for you, so the requests come out correct with fewer runtime errors than hand-rolled calls.

## API Specifications (OpenRPC, OpenAPI)

Quicknode publishes machine-readable OpenAPI and OpenRPC specs for its APIs. Agents can load them to auto-generate request shapes, validate parameters, and discover available operations without scraping the docs.

| API | Spec URL |
| --- | --- |
| Streams API | [api.quicknode.com/streams/rest/openapi.json](https://api.quicknode.com/streams/rest/openapi.json) |
| Webhooks API | [api.quicknode.com/webhooks/rest/openapi.json](https://api.quicknode.com/webhooks/rest/openapi.json) |
| Key-Value Store API | [api.quicknode.com/kv/rest/openapi.json](https://api.quicknode.com/kv/rest/openapi.json) |
| IPFS API | [quicknode.com/docs/openapi/ipfs.openapi.json](https://www.quicknode.com/docs/openapi/ipfs.openapi.json) |
| Admin API | [quicknode.com/docs/openapi/admin-api.openapi.json](https://www.quicknode.com/docs/openapi/admin-api.openapi.json) |

For the **Core API**, Quicknode publishes per-chain OpenRPC/OpenAPI specs covering RPC methods. Coverage is rolling out across major chains; see the [Ethereum API Overview](https://www.quicknode.com/docs/ethereum/api-overview#api-specifications-openrpc-openapi) for a representative example, and the linked spec is available alongside each chain's API overview page.

---

---
title: Quicknode MCP
description: Query live blockchain data and manage Quicknode infrastructure through natural language, using the official MCP server with any compatible AI assistant.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


The **Quicknode MCP server** connects your Quicknode account to MCP-compatible AI assistants like ChatGPT, Codex, Claude Code, Claude Desktop, Cursor, VS Code, and more. Once connected, you can read live blockchain data, create and manage endpoints, monitor usage, configure security settings, and review billing data through natural language instead of navigating the dashboard or writing API scripts.

The server is hosted remotely at `https://mcp.quicknode.com/mcp` and authenticates via OAuth. Its tools reach Quicknode over two paths. The account tools call Quicknode's [Admin API](/docs/admin-api). The `call-rpc` tool reads the blockchain directly through [Tooling Access](#blockchain-rpc-calls), an account-level setting that covers every network Quicknode supports. The assistant interprets your request, selects the appropriate tool, and executes it after confirmation.

  

TL;DR

-   Read live blockchain data with the `call-rpc` tool. No endpoint provisioning required. An Admin enables Tooling Access once for the account. See [Blockchain RPC Calls](#blockchain-rpc-calls)
-   Quicknode is an [official connector](https://claude.com/connectors/quicknode) in the **Anthropic MCP directory** — add it [directly](https://claude.ai/directory/connectors/356a8580-5936-40a0-9a06-5ab54bdaa344) or find it under **Customize** > **Connectors** in Claude
-   Quicknode is also available natively in **ChatGPT** and **Codex** — install directly from the [ChatGPT Apps catalog](https://chatgpt.com/apps/quicknode/asdk_app_69ca79775c848191a5f1e538e77aedbb) or via `/plugin` in Codex
-   All other clients (Cursor, VS Code, Windsurf, Zed) connect by pointing to `https://mcp.quicknode.com/mcp` and authorizing via OAuth
-   For CI/CD and non-interactive environments, skip OAuth and pass an API key directly — see [Using an API Key](#using-an-api-key)
-   Manage endpoints, monitor usage, configure security rules, and review billing through natural language, no dashboard or API scripts required

## Requirements

  

-   A [Quicknode account](https://www.quicknode.com/signup)
-   An MCP-compatible AI assistant (ChatGPT, Codex, Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Zed, or similar)

## Configuration

Add the Quicknode MCP server to your assistant using the instructions for your client below.

  

**Claude**

#### Claude Web

Quicknode is an [official connector](https://claude.com/connectors/quicknode) in the Anthropic MCP directory. To connect it in Claude:

  

1.  Visit the [Quicknode connector page](https://claude.ai/directory/connectors/356a8580-5936-40a0-9a06-5ab54bdaa344), or open [Claude](https://claude.ai/) in your browser and navigate to **Customize** > **Connectors** to find Quicknode in the directory
2.  Click **Connect**
3.  A browser window will open — log in with your Quicknode account, select a role (**Admin** or **Viewer**), and approve access

#### Claude Desktop

To add the Quicknode MCP server to the Claude Desktop app:

  

1.  Navigate to **Customize** > **Connectors**
2.  Find **Quicknode** in the directory and click **Connect**
3.  A browser window will open — log in with your Quicknode account, select a role (**Admin** or **Viewer**), and approve access

#### Claude Code

To add the Quicknode MCP server to Claude Code, run the following command in your terminal:

  

1.  Add the server:

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

  

2.  Start Claude Code and type `/mcp` to authorize the server in the browser window that opens

Installation Scopes

By default, the command above installs the server in **local** scope (current project only). Claude Code supports three scopes:

-   **Local** (default) — Available only to you in the current project
-   **Project** (`--scope project`) — Shared with your team via a `.mcp.json` file in the project root
-   **User** (`--scope user`) — Available to you across all projects

To install globally for your user, add the `--scope user` flag:

```bash
claude mcp add --transport http --scope user quicknode https://mcp.quicknode.com/mcp
```

**OpenAI**

#### ChatGPT

To connect the Quicknode MCP server to ChatGPT:

  

1.  Visit the [Quicknode app on ChatGPT](https://chatgpt.com/apps/quicknode/asdk_app_69ca79775c848191a5f1e538e77aedbb), or open [ChatGPT](https://chatgpt.com), go to **Apps** in the sidebar, and search for **Quicknode**
2.  Click **Connect** on the Quicknode app page
3.  A browser window opens at `mcp.quicknode.com` where you log in with your Quicknode account, select a role (**Admin** or **Viewer**), and approve access
4.  Quicknode is now available in your ChatGPT conversations. Mention **@Quicknode** in any chat to use it

#### Codex

To add Quicknode to Codex (OpenAI):

  

1.  Open Codex and type `/plugin` in the input
2.  Browse the available plugins and select **Quicknode**
3.  Press Enter to view details, then select **Install plugin**
4.  If you have not already connected via ChatGPT, a browser window opens for OAuth authorization where you log in with your Quicknode account, select a role (**Admin** or **Viewer**), and approve access
5.  After installation, Quicknode tools are available in your Codex sessions

tip

If you have already connected Quicknode in ChatGPT, the authorization step is skipped and the plugin is ready to use immediately.

**Cursor**

To add the Quicknode MCP server to Cursor:

  

1.  Go to **Settings** > **Tools & MCPs**, and click **New MCP Server**
2.  (Optionally) Open (or create) `.cursor/mcp.json` in your project root or home directory
3.  Add the following configuration:

```json
{

  "mcpServers": {

    "quicknode": {

      "url": "https://mcp.quicknode.com/mcp"

    }

  }

}
```

4.  Once you save the file, Cursor will detect the new server configuration.
5.  Click **Connect** next to the Quicknode MCP server in the Cursor interface
6.  A browser window will open where you can log in with your Quicknode account and approve access

**VS Code**

To add the Quicknode MCP server to VS Code (GitHub Copilot):

  

1.  Open the Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`)
2.  Search for **"MCP: Add Server"**
3.  Select **"HTTP"** as the server type
4.  Enter the URL: `https://mcp.quicknode.com/mcp`
5.  Choose whether to save to **User Settings** (global) or **Workspace Settings** (project-only)

Alternatively, add this to your `.vscode/mcp.json`:

```json
{

  "mcp": {

    "servers": {

      "quicknode": {

        "type": "http",

        "url": "https://mcp.quicknode.com/mcp"

      }

    }

  }

}
```

**Windsurf**

To add the Quicknode MCP server to Windsurf:

  

1.  Open **Windsurf Settings** > **Cascade** > **MCP** > **Add Server** > **Add custom server**
2.  This opens `~/.codeium/windsurf/mcp_config.json`. Add:

```json
{

  "mcpServers": {

    "quicknode": {

      "serverUrl": "https://mcp.quicknode.com/mcp"

    }

  }

}
```

3.  Click the refresh button in the MCP section of settings to activate

**Zed**

To add the Quicknode MCP server to Zed:

  

1.  Open **Settings** (`Cmd+,` / `Ctrl+,`)
2.  Add the following to your `settings.json`:

```json
{

  "context_servers": {

    "quicknode": {

      "transport": "http",

      "url": "https://mcp.quicknode.com/mcp"

    }

  }

}
```

3.  Restart Zed to activate the server

**Other Clients**

For any other MCP-compatible client, use the following connection details:

  

-   **URL:** `https://mcp.quicknode.com/mcp`
-   **Transport:** Streamable HTTP
-   **Authentication:** OAuth 2.1 (handled automatically on first connect)

If your client doesn't support OAuth or HTTP transport natively, you can use `mcp-remote` as a bridge:

```json
{

  "mcpServers": {

    "quicknode": {

      "command": "npx",

      "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp"]

    }

  }

}
```

## Authentication and Roles

When you connect for the first time, a browser window opens where you log in with your Quicknode account. If you belong to multiple Quicknode accounts, you'll choose which one to connect. You will then select an **API key role** that determines what the MCP server can do on your behalf:

  

-   **Viewer** — Read-only access. Your assistant can read live blockchain data with `call-rpc`, list endpoints, and view metrics, logs, usage, and billing data, but cannot create, modify, or delete any resources.
-   **Admin** — Everything the Viewer role can do, plus write access. Your assistant can create and delete endpoints, modify security rules, update rate limits, enable or disable Tooling Access, and manage all account resources.

This process creates an API key under the hood, scoped to the role you selected. You do not need to create or manage the key yourself.

  

Choosing the Right Role

Choose the **Viewer** role if you only need to inspect your infrastructure. Use **Admin** only when you need the assistant to make changes. If you need to switch roles later, remove the server from your client, re-add it, and go through the authorization flow again to re-authenticate with a different role.

## Using an API Key

If you're running in a non-interactive environment where a browser-based login isn't possible (e.g., CI/CD pipelines, remote VMs, or automation agents), you can skip the OAuth flow by passing your API key as a bearer token. The MCP server recognizes the `Authorization` header and treats the request as already authenticated.

Generate an API key from the [Quicknode Dashboard](https://dashboard.quicknode.com/api-keys) under **Account (_avatar icon_) > API Keys**. The role you assign to the key (Admin or Viewer) determines the MCP server's permissions, the same as choosing a role during the OAuth flow.

  

**Claude**

#### Claude Code

Pass your API key as a bearer token using the `--header` flag:

```bash
claude mcp add quicknode --transport http https://mcp.quicknode.com/mcp --header "Authorization: Bearer YOUR_API_KEY"
```

#### Claude Desktop

Add the `--header` flag to the `mcp-remote` arguments in your `claude_desktop_config.json`:

```json
{

  "mcpServers": {

    "quicknode": {

      "command": "npx",

      "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp", "--header", "Authorization: Bearer YOUR_API_KEY"]

    }

  }

}
```

**OpenAI**

#### Codex

Pass your API key as a bearer token using the `--bearer-token-env-var` flag, which tells Codex to read the key from an environment variable at runtime:

```bash
codex mcp add quicknode \

  --url https://mcp.quicknode.com/mcp \

  --bearer-token-env-var YOUR_API_KEY
```

Run `codex mcp list` to confirm the server is registered.

**Cursor**

Add the following to your `.cursor/mcp.json`:

```json
{

  "mcpServers": {

    "quicknode": {

      "command": "npx",

      "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp", "--header", "Authorization: Bearer YOUR_API_KEY"]

    }

  }

}
```

**VS Code**

Add the `headers` field to your `.vscode/mcp.json`:

```json
{

  "mcp": {

    "servers": {

      "quicknode": {

        "type": "http",

        "url": "https://mcp.quicknode.com/mcp",

        "headers": {

          "Authorization": "Bearer YOUR_API_KEY"

        }

      }

    }

  }

}
```

**Windsurf**

Add the `headers` field to your `~/.codeium/windsurf/mcp_config.json`:

```json
{

  "mcpServers": {

    "quicknode": {

      "serverUrl": "https://mcp.quicknode.com/mcp",

      "headers": {

        "Authorization": "Bearer YOUR_API_KEY"

      }

    }

  }

}
```

**Zed**

Add the `headers` field to your `settings.json`:

```json
{

  "context_servers": {

    "quicknode": {

      "transport": "http",

      "url": "https://mcp.quicknode.com/mcp",

      "headers": {

        "Authorization": "Bearer YOUR_API_KEY"

      }

    }

  }

}
```

**Other Clients**

For any client that supports custom headers, set:

```text
Authorization: Bearer YOUR_API_KEY
```

If your client uses `mcp-remote`, add the `--header` flag:

```json
{

  "mcpServers": {

    "quicknode": {

      "command": "npx",

      "args": ["-y", "mcp-remote", "https://mcp.quicknode.com/mcp", "--header", "Authorization: Bearer YOUR_API_KEY"]

    }

  }

}
```

## Blockchain RPC Calls

The `call-rpc` tool reads live blockchain data. It sends a read-only JSON-RPC request through your account's **Tooling Access** setting, which covers every network Quicknode supports. You do not need to create an endpoint.

An Admin turns it on once with `enable-tooling-access`, or checks the current state with the [Admin API](/docs/admin-api/tooling-access/v0-tooling-access). The same setting powers `qn rpc call` in the [CLI](/docs/cli) and the `rpc` client in the [SDK](/docs/sdk), so enabling it covers all three.

One tool reaches every chain family. `eth_getBalance` on `base-mainnet`, `getSlot` on `solana-mainnet`, and `getblockcount` on `btc` all go through `call-rpc`, routed by network slug.

Calls are read-only. Write methods return an error instead of broadcasting:

```text
RPC method eth_sendRawTransaction is not allowed. Only registered read-only methods may be called.
```

To send transactions, create a dedicated endpoint with `create-endpoint` and call it from your own code.

  

Disabling Is Account-Wide

`disable-tooling-access` turns the setting off for the whole account. It cuts off RPC access for every Quicknode developer tool, including the CLI and the SDK, not just the assistant you are working in.

## Available Tools

The MCP server exposes the following tools. Tools marked as **read-only** are available to both **Admin** and **Viewer** roles. All other tools require the **Admin** role.

### Blockchain RPC

Read live blockchain data, and control the account setting that enables it. See [Blockchain RPC Calls](#blockchain-rpc-calls).

| Tool | Description | Access |
| --- | --- | --- |
| call-rpc | Call a read-only JSON-RPC method on any supported network | read-only |
| enable-tooling-access | Turn on Tooling Access for your account so Quicknode developer tools can make RPC calls | admin |
| disable-tooling-access | Turn off Tooling Access for the whole account | admin |

### Endpoint Management

Create, read, update, and delete Quicknode endpoints across any supported chain and network.

| Tool | Description | Access |
| --- | --- | --- |
| list-endpoints | List all endpoints on your account | read-only |
| get-endpoint | Get details for a specific endpoint | read-only |
| create-endpoint | Create a new endpoint on a specified chain and network | admin |
| delete-endpoint | Delete an endpoint | admin |
| get-endpoint-metrics | Retrieve performance metrics for an endpoint | read-only |
| list-endpoint-logs | Fetch recent logs for an endpoint | read-only |
| get-endpoint-log-details | Get detailed information for a specific log entry | read-only |

### Rate Limits

Configure method-level and endpoint-level rate limits.

| Tool | Description | Access |
| --- | --- | --- |
| update-endpoint-rate-limits | Set overall rate limits (RPS, RPM, RPD) for an endpoint | admin |
| list-endpoint-method-rate-limits | List method-specific rate limits | read-only |
| create-endpoint-method-rate-limit | Add a rate limit for a specific RPC method | admin |
| update-endpoint-method-rate-limit | Update an existing method rate limit | admin |
| delete-endpoint-method-rate-limit | Remove a method rate limit | admin |

### Security

Manage authentication and access control settings for endpoints. The `create-security-rule` and `delete-security-rule` tools support multiple rule types: IP allowlists, JWT validation, referrer restrictions, domain masks, and authentication tokens.

| Tool | Description | Access |
| --- | --- | --- |
| list-endpoint-security | View current security settings and rules | read-only |
| update-endpoint-security-options | Enable or disable security features (CORS, HSTS, IP filtering, etc.) | admin |
| create-security-rule | Add a security rule (IP, JWT, referrer, domain mask, or token) | admin |
| delete-security-rule | Remove a security rule | admin |

### Usage and Billing

Monitor RPC usage and review billing information.

| Tool | Description | Access |
| --- | --- | --- |
| get-rpc-usage | Get RPC usage with optional breakdown by endpoint, method, or chain | read-only |
| get-billing | View billing invoices or payment history | read-only |

### Chains

Query available chains and networks.

| Tool | Description | Access |
| --- | --- | --- |
| list-chains | List all supported chains and their available networks | read-only |

## MCP Resources

In addition to tools, the Quicknode MCP server exposes your endpoints as **MCP resources**. Resources let your AI assistant reference endpoint details directly in context without needing to call a tool first. In clients that support MCP resources, you can type `@quicknode` to browse and attach your endpoints to the conversation (e.g., `quicknode://endpoints/<endpoint-id>`).

This is useful when you want the assistant to have your endpoint configuration readily available while working on a task, such as writing code that targets a specific chain or debugging a request.

## Example Prompts

You do not need to reference tool names directly. The AI assistant maps natural language to the appropriate tool. Some examples:

**Live blockchain data:**

-   "What is the current block number on Base?"
-   "Get the balance of 5s3vajJvaAbabQvxFdiMfg14y23b2jvK6K2Mw4PYcYK on Solana mainnet"
-   "Read the latest block on Ethereum and on Arbitrum, then compare the timestamps"

**Endpoint management:**

-   "Create a new Base mainnet endpoint"
-   "Show me all my endpoints and their current status"

**Monitoring and debugging:**

-   "Check the logs for my Arbitrum endpoint from the last hour"
-   "Show me the performance metrics for my Ethereum endpoint over the past week"

**Security:**

-   "Add JWT authentication to my Ethereum mainnet endpoint"
-   "Review security settings across all endpoints"

**Usage and billing:**

-   "Show me my RPC usage broken down by chain for this month"
-   "Which endpoint is using the most credits this month?"

**Rate limiting:**

-   "Set a rate limit of 100 requests per second on my Polygon endpoint"
-   "Add a method-specific rate limit for eth_call"

  

tip

-   **Start simple** — Try asking "What endpoints do I have?" or "Show me my usage for this month" to get familiar with the available tools.
-   **Be specific** — When you have multiple endpoints, mention the chain or name to help the assistant find the right one quickly.

## How It Works

The MCP server is hosted remotely at `https://mcp.quicknode.com/mcp` and uses OAuth 2.1 for authentication. When your AI assistant receives a request, it calls the appropriate MCP tool. Account tools go to the Admin API, and `call-rpc` goes to Tooling Access. The assistant then formats the response and presents it in natural language.

  

-   **Account tools** send authenticated requests to the Quicknode [Admin API](/docs/admin-api). This covers endpoints, rate limits, security rules, logs, metrics, usage, and billing.
-   **`call-rpc`** sends the JSON-RPC request to your account's Tooling Access URL. The server mints a short-lived credential for the call, so there is no endpoint or long-lived credential in your configuration.

Write operations (creating endpoints, modifying security settings, deleting resources, changing the Tooling Access setting) require the **Admin** role and your explicit confirmation before the assistant executes them. If you connected with the **Viewer** role, the assistant can only perform read-only operations.

  

tip

Quicknode MCP reads live blockchain data and manages your account-level infrastructure. To help AI coding agents plan, build, and improve Web3 apps, with accurate knowledge of Quicknode's APIs and products when writing code, see the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin), which bundles this MCP server with the `build-web3` skill in a single install. For AI-optimized documentation discovery, see [LLM-Optimized Docs](/docs/build-with-ai/llms-txt).

## Resources

[

Quicknode Connector on Claude

Add Quicknode directly from the Anthropic MCP directory

→](https://claude.com/connectors/quicknode)[

Setup Guide

Read blockchain data and manage infrastructure with AI and MCP

→](https://www.quicknode.com/guides/ai/quicknode-mcp)[

Quicknode on ChatGPT

Install the Quicknode app directly from the ChatGPT Apps catalog

→](https://chatgpt.com/apps/quicknode/asdk_app_69ca79775c848191a5f1e538e77aedbb)[

Admin API Docs

Quicknode Admin API reference

→](/docs/admin-api)[

EVM MCP Server

Guide for using the EVM MCP server

→](https://www.quicknode.com/guides/ai/evm-mcp-server)[

Solana MCP Server

Guide for using the Solana MCP server

→](https://www.quicknode.com/guides/ai/solana-mcp-server)

---

---
title: x402 Payments
description: Access Quicknode's blockchain infrastructure with wallet-authenticated, pay-per-request stablecoin payments using the x402 protocol. No account or API keys required.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


x402 on Quicknode provides pay-per-request access to blockchain endpoints across all supported networks. Instead of creating an account and managing API keys, any application or AI agent with a wallet and a supported stablecoin can start making calls immediately.

[x402](https://x402.org/) is an open payment standard by Coinbase built on the HTTP 402 "Payment Required" status code. Client libraries handle the payment negotiation automatically.

x402 on Quicknode supports three access patterns:

  

-   **Pay-per-request**: No authentication required. Each request includes a payment signature handled automatically by the client.
-   **Credit drawdown**: Authenticate once with SIWX, purchase a credit bundle, and consume credits per request. Required for gRPC-Web and WebSocket transports.
-   **Nanopayment**: Batched payments via [Circle Gateway](https://developers.circle.com/gateway/nanopayments). The payment chain is limited to selected EVM testnets (Base Sepolia, Polygon Amoy, Arc Testnet).

Regardless of which payment model or payment chain you use, you can query any of Quicknode's [supported networks](https://www.quicknode.com/docs/platform/supported-chains-node-types#supported-chains--networks).

x402 is an additive access method. It does not replace Quicknode's standard plans. Teams running production workloads benefit from standard plans with SLAs, dedicated support, and higher rate limits. x402 is designed for AI agents, rapid prototyping, and use cases where permissionless access is the priority.

  

TL;DR

-   x402 can be used two ways: **one-shot RPC calls** with a funded wallet and no account (covered on this page), or paying for an [Agent Subscription](/docs/build-with-ai/agent-subscriptions) to create a Quicknode account and receive a full platform API key for the full product suite
-   Three one-shot access patterns: pay-per-request (self-contained per call), credit drawdown (SIWX auth + bundle, required for gRPC-Web and WebSocket), and nanopayment (Circle Gateway)
-   Install `@quicknode/x402`, which handles the full payment negotiation automatically; payment chain is independent of the RPC chain

info

x402 on Quicknode is currently in alpha.

```bash
# Fetch machine-readable x402 documentation for AI agents

curl https://x402.quicknode.com/llms.txt
```

## Quick Start

Install the `@quicknode/x402` package regardless of which payment model you choose, as the client supports all three patterns with configuration options.

```bash
npm install @quicknode/x402
```

**Pay-per-request**

### Pay-per-request

**Pay-per-request** requires no authentication or session state. Each request includes a payment signature handled automatically by the client.

```typescript
import { createQuicknodeX402Client } from '@quicknode/x402'



const client = await createQuicknodeX402Client({

	baseUrl: 'https://x402.quicknode.com',

	network: 'eip155:84532', // Base Sepolia (payment network)

	evmPrivateKey: process.env.PRIVATE_KEY as `0x${string}`,

	paymentModel: 'pay-per-request',

})



// The endpoint below is the chain you want to query (not the payment chain).

// You can call any Quicknode-supported network here regardless of which chain you pay on.

const response = await client.fetch('https://x402.quicknode.com/base-mainnet', {

	method: 'POST',

	headers: { 'Content-Type': 'application/json' },

	body: JSON.stringify({

		jsonrpc: '2.0',

		id: 1,

		method: 'eth_blockNumber',

		params: [],

	}),

})



const data = await response.json()

console.log('Block:', data.result)
```

**Credit Drawdown**

### Credit Drawdown

**Credit drawdown** authenticates once via SIWX to obtain a JWT, then purchases a credit bundle upfront. Credits are consumed per request. This is the only model that supports gRPC-Web and WebSocket transports.

```typescript
import { createQuicknodeX402Client } from '@quicknode/x402'



const client = await createQuicknodeX402Client({

	baseUrl: 'https://x402.quicknode.com',

	network: 'eip155:84532', // Base Sepolia (payment network)

	evmPrivateKey: process.env.PRIVATE_KEY as `0x${string}`,

	paymentModel: 'credit-drawdown', // default if omitted

	preAuth: true, // pre-authenticates (SIWX + JWT) before the first request

})



// The endpoint below is the chain you want to query (not the payment chain).

// You can call any Quicknode-supported network here regardless of which chain you pay on.

const response = await client.fetch('https://x402.quicknode.com/base-mainnet', {

	method: 'POST',

	headers: { 'Content-Type': 'application/json' },

	body: JSON.stringify({

		jsonrpc: '2.0',

		id: 1,

		method: 'eth_blockNumber',

		params: [],

	}),

})



const data = await response.json()

console.log('Block:', data.result)
```

**Nanopayment**

### Nanopayment

**Nanopayment** uses Circle's Gateway infrastructure to batch payments with no per-request on-chain settlement. It requires a one-time USDC deposit into the Gateway Wallet contract before making requests. After depositing, the Gateway API waits for a chain-specific number of block confirmations before updating your unified balance. See [Circle's supported blockchains reference](https://developers.circle.com/gateway/references/supported-blockchains#required-block-confirmations) for confirmation times per chain.

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



const client = await createQuicknodeX402Client({

  baseUrl: "https://x402.quicknode.com",

  network: "eip155:84532", // Base Sepolia (payment network; must be a nanopayment-eligible EVM testnet)

  evmPrivateKey: process.env.PRIVATE_KEY as `0x${string}`,

  paymentModel: "nanopayment",

});



// Check Gateway Wallet balance

if (client.gatewayClient) {

  const balances = await client.gatewayClient.getBalances();

  console.log("Gateway available:", balances.gateway.formattedAvailable);



  // 1 USDC = 1_000_000 base units (6 decimals)

  // If balance is low, deposit more USDC to avoid payment failures

  if (balances.gateway.available < 1_000_000n) {

    console.log("Depositing 1 USDC...");

    const deposit = await client.gatewayClient.deposit("1");

    console.log(`Deposit tx: ${deposit.depositTxHash}`);

  }

}



// $0.0001 per request, payments batched via Circle Gateway (no per-request auth)

// The endpoint below is the chain you want to query (not the payment chain).

// You can call any Quicknode-supported network here regardless of which chain you pay on.

const response = await client.fetch("https://x402.quicknode.com/base-mainnet", {

  method: "POST",

  headers: { "Content-Type": "application/json" },

  body: JSON.stringify({

    jsonrpc: "2.0",

    id: 1,

    method: "eth_blockNumber",

    params: [],

  }),

});



const data = await response.json();

console.log("Block:", data.result);
```

Building with Solana?

Use [`@quicknode/x402-solana`](https://github.com/quiknode-labs/x402-solana), a dedicated Solana Kit integration that creates x402-enabled RPC and WebSocket clients directly from your Solana keypair. No account or API key required, just a wallet with USDC. Check out the [How to Access Solana RPC with x402](https://www.quicknode.com/guides/solana-development/ai-agents/how-to-access-solana-rpc-with-x402-solana) guide for a full walkthrough.

```bash
npm install @quicknode/x402-solana
```

See the [examples repo](https://github.com/quiknode-labs/qn-x402-examples) for reference implementations.

## Supported Protocols

x402 endpoints support the same protocols as standard Quicknode endpoints. Protocol availability varies by payment model:

| Protocol | Pay-per-request | Credit Drawdown | Nanopayment |
| --- | --- | --- | --- |
| JSON-RPC | Yes | Yes | Yes |
| REST | Yes | Yes | Yes |
| gRPC-Web | No | Yes | No |
| WebSocket | No | Yes | No |

## Pricing

x402 on Quicknode supports three billing patterns:

|  | Pay-per-request | Credit Drawdown | Nanopayment |
| --- | --- | --- | --- |
| Cost | $0.001 per request | $10 per 1,000,000 credits (~$0.00001 per request) | $0.0001 per request |
| Settlement | One on-chain payment per request | Upfront credit purchase, consumed per response | Batched via Circle Gateway (gasless after initial USDC deposit) |
| Authentication | None | SIWX + JWT | None (Circle Gateway Wallet deposit required) |
| Free Tier | Shared 1M API credits / month bucket | Shared 1M API credits / month bucket | Shared 1M API credits / month bucket |
| Best for | Simple integrations, low volume | Sustained usage, streaming protocols | High-volume testing, sub-cent cost |

### Credit Consumption Rates

For the credit drawdown pattern, each successful response consumes credits based on the protocol used. When credits are depleted, the next request triggers an automatic payment for a new credit bundle.

| Protocol | Rate |
| --- | --- |
| JSON-RPC (HTTP) | 1 credit per successful (HTTP 200) response |
| REST (HTTP) | 1 credit per successful response |
| gRPC-Web | 1 credit upfront + 1 credit per 10 KB of response data |
| WebSocket | 1 credit upfront + 1 credit per response message |

Error responses, JSON-RPC errors, and non-200 HTTP status codes are not metered. Each wallet gets a single free tier of 1,000,000 API credits / month across Quicknode's agentic payment surfaces, including all x402 payment models and MPP. RPC requests consume 1 API credit each, while SQL Explorer consumes the API credits used by the query. The bucket resets on the first of the month, and paid usage continues at the applicable per-model rate after the free tier is exhausted.

## Supported Payment Networks

These are the chains you pay on. The chain you pay on does not need to match the chain you query.

| Payment Network | Token | Pay-per-request | Credit Drawdown | Nanopayment |
| --- | --- | --- | --- | --- |
| Base Sepolia | USDC | Yes | Yes | Yes |
| Base Mainnet | USDC | Yes | Yes | No |
| Polygon Amoy | USDC | Yes | Yes | Yes |
| Polygon Mainnet | USDC | Yes | Yes | No |
| XLayer Testnet | USDG | Yes | Yes | No |
| XLayer Mainnet | USDG | Yes | Yes | No |
| Arc Testnet | USDC | No | No | Yes |
| Solana Devnet | USDC | Yes | Yes | No |
| Solana Mainnet | USDC | Yes | Yes | No |

To get testnet tokens:

-   **Base Sepolia / Polygon Amoy / Arc Testnet:** Use the [Circle faucet](https://faucet.circle.com/) for USDC. Base Sepolia also has a built-in `/drip` endpoint on the x402 gateway.
-   **XLayer Testnet:** Pre-fund your wallet with USDG on XLayer Testnet.
-   **Solana Devnet:** Pre-fund your wallet with USDC on Solana Devnet via the [Circle faucet](https://faucet.circle.com/).

## Authentication

Authentication is required for **credit drawdown** only. Pay-per-request and nanopayment include the payment signature in each request and do not require a JWT.

For credit drawdown, the `/auth` endpoint accepts three authentication paths:

  

-   **SIWE (EVM only):** Post a signed EIP-4361 SIWE message. This is the original auth method and remains fully supported.
-   **SIWX/EVM:** Same SIWE message format with `"type": "siwx"` in the request body.
-   **SIWX/Solana:** A CAIP-122 / SIWS formatted message signed with Ed25519, encoded as Base58, with `"type": "siwx"`.

All paths require the following fields in the signed message:

-   `domain` (`x402.quicknode.com`)
-   `address` (your wallet address)
-   `uri` (`https://x402.quicknode.com`)
-   `version` (`1`)
-   `chainId` (the chain ID of the network you pay on)
-   `nonce` (at least 8 random characters)
-   `issuedAt` (current ISO 8601 timestamp, within 5 minutes).

The auth response returns a JWT that expires in 1 hour. Include `Authorization: Bearer <JWT>` on all subsequent requests.

## How It Works

The flow below describes the **credit drawdown** model. For pay-per-request and nanopayment, steps 1 and 2 are skipped; each request includes a payment signature directly with no prior authentication.

The `@quicknode/x402` client handles the full payment flow automatically. Under the hood, the credit drawdown flow follows this sequence:

  

1.  **Authenticate.** Sign a message with your wallet (SIWE for EVM, SIWX for Solana) and exchange it for a JWT token at the `/auth` endpoint.
2.  **Make requests.** Send requests to `POST /:network` with the JWT in the `Authorization: Bearer` header. Requests work across JSON-RPC, REST, gRPC-Web, and WebSocket protocols.
3.  **Pay when prompted.** When credits run out, the server returns HTTP 402. The client automatically signs a stablecoin payment and retries the request.
4.  **Repeat.** Credits are consumed per successful response. When exhausted, the next request triggers a new payment automatically.

## x402 vs Standard Quicknode Plans

|  | x402 | Standard Plans |
| --- | --- | --- |
| Authentication | None (SIWX + JWT only for credit drawdown) | API key |
| Billing | Per request (or credit bundle for drawdown) | [Monthly/Yearly subscription](https://www.quicknode.com/pricing) |
| Setup required | Wallet + stablecoin | Account + API key |
| Status | Alpha | Production SLA |
| Best for | Agents, prototyping, permissionless access | Teams, production workloads |

## Resources

[

Getting Started Guide

Step-by-step walkthrough for x402 on Quicknode

→](https://www.quicknode.com/guides/x402/access-quicknode-endpoints-with-x402-payments)[

Video Walkthrough

How to get started with x402 on Quicknode

→](https://www.youtube.com/watch?v=hDBiXRUme9M)[

Protocol Explainer

Deep dive on how x402 works

→](https://blog.quicknode.com/x402-protocol-explained-inside-the-https-native-payment-layer/)[

Example Implementations

End-to-end demonstrations of the x402 payment protocol

→](https://github.com/quiknode-labs/qn-x402-examples)[

Sample App

Explore x402 payments through a simple UI

→](https://www.quicknode.com/sample-app-library/x402-explorer)[

Protocol Specification

Open-source x402 protocol by Coinbase

→](https://github.com/coinbase/x402)

tip

For an alternative payment protocol, see [MPP Payments](/docs/build-with-ai/mpp-payments). For managing Quicknode infrastructure through natural language, see [Quicknode MCP](/docs/build-with-ai/quicknode-mcp). To help AI coding agents plan, build, and improve Web3 apps with accurate Quicknode product knowledge, see the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin).

---

---
title: 0G RPC
description: Get started with 0G RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# 0G RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [0G](https://www.quicknode.com/chains/0g) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=0g)

Beta

Beta

## What is 0G?

0G Chain is a cutting-edge, **AI-focused Layer 1 blockchain** designed for data-intensive applications. Built on a **modular architecture**, 0G separates consensus, execution, and storage, enabling flexible optimization of each component to deliver scalability for AI-driven workloads.

0G offers **full EVM compatibility** at the bytecode level, making it straightforward for Ethereum applications to migrate without changes. The network uses **CometBFT** (a Tendermint-based BFT consensus mechanism) to achieve fast finality, high throughput, and low latency. Security is ensured through a **decentralized validator set** and standard cryptographic guarantees.

Gas fees are paid in the **native 0G token**, and the chain supports Ethereum transaction formats, including **EIP-1559-style transactions**, ensuring a smooth developer and user experience.

## Interacting with 0G

0G nodes expose a JSON-RPC interface that offers extensive compatibility with Ethereum's API while adding 0G-specific functionality. This makes it straightforward to migrate most Ethereum applications with minimal changes.

With this API, you can:

-   Execute standard Ethereum JSON-RPC methods such as eth_call, eth_sendTransaction, and eth_getBalance
-   Use debug and trace methods (where enabled) for advanced blockchain analysis
-   Subscribe to real-time events via WebSocket connections
-   Access 0G-specific endpoints for querying modular components like consensus or data storage

You can access the API by:

-   Using a hosted provider such as a **Quicknode 0G endpoint**, which delivers low-latency global access, archive data, and enhanced reliability out of the box

## Supported Networks

Quicknode provides access to the following 0g networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✓ | Yes | None |
| Galileo Testnet | Testnet | ✓ | ✓ | Yes | None |

Complete reference for developers building on 0g with Quicknode:

-   [QuickStart](/docs/0g/quickstart): Get started with 0g quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/0g/endpoints): Learn how to configure and manage your 0g endpoints for optimal performance and reliability.
-   [API Overview](/docs/0g/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/0g/add-ons): Discover endpoint add-ons that extend your 0g development workflow.
-   [Endpoint Security](/docs/0g/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/0g/error-references): Understand common error codes and troubleshooting steps for 0g API requests.

---

---
title: Abstract RPC
description: Get started with Abstract RPC on Quicknode. Access reliable, low-latency infrastructure for Abstract with globally distributed endpoints for consumer-focused blockchain applications.
---

# Abstract RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Abstract](https://www.quicknode.com/chains/abstract) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=abstract)

## What is Abstract?

Abstract is a zero-knowledge rollup Layer 2 blockchain built on zkSync's ZK Stack technology, designed specifically for consumer crypto applications and onchain culture. Created by the team behind Pudgy Penguins, Abstract focuses on bringing mainstream users to Web3 through intuitive user experiences and consumer-focused applications.

Abstract combines the security of Ethereum with lower costs and faster transaction speeds, while offering native account abstraction through the Abstract Global Wallet (AGW). This enables users to interact with applications using familiar login methods like email and social accounts rather than traditional seed phrases.

## Interacting with Abstract

Abstract nodes expose a JSON-RPC interface that provides full compatibility with Ethereum's API while adding L2-specific functionality.

With this API, you can:

-   Execute all standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, eth_getBalance)
-   Debug utilities for deeper blockchain analysis and transaction inspection
-   zkSync compatible API methods for zero-knowledge rollups

You can access the API by:

-   Running a local Abstract client
-   Using a hosted provider such as a **Quicknode Abstract endpoint**, which delivers low-latency global access, archive data, and enhanced reliability out of the box.

## Supported Networks

Quicknode provides access to the following Abstract networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 2741 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 11124 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Abstract with Quicknode:

-   [QuickStart](/docs/abstract/quickstart): Get started with Abstract quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/abstract/endpoints): Learn how to configure and manage your Abstract endpoints for optimal performance and reliability.
-   [API Overview](/docs/abstract/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/abstract/add-ons): Discover endpoint add-ons that extend your Abstract development workflow.
-   [Endpoint Security](/docs/abstract/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/abstract/error-references): Understand common error codes and troubleshooting steps for Abstract API requests.

---

# Quicknode Add-ons

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


Add-ons extend Quicknode endpoints with additional APIs, RPC methods, and data
services. Enable an add-on from the [Quicknode dashboard](https://dashboard.quicknode.com/add-ons).

## Available add-ons

Linked chains have a chain-specific API reference. Unlinked chains are supported
but do not yet have a matching chain-specific reference page.

### [Risk Assessment API](https://dashboard.quicknode.com/add-ons/risk-assessment-api)

Automated AML/CFT compliance that integrates into workflows while protecting data
privacy and proactively detecting risk.

**Supported chains (16):** Arbitrum, Avalanche, Base, Bitcoin, Blast, BNB Smart
Chain, Doge, Ethereum, Litecoin, Optimistic Ethereum, Polygon, Solana, Stellar,
TON, TRON, and XRP Ledger.

### [GoldRush - Multichain Data APIs](https://dashboard.quicknode.com/add-ons/covalent-wallet-api)

Onchain data from more than 100 chains, built for humans and AI agents. Go from
prototype to production in minutes.

**Supported chains (29):** Arbitrum, [Arbitrum Nova](https://www.quicknode.com/docs/arbitrum-nova/goldrush-wallet-api/overview), Arc, [Avalanche](https://www.quicknode.com/docs/avalanche/goldrush-wallet-api/overview), [Base](https://www.quicknode.com/docs/base/goldrush-wallet-api/overview), Berachain, [Bitcoin](https://www.quicknode.com/docs/bitcoin/goldrush-wallet-api/overview), [Blast](https://www.quicknode.com/docs/blast/goldrush-wallet-api/overview), BNB Smart Chain, Celo, [Ethereum](https://www.quicknode.com/docs/ethereum/goldrush-wallet-api/overview), Fantom, Gnosis, Hyperliquid, Ink, Linea, Mantle, Monad, Optimistic Ethereum, Plasma, Polygon, Polygon zkEVM, Scroll, Sei, Solana, Sonic, Unichain, World Chain, and zkSync.

### [Address Risk Scores API](https://dashboard.quicknode.com/add-ons/address-risk-scores)

Quickly assess wallet risk levels with comprehensive onchain data and entity
insights.

**Supported chains (16):** Arbitrum, Avalanche, Base, Bitcoin, Bitcoin Cash, BNB
Smart Chain, Doge, Ethereum, Litecoin, Optimistic Ethereum, Polygon, Solana, Sui,
TON, TRON, and zkSync.

### [Solana Priority Fee API](https://dashboard.quicknode.com/add-ons/solana-priority-fee)

Estimate Solana fees in real time with priority-fee averages based on recent fee
data.

**Supported chain (1):** [Solana](https://www.quicknode.com/docs/solana/qn_estimatePriorityFees).

### [Multi-Chain Stablecoin Balance API](https://dashboard.quicknode.com/add-ons/multi-chain-stablecoin-balance-api)

Query stablecoin holdings for individual wallets across more than 10 blockchain
networks with a single API call.

**Supported chains (10):** Arbitrum, Avalanche, Base, Blast, BNB Smart Chain,
[Ethereum](https://www.quicknode.com/docs/ethereum/multi-chain-stablecoin-balance-api/overview), Optimistic Ethereum, Polygon, Solana, and TRON.

### [Block Timestamp Lookup](https://dashboard.quicknode.com/add-ons/block-timestamp-lookup)

Retrieve blocks by timestamp or timestamp range, simplifying blockchain data
tracking and analysis.

**Supported chains (9):** Avalanche, [Base](https://www.quicknode.com/docs/base/qn_getBlockFromTimestamp), [Bitcoin](https://www.quicknode.com/docs/bitcoin/qn_getBlockFromTimestamp), BNB Smart Chain, [Ethereum](https://www.quicknode.com/docs/ethereum/qn_getBlockFromTimestamp), Mantle, Tempo, TRON, and X Layer.

### [Lil' Jit - Jito Bundles & Transactions](https://dashboard.quicknode.com/add-ons/lil-jit-jito-bundles-and-transactions)

Use a bundle of RPC methods for interacting with Jito through an existing
Quicknode endpoint.

**Supported chain (1):** [Solana](https://www.quicknode.com/docs/solana/getBundleStatuses).

### [Single Flight RPC](https://dashboard.quicknode.com/add-ons/single-flight-rpc)

Bundle multiple RPC calls into a single call instead of iterating through blocks,
transactions, or receipts.

**Supported chains (19):** 0g, [Arbitrum](https://www.quicknode.com/docs/arbitrum/qn_getBlockWithReceipts), [Arbitrum Nova](https://www.quicknode.com/docs/arbitrum-nova/qn_getBlockWithReceipts), [Avalanche](https://www.quicknode.com/docs/avalanche/qn_getBlockWithReceipts), [Base](https://www.quicknode.com/docs/base/qn_getBlockWithReceipts), Berachain, [Blast](https://www.quicknode.com/docs/blast/qn_getBlockWithReceipts), [BNB Smart Chain](https://www.quicknode.com/docs/bnb-smart-chain/qn_getBlockWithReceipts), [Celo](https://www.quicknode.com/docs/celo/qn_getBlockWithReceipts), [Ethereum](https://www.quicknode.com/docs/ethereum/qn_getBlockWithReceipts), [Fantom](https://www.quicknode.com/docs/fantom/qn_getBlockWithReceipts), [Gnosis](https://www.quicknode.com/docs/gnosis/qn_getBlockWithReceipts), Monad, [Optimistic Ethereum](https://www.quicknode.com/docs/optimism/qn_getBlockWithReceipts), [Polygon](https://www.quicknode.com/docs/polygon/qn_getBlockWithReceipts), Polygon zkEVM, Scroll, TRON, and zkSync.

### [Multi-Region Transaction Broadcast](https://dashboard.quicknode.com/add-ons/multi-region-transaction-broadcast)

Send a transaction to multiple regions in a single call. Each call uses 70 API
credits.

**Supported chains (7):** [Avalanche](https://www.quicknode.com/docs/avalanche/eth_sendRawTransaction), Berachain, BNB Smart Chain, [Ethereum](https://www.quicknode.com/docs/ethereum/eth_sendRawTransaction), [Fantom](https://www.quicknode.com/docs/fantom/eth_sendRawTransaction), Gnosis, and [Polygon](https://www.quicknode.com/docs/polygon/eth_sendRawTransaction).

---

---
title: Admin API
description: Getting Started with the Admin API
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


The **Quicknode Admin API** allows users to perform all actions available in the [User Dashboard](https://dashboard.quicknode.com/) programmatically via REST API. These actions include:

  

1.  Creating, managing, and deleting endpoints
2.  Retrieving metrics and billing information
3.  Managing and rotating API keys
4.  Configuring security features (e.g., whitelisting, JWT authentication, and more)

## API Specifications (OpenAPI)

Download the machine-readable API specifications for use with compatible tooling (e.g. [Swagger Editor](https://editor.swagger.io/)).

  

-   [Admin API (OpenAPI)](/docs/openapi/admin-api.openapi.json)

## Access

The Admin API is available to accounts subscribed to paid plans.

## Authentication

To use the Admin API, you must authenticate your requests by including an API key in the HTTP headers. Follow these steps:

1.  Generate an API key from your [Quicknode dashboard](https://dashboard.quicknode.com/api-keys).
2.  Include the API key in the `x-api-key` header of your HTTP request. For example:

```bash
x-api-key: your-api-key-here
```

Here's an example of how to request usage data using the Admin API with cURL:

```bash
curl -X GET 'https://api.quicknode.com/v0/usage/rpc' \

     -H 'accept: application/json' \

     -H 'x-api-key: YOUR_API_KEY_HERE'
```

## Prometheus Exporter (Enterprise Exclusive)

Enterprise customers now have access to a dedicated endpoint— **`Prometheus (/exporter/prometheus)`** — for deeper insights into their API usage. This endpoint provides real-time metrics that can be seamlessly integrated into internal dashboards. It offers the same data as the [metrics dashboard](https://dashboard.quicknode.com/endpoints/%7Bendpoint_id%7D/metrics), updated at intervals defined by Quicknode, and are compatible with any Prometheus scraper. This enables easy monitoring and tracking of usage metrics with accuracy.

  

Note

Please note that this endpoint is currently available only for Enterprise customers. For more information or inquiries about accessing these endpoints, feel free to [contact us](https://www.quicknode.com/contact-us).

## Making Admin REST API Requests

In this documentation, you will see example requests made with cURL and various programming languages for each supported Admin API method. This section will explain how to execute it on your machine.

### cURL

Most \*nix based systems have cURL support out of the box. cURL is a command line tool and library for transferring data with URLs. Check if you have it by running the following:

```text
curl -h
```

### CLI

To run CLI examples, install the `qn` command line tool:

```bash
brew install quicknode/tap/qn
```

Check if you have it by running the following:

```bash
qn --version
```

Then authenticate with an Admin API key from your [Quicknode dashboard](https://dashboard.quicknode.com/api-keys):

```bash
qn auth login
```

You can also provide the API key directly:

```bash
qn auth login --api-key YOUR_API_KEY_HERE
```

For other installation methods, output formats, and configuration options, see the [CLI documentation](/docs/cli).

### Python

To run our Python code examples, you'll need to have Python installed as well as the requests package. You can install this package with the following command:

```python
python -m pip install requests
```

### JavaScript

To run our JavaScript code examples, you'll need to have Node v18 and up installed. You can follow this [official document](https://nodejs.org/en/download/) to install the latest, stable version of Node globally. Check if you have it by running the following:

```js
node -v
```

### Ruby

To run our Ruby code examples, you'll need to have Ruby installed. You can follow this [official installation document](https://www.ruby-lang.org/en/documentation/installation/) for more information. Check if you have it by running the following:

```text
ruby -v
```

### SDK

To run SDK examples, install the SDK package for your preferred language, create an API key in the [Quicknode dashboard](https://dashboard.quicknode.com/api-keys), and set it in your environment:

```bash
export QN_SDK__API_KEY="YOUR_API_KEY"
```

Install the Node.js SDK package:

```bash
npm install @quicknode/sdk
```

Then initialize the SDK and make an Admin API request:

```js
import { QuicknodeSdk } from "@quicknode/sdk";



const qn = QuicknodeSdk.fromEnv();

const response = await qn.admin.getEndpoints({ limit: 20 });



console.log(response.data);
```

For other languages and setup options, see the [SDK Quick Start](/docs/sdk/quick-start).

---

---
title: Aleo REST API
description: Get started with Aleo REST API on Quicknode. Access reliable, low-latency infrastructure for the Aleo blockchain with globally distributed endpoints for privacy-focused applications.
---

# Aleo REST API

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Aleo REST API](https://www.quicknode.com/chains/aleo) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=aleo)

## What is Aleo?

Aleo is a Layer 1 blockchain that enables privacy-preserving applications through zero-knowledge cryptography. Programs execute on snarkVM, a zero-knowledge virtual machine developed by Provable, and can be written in Leo — a high-level language that compiles to Aleo instructions. Unlike traditional blockchains where all transaction data is publicly visible, Aleo uses zkSNARKs (specifically Varuna) to verify computations without revealing the underlying inputs, while still supporting public state where needed.

Aleo combines general-purpose programmability with default-private state, allowing applications to process sensitive data while remaining verifiable on-chain. The network is secured by AleoBFT, a DAG-based Byzantine Fault Tolerant proof-of-stake consensus, and uses a coinbase puzzle to incentivize a decentralized network of provers.

## Interacting with Aleo

Aleo nodes expose a REST API interface that allows developers to interact with the blockchain using standard HTTP methods. This makes it easy to integrate Aleo functionality into web applications and services using familiar tools and libraries.

With this API, you can:

-   Query block data, heights, hashes, and transaction details
-   Look up validator committee information and delegator data
-   Inspect deployed programs and query mapping values
-   Retrieve state roots and state paths for verification
-   Find transactions and transitions by various identifiers
-   Broadcast transactions and prover solutions

You can access the API by:

-   Running a local Aleo client
-   Using a hosted provider such as a **Quicknode Aleo endpoint**, which delivers low-latency global access and enhanced reliability out of the box.

## Supported Networks

Quicknode provides access to the following Aleo networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | No | None |
| Testnet | Testnet | ✓ | ✗ | No | None |

Complete reference for developers building on Aleo with Quicknode:

-   [QuickStart](/docs/aleo/quickstart): Get started with Aleo quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/aleo/endpoints): Learn how to configure and manage your Aleo endpoints for optimal performance and reliability.
-   [API Overview](/docs/aleo/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/aleo/add-ons): Discover endpoint add-ons that extend your Aleo development workflow.
-   [Endpoint Security](/docs/aleo/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/aleo/error-references): Understand common error codes and troubleshooting steps for Aleo API requests.

---

---
title: Aptos REST API
description: Get started with Aptos REST API on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Aptos REST API

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Aptos REST API](https://www.quicknode.com/chains/aptos) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=aptos)

## Aptos Overview

Aptos is a Layer 1 blockchain built to support the widespread adoption of blockchain through better technology and user experience. It introduces a novel smart contract programming language called Move, designed to be safe, flexible, and expressive. Aptos leverages a parallel execution engine (Block-STM) to achieve high throughput and low latency, making it ideal for decentralized applications that require fast transaction processing.

The network features AptosBFT, a consensus protocol derived from HotStuff, which provides strong safety guarantees while maintaining high performance. Aptos also supports on-chain governance, enabling protocol upgrades and network evolution while preserving decentralization.

## Interacting with Aptos's APIs

Aptos nodes expose a REST API interface that allows developers to interact with the blockchain using standard HTTP methods. This makes it easy to integrate Aptos functionality into web applications and mobile apps using familiar tools and libraries.

However, due to Aptos's unique architecture and the Move programming language, some API behaviors may differ from other blockchains. The Quicknode Aptos documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official Aptos documentation](https://aptos.dev/) for the latest updates and API differences.

## Make Aptos API Calls

The quickest way to start building on Aptos is to create a Quicknode endpoint and send your first REST API request.

Quicknode provides managed Aptos endpoints, giving you immediate access to the Aptos network without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/aptos/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Aptos networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | Yes | None |
| Testnet | Testnet | ✓ | ✗ | Yes | None |

Complete reference for developers building on Aptos with Quicknode:

-   [QuickStart](/docs/aptos/quickstart): Get started with Aptos quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/aptos/endpoints): Learn how to configure and manage your Aptos endpoints for optimal performance and reliability.
-   [API Overview](/docs/aptos/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/aptos/add-ons): Discover endpoint add-ons that extend your Aptos development workflow.
-   [Endpoint Security](/docs/aptos/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/aptos/error-references): Understand common error codes and troubleshooting steps for Aptos API requests.

---

---
title: Arbitrum RPC
description: Get started with Arbitrum RPC on Quicknode. Access reliable, low-latency Layer 2 infrastructure with globally distributed endpoints for fast, cost-effective Ethereum scaling.
---

# Arbitrum RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Arbitrum](https://www.quicknode.com/chains/arb) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=arbitrum)

## What is Arbitrum?

Arbitrum is a Layer 2 scaling solution for Ethereum that uses **optimistic rollup technology** to reduce transaction costs and increase throughput while maintaining Ethereum's security. Built by Offchain Labs, Arbitrum processes transactions off-chain and submits compressed batches to Ethereum mainnet, achieving up to 90% lower gas fees and faster confirmation times.

Arbitrum operates using an **optimistic execution model**. It assumes transactions are valid by default but includes a **7-day challenge period** where validators can dispute fraudulent transactions through an interactive fraud-proof system. This design allows Arbitrum to inherit Ethereum's security guarantees while providing a fully **EVM-compatible environment** where existing Solidity smart contracts and dApps can deploy without modification.

The network uses **ArbOS**, a custom operating system that manages the execution environment and handles cross-chain messaging through its **retryable tickets** system, enabling communication between L1 and L2.

## Interacting with Arbitrum

The Arbitrum JSON-RPC API extends the standard Ethereum JSON-RPC interface with Layer 2-specific functionality. Since Arbitrum maintains **byte-level EVM compatibility**, developers can use familiar tools like Ethers.js and Foundry without modification.

With this API, you can:

-   Execute all standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, etc.)
-   Access Arbitrum-specific methods for L2 operations (arbtrace_block, arbtrace_replayTransaction)
-   Subscribe to real-time events via WebSocket connections

You can access the API by:

-   Running a local Arbitrum node (Nitro client)
-   Using a hosted provider such as a **Quicknode Arbitrum endpoint**, which provides instant access to both Arbitrum One and Arbitrum Nova networks with built-in reliability and archive data support

## Supported Networks

Quicknode provides access to the following Arbitrum networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 42161 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 421614 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Arbitrum with Quicknode:

-   [QuickStart](/docs/arbitrum/quickstart): Get started with Arbitrum quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/arbitrum/endpoints): Learn how to configure and manage your Arbitrum endpoints for optimal performance and reliability.
-   [API Overview](/docs/arbitrum/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/arbitrum/add-ons): Discover endpoint add-ons that extend your Arbitrum development workflow.
-   [Endpoint Security](/docs/arbitrum/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/arbitrum/error-references): Understand common error codes and troubleshooting steps for Arbitrum API requests.

---

---
title: Arbitrum Nova RPC
description: Get started with Arbitrum Nova RPC on Quicknode. Access reliable, low-latency infrastructure for Arbitrum Nova with globally distributed endpoints for low-cost applications.
---

# Arbitrum Nova RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Arbitrum Nova](https://www.quicknode.com/chains/nova) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=arbitrum-nova)

## What is Arbitrum Nova?

Arbitrum Nova is an AnyTrust Chain operated by the Arbitrum Foundation, designed for applications that require low transaction costs and high throughput. Unlike Arbitrum One which uses traditional optimistic rollup technology, Nova uses AnyTrust technology that relies on a Data Availability Committee (DAC) to store transaction data off-chain while maintaining security guarantees.

Nova chains are owned by the Arbitrum Governance system, ensuring decentralized control and community-driven development. This approach enables lower costs than traditional rollups, making Nova ideal for gaming, social applications, and high-frequency use cases where transaction fees need to be minimal.

## Interacting with Arbitrum Nova

The Arbitrum Nova JSON-RPC API is fully compatible with Ethereum's API, enabling developers to use existing Ethereum tools and libraries without modification. Nova supports all standard Ethereum JSON-RPC methods plus Arbitrum-specific functionality for Layer 2 operations and cross-chain messaging.

Since Nova is EVM-equivalent like Arbitrum One, developers can use familiar tools such as MetaMask, Hardhat, and Ethers.js while benefiting from the low costs provided by AnyTrust technology.

## Supported Networks

Quicknode provides access to the following Arbitrum Nova networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 42170 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Arbitrum Nova with Quicknode:

-   [QuickStart](/docs/arbitrum-nova/quickstart): Get started with Arbitrum Nova quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/arbitrum-nova/endpoints): Learn how to configure and manage your Arbitrum Nova endpoints for optimal performance and reliability.
-   [API Overview](/docs/arbitrum-nova/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/arbitrum-nova/add-ons): Discover endpoint add-ons that extend your Arbitrum Nova development workflow.
-   [Endpoint Security](/docs/arbitrum-nova/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/arbitrum-nova/error-references): Understand common error codes and troubleshooting steps for Arbitrum Nova API requests.

---

---
title: Arc RPC
description: Get started with Arc RPC on Quicknode. Access reliable, low-latency infrastructure for Arc with globally distributed endpoints.
---

# Arc RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Arc](https://www.quicknode.com/chains/arc) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=arc)

Beta

Beta

## Arc Overview

Arc is an open Layer 1 blockchain built by Circle for stablecoin finance. It uses USDC as its native gas token, removing volatility from transaction fees and enabling predictable, dollar-based costs. Powered by Malachite, its consensus engine provides instant finality and sub-second settlement. Arc includes a built-in FX engine for on-chain currency exchange, supports EVM compatibility, and offers opt-in privacy for compliant financial operations—all fully integrated with Circle’s ecosystem tools like CCTP and Paymaster.

## Interacting with Arc

Arc exposes a standard Ethereum JSON-RPC interface, allowing developers to interact with the network using familiar Ethereum tools and libraries. You can query balances, transactions, and contract state; send transactions; and deploy or interact with smart contracts directly.

Because Arc is an EVM-compatible Layer 1 optimized for stablecoin finance, most Ethereum JSON-RPC methods are supported, though certain endpoints or behaviors may differ. For the latest API details, refer to [Circle’s official Arc developer documentation](https://www.arc.network/).

## Make Arc API Calls

The quickest way to start building on Arc is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed Arc endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Archive data — full historical state for in-depth queries
-   Enhanced performance — optimized latency and request handling for production-grade apps

> Visit the [QuickStart](/docs/arc/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Arc networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Testnet | Testnet | 5042002 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Arc with Quicknode:

-   [QuickStart](/docs/arc/quickstart): Get started with Arc quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/arc/endpoints): Learn how to configure and manage your Arc endpoints for optimal performance and reliability.
-   [API Overview](/docs/arc/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/arc/add-ons): Discover endpoint add-ons that extend your Arc development workflow.
-   [Endpoint Security](/docs/arc/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/arc/error-references): Understand common error codes and troubleshooting steps for Arc API requests.

---

---
title: Ault RPC
description: Get started with Ault RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Ault RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Ault](https://www.quicknode.com/chains/ault) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=ault)

Beta

Beta

## What is Ault?

Ault is a blockchain platform designed for tokenized market access and on-chain financial applications. It is built on the Cosmos SDK and uses CometBFT proof-of-stake consensus to provide fast transaction finality and deterministic execution. The network offers full EVM compatibility, enabling developers to deploy Solidity smart contracts and use standard Ethereum tooling while operating within a Cosmos-based architecture.

In addition to EVM support, Ault also supports CosmWasm smart contracts written in Rust, allowing developers to build interoperable applications across the Cosmos ecosystem. The protocol implements an EIP-1559-style fee market for gas pricing and fee management. Financial functionality such as trading and lending is provided through on-chain applications and protocols deployed on the network, rather than as base-layer features. Governance and network operation are organized under a Wyoming DAO LLC structure, with participation by licensed node operators.

## Interacting With Ault's APIs

Ault nodes expose multiple API interfaces to support different development workflows:

-   **Ethereum JSON-RPC API**: Fully compatible with Ethereum's JSON-RPC interface, allowing developers to use familiar tools like Foundry, Hardhat, ethers.js, viem, and web3.py without modification.
-   **Tendermint RPC API**: Native Cosmos SDK interface for querying blockchain data, blocks, transactions, and network information.
-   **Cosmos REST/gRPC API**: RESTful and gRPC endpoints for interacting with Cosmos modules, including bank, staking, governance, and custom application logic.

However, due to Ault's architectural differences from standard Ethereum chains, some RPC methods may behave differently. The Quicknode Ault documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official Ault documentation](https://aultblockchain.com) for the latest updates and RPC differences.

## Make Ault API Calls

The quickest way to start building on Ault is to create a Quicknode endpoint and send your first request.

Quicknode provides managed Ault endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Archive data — full historical state for in-depth queries
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/ault/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the Ault network listed below:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 904 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 10904 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Ault with Quicknode:

-   [QuickStart](/docs/ault/quickstart): Get started with Ault quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/ault/endpoints): Learn how to configure and manage your Ault endpoints for optimal performance and reliability.
-   [API Overview](/docs/ault/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/ault/add-ons): Discover endpoint add-ons that extend your Ault development workflow.
-   [Endpoint Security](/docs/ault/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/ault/error-references): Understand common error codes and troubleshooting steps for Ault API requests.

---

---
title: Avalanche RPC
description: Get started with Avalanche RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Avalanche RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Avalanche](https://www.quicknode.com/chains/avalanche) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=avalanche)

## Avalanche Overview

Avalanche is a Layer 1 blockchain platform designed for high throughput and low latency. It uses a multi-chain architecture consisting of three built-in blockchains:

-   **Exchange Chain (X-Chain)**: for creating and transferring digital assets
-   **Platform Chain (P-Chain)**: for coordinating validators and managing subnets
-   **Contract Chain (C-Chain)**: fully compatible with Ethereum's EVM for smart contracts

Avalanche employs two consensus protocols: Avalanche consensus for the DAG-based X-Chain and Snowman consensus for linear chains such as the C-Chain and P-Chain. Together, these enable the network to typically finalize transactions in under 1 second while maintaining security and decentralization.

The platform also supports subnets, custom blockchain networks where developers can define their own validator sets, virtual machines, and tokenomics, enabling application-specific blockchains to scale efficiently.

## Interacting with Avalanche's APIs

Avalanche nodes expose multiple JSON-RPC interfaces for each chain. The C-Chain is compatible with Ethereum's JSON-RPC API, meaning developers can use Ethereum's native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification. The P-Chain and X-Chain have their own specific APIs for platform and asset management operations.

However, due to Avalanche's architectural differences, some RPC methods may behave differently from those on Ethereum. The Quicknode Avalanche documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official Avalanche documentation](https://build.avax.network/docs/api-reference/c-chain/api) for the latest updates and RPC differences.

## Make Avalanche API Calls

The quickest way to start building on Avalanche is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed Avalanche endpoints, giving you immediate access to the Avalanche Mainnet and Fuji Testnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/avalanche/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Avalanche networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 43114 | ✓ | ✓ | Yes | None |
| Fuji Testnet | Testnet | 43113 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Avalanche with Quicknode:

-   [QuickStart](/docs/avalanche/quickstart): Get started with Avalanche quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/avalanche/endpoints): Learn how to configure and manage your Avalanche endpoints for optimal performance and reliability.
-   [API Overview](/docs/avalanche/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/avalanche/add-ons): Discover endpoint add-ons that extend your Avalanche development workflow.
-   [Endpoint Security](/docs/avalanche/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/avalanche/error-references): Understand common error codes and troubleshooting steps for Avalanche API requests.

---

---
title: B3 RPC
description: Get started with B3 RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# B3 RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [B3](https://www.quicknode.com/chains/b3) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=b3)

## B3 Overview

B3 is a Layer 2 scaling solution for Ethereum, built on the OP Stack—the same technology that powers Optimism. It uses optimistic rollups to execute transactions off-chain while posting compressed transaction data to Ethereum for settlement security. B3 maintains bytecode-level EVM equivalence, ensuring full compatibility with existing Ethereum applications. Transactions are ordered by sequencers for low-latency block production, while Ethereum ensures security through a fraud-proof challenge period.

B3 is designed for high-performance blockchain infrastructure, delivering fast transaction throughput and low fees. This makes it well-suited for decentralized applications that demand efficient and cost-effective execution.

## Interacting with B3's APIs

B3 nodes expose a JSON-RPC interface that is compatible with Ethereum's JSON-RPC API. This means developers can use Ethereum's native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification.

However, due to B3's architectural differences, some RPC methods may behave differently from those on Ethereum. The Quicknode B3 documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official B3 documentation](https://docs.b3.fun/) for the latest updates and RPC differences.

## Make B3 API Calls

The quickest way to start building on B3 is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed B3 endpoints, giving you immediate access to the B3 Mainnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/b3/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following B3 networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 8333 | ✓ | ✓ | No | 128 blocks of state history |
| Sepolia | Testnet | 1993 | ✓ | ✓ | No | 128 blocks of state history |

Complete reference for developers building on B3 with Quicknode:

-   [QuickStart](/docs/b3/quickstart): Get started with B3 quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/b3/endpoints): Learn how to configure and manage your B3 endpoints for optimal performance and reliability.
-   [API Overview](/docs/b3/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/b3/add-ons): Discover endpoint add-ons that extend your B3 development workflow.
-   [Endpoint Security](/docs/b3/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/b3/error-references): Understand common error codes and troubleshooting steps for B3 API requests.

---

---
title: Base RPC
description: Get started with Base RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Base RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Base](https://www.quicknode.com/chains/base) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=base)

## What is Base?

Base is a Layer 2 scaling solution for Ethereum built by Coinbase using the **OP Stack**, the same technology powering Optimism. Base uses **optimistic rollup technology** to process transactions off-chain while posting compressed data to Ethereum mainnet for security.

Base implements **EVM equivalence** at the bytecode level through the Optimism Virtual Machine. The network uses **sequencers** to order transactions and achieve fast block times. Base inherits Ethereum's security through a **fraud proof window** during which invalid state transitions can be challenged. The network uses **ETH for gas fees** and supports all Ethereum transaction types including EIP-1559.

## Interacting with Base

Base nodes expose a JSON-RPC interface that provides full compatibility with Ethereum's API while adding L2-specific functionality. The **Base JSON-RPC API** enables seamless migration of Ethereum applications.

With this API, you can:

-   Execute all standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, eth_getBalance)
-   Access L2-specific methods for gas estimation and rollup operations
-   Access Flashblocks API
-   Subscribe to real-time events via WebSocket connections

You can access the API by:

-   Using a hosted provider such as a **Quicknode Base endpoint**, which delivers low-latency global access, archive data, and enhanced reliability out of the box

## Supported Networks

Quicknode provides access to the following Base networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 8453 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 84532 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Base with Quicknode:

-   [QuickStart](/docs/base/quickstart): Get started with Base quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/base/endpoints): Learn how to configure and manage your Base endpoints for optimal performance and reliability.
-   [API Overview](/docs/base/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/base/add-ons): Discover endpoint add-ons that extend your Base development workflow.
-   [Endpoint Security](/docs/base/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/base/error-references): Understand common error codes and troubleshooting steps for Base API requests.

---

---
title: Berachain RPC
description: Get started with Berachain RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Berachain RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Berachain](https://www.quicknode.com/chains/berachain) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=berachain)

## Berachain Overview

Berachain is a Layer 1 blockchain built on the Cosmos SDK and designed with a unique Proof-of-Liquidity consensus mechanism. Unlike traditional Proof-of-Stake systems, Berachain's validators are selected based on their contributions to decentralized finance (DeFi) protocols, aligning network security with DeFi participation. Berachain maintains full EVM compatibility, enabling seamless migration of Ethereum applications.

The network features three native tokens: BGT (governance token), BERA (gas token), and HONEY (overcollateralized stablecoin), creating an innovative economic model that incentivizes active participation in the DeFi ecosystem while maintaining network security.

## Interacting with Berachain's APIs

Berachain nodes expose a JSON-RPC interface that is compatible with Ethereum's JSON-RPC API. This means developers can use Ethereum's native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification.

However, due to Berachain's architectural differences, some RPC methods may behave differently from those on Ethereum. The Quicknode Berachain documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official Berachain documentation](https://docs.berachain.com/learn/) for the latest updates and RPC differences.

## Make Berachain API Calls

The quickest way to start building on Berachain is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed Berachain endpoints, giving you immediate access to the Berachain Testnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/berachain/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Berachain networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 80084 | ✓ | ✓ | Yes | None |
| Bepolia Testnet | Testnet | 80069 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Berachain with Quicknode:

-   [QuickStart](/docs/berachain/quickstart): Get started with Berachain quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/berachain/endpoints): Learn how to configure and manage your Berachain endpoints for optimal performance and reliability.
-   [API Overview](/docs/berachain/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/berachain/add-ons): Discover endpoint add-ons that extend your Berachain development workflow.
-   [Endpoint Security](/docs/berachain/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/berachain/error-references): Understand common error codes and troubleshooting steps for Berachain API requests.

---

---
title: Bitcoin RPC
description: Get started with Bitcoin RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for Bitcoin development and integration.
---

# Bitcoin RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Bitcoin](https://www.quicknode.com/chains/bitcoin) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=bitcoin)

## Bitcoin Overview

Bitcoin is the world's first and most established cryptocurrency, operating as a decentralized peer-to-peer electronic cash system. Built on a proof-of-work consensus mechanism, Bitcoin provides:

  

-   **Digital Scarcity**: A fixed supply of 21 million coins with predictable issuance
-   **Decentralized Network**: Nodes worldwide maintaining network security
-   **Immutable Ledger**: Cryptographically secured transaction history
-   **Global Settlement**: 24/7 borderless value transfer without intermediaries

Bitcoin's architecture prioritizes security and decentralization, making it the foundation for digital value storage and transfer. The network processes transactions through miners who compete to solve cryptographic puzzles, securing the blockchain and earning Bitcoin rewards.

## Interacting with Bitcoin's APIs

Bitcoin Core provides a comprehensive JSON-RPC API that enables developers to interact with the Bitcoin network programmatically. The API supports operations including transaction management, blockchain queries, and network monitoring.

Bitcoin's RPC interface follows standard JSON-RPC 2.0 protocols, making it compatible with most programming languages and development frameworks. However, Bitcoin's UTXO model differs significantly from account-based blockchains, requiring developers to understand transaction inputs and outputs.

## Make Bitcoin API Calls

The quickest way to start building on Bitcoin is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Bitcoin endpoints, giving you immediate access to Bitcoin Mainnet and Testnet without the complexity of running your own Bitcoin node. These endpoints offer:

-   **High reliability** – globally distributed infrastructure with 99.9% uptime SLA
-   **Enhanced performance** – optimized for low latency with advanced caching layers
-   **Enterprise features** – advanced analytics, debugging tools, and dedicated support

> Visit the [QuickStart](/docs/bitcoin/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Bitcoin networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | No | Pruning disabled |
| Testnet4 | Testnet | ✓ | ✗ | No | Pruning disabled |

Complete reference for developers building on Bitcoin with Quicknode:

-   [QuickStart](/docs/bitcoin/quickstart): Get started with Bitcoin quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/bitcoin/endpoints): Learn how to configure and manage your Bitcoin endpoints for optimal performance and reliability.
-   [API Overview](/docs/bitcoin/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/bitcoin/add-ons): Discover endpoint add-ons that extend your Bitcoin development workflow.
-   [Endpoint Security](/docs/bitcoin/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/bitcoin/error-references): Understand common error codes and troubleshooting steps for Bitcoin API requests.

---

---
title: Bitcoin Cash RPC
description: Get started with Bitcoin Cash RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Bitcoin Cash RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Bitcoin Cash](https://www.quicknode.com/chains/bch) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=bitcoincash)

Beta

Beta

## What is Bitcoin Cash?

[Bitcoin Cash](https://bitcoincash.org/) is a peer-to-peer electronic cash system that emerged in 2017 as a hard fork of Bitcoin. It was created to address Bitcoin's scalability limitations by increasing the block size limit to 32MB, enabling more transactions per second and lower fees.

Bitcoin Cash maintains Bitcoin's **proof-of-work (PoW) consensus mechanism** and **UTXO (Unspent Transaction Output) model** for tracking balances and transaction history. This makes Bitcoin Cash a fast, reliable, and low-cost cryptocurrency for everyday transactions and micropayments.

## Interacting with Bitcoin Cash APIs

Bitcoin Cash nodes expose a JSON-RPC interface that is compatible with Bitcoin's JSON-RPC API, allowing developers to interact with the blockchain programmatically using familiar Bitcoin tooling and libraries.

However, due to Bitcoin Cash's architectural differences (such as larger block sizes, different address formats, and unique features like CashTokens), some RPC methods may behave differently from those on Bitcoin. The Quicknode Bitcoin Cash documentation provides comprehensive coverage of these differences and Bitcoin Cash-specific functionality, and we highly recommend cross-referencing with the [official Bitcoin Cash documentation](https://docs.bitcoincashnode.org/doc/json-rpc/) for the latest updates and RPC differences.

You can access the API by:

-   Running a [local Bitcoin Cash client](https://docs.bitcoincashnode.org/doc/) (e.g., Bitcoin Cash Node, BCHD).
-   Using a **Quicknode Bitcoin Cash endpoint**, which delivers low-latency global access, historical data, and enhanced reliability out of the box.

## Supported Networks

Quicknode provides access to the following Bitcoin Cash networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | Yes | None |
| Testnet | Testnet | ✓ | ✗ | Yes | None |

Complete reference for developers building on Bitcoin Cash with Quicknode:

-   [QuickStart](/docs/bitcoincash/quickstart): Get started with Bitcoin Cash quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/bitcoincash/endpoints): Learn how to configure and manage your Bitcoin Cash endpoints for optimal performance and reliability.
-   [API Overview](/docs/bitcoincash/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/bitcoincash/add-ons): Discover endpoint add-ons that extend your Bitcoin Cash development workflow.
-   [Endpoint Security](/docs/bitcoincash/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.

---

---
title: Blast RPC
description: Get started with Blast RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Blast RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Blast](https://www.quicknode.com/chains/blast) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=blast)

## Blast Overview

Blast is a Layer 2 scaling solution for Ethereum, built on the OP Stack—the same technology that powers Optimism. It uses optimistic rollups to execute transactions off-chain while submitting compressed transaction data to Ethereum for security and settlement. Blast maintains bytecode-level EVM equivalence, ensuring full compatibility with existing Ethereum applications. The network employs sequencers to order transactions and achieve low-latency block production, while Ethereum provides finality through a fraud-proof challenge period.

Blast's defining feature is its native yield: ETH deposits are staked through protocols like Lido or Rocket Pool to generate staking rewards automatically, and USDB Blast's native stablecoin earns yield from real world, yield-bearing assets.

## Interacting with Blast's APIs

Blast nodes expose a JSON-RPC interface that is compatible with Ethereum's JSON-RPC API. This means developers can use Ethereum's native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification.

However, due to Blast's architectural differences, some RPC methods may behave differently from those on Ethereum. The Quicknode Blast documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official Blast documentation](https://docs.blast.io/about-blast) for the latest updates and RPC differences.

## Make Blast API Calls

The quickest way to start building on Blast is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed Blast endpoints, giving you immediate access to the Blast Mainnet and Sepolia Testnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/blast/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Blast networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 81457 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 168587773 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Blast with Quicknode:

-   [QuickStart](/docs/blast/quickstart): Get started with Blast quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/blast/endpoints): Learn how to configure and manage your Blast endpoints for optimal performance and reliability.
-   [API Overview](/docs/blast/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/blast/add-ons): Discover endpoint add-ons that extend your Blast development workflow.
-   [Endpoint Security](/docs/blast/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/blast/error-references): Understand common error codes and troubleshooting steps for Blast API requests.

---

---
title: BNB Smart Chain RPC
description: Get started with BNB Smart Chain RPC on Quicknode. Access reliable, low-latency infrastructure for BNB Smart Chain with globally distributed endpoints for fast mobile payments and Web3 applications.
---

# BNB Smart Chain RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [BNB Smart Chain](https://www.quicknode.com/chains/bsc) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=bnb-smart-chain)

## What is BNB Smart Chain?

BNB Smart Chain (BSC) is an EVM-compatible blockchain developed by Binance. BSC provides smart contract functionality through the **Ethereum Virtual Machine**. BSC uses a **Proof of Staked Authority (PoSA)** consensus mechanism that combines elements of Proof of Authority and Delegated Proof of Stake. The network implements **BEP-20** as its token standard (equivalent to ERC-20) and supports additional standards like BEP-721 for NFTs.

## Interacting with BNB Smart Chain

The BNB Smart Chain provides full compatibility with Ethereum's JSON-RPC interface, allowing developers to interact with BSC using standard Ethereum tooling. Since BSC maintains EVM equivalence, existing Solidity contracts can deploy directly without code changes.

With this API, you can:

-   Execute all standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, eth_getBalance)
-   Deploy and interact with BEP-20 tokens and smart contracts
-   Query blockchain state including blocks, transactions, receipts, and event logs
-   Subscribe to real-time events via WebSocket connections

You can access the API by:

-   Running a local BSC node (Geth-based BSC client)
-   Using a hosted provider such as a **Quicknode BNB Smart Chain endpoint**, which provides low-latency access to both mainnet and testnet with archive data support

## Supported Networks

Quicknode provides access to the following BNB Smart Chain networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 56 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 97 | ✓ | ✓ | Yes | None |

Complete reference for developers building on BNB Smart Chain with Quicknode:

-   [QuickStart](/docs/bnb-smart-chain/quickstart): Get started with BNB Smart Chain quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/bnb-smart-chain/endpoints): Learn how to configure and manage your BNB Smart Chain endpoints for optimal performance and reliability.
-   [API Overview](/docs/bnb-smart-chain/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/bnb-smart-chain/add-ons): Discover endpoint add-ons that extend your BNB Smart Chain development workflow.
-   [Endpoint Security](/docs/bnb-smart-chain/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/bnb-smart-chain/error-references): Understand common error codes and troubleshooting steps for BNB Smart Chain API requests.

---

---
title: Celestia RPC
description: Get started with Celestia RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Celestia RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Celestia](https://www.quicknode.com/chains/celestia) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=celestia)

Beta

Beta

## Celestia Overview

Celestia is a modular blockchain network that separates data availability and consensus from execution. This design allows developers to launch their own blockchains without needing to bootstrap a validator set or compromise on scalability.

The network consists of two main components:

-   **Data Availability Layer**: Celestia's core function is ensuring that transaction data is accessible and verifiable by anyone. It uses Data Availability Sampling (DAS), which allows light nodes to verify data without downloading entire blocks.
    
-   **Consensus Layer**: Built on the Cosmos SDK with a modified Tendermint consensus mechanism, Celestia orders and publishes transactions while leaving execution to rollups and other chains built on top.
    

Celestia uses **TIA** as its native token for paying data availability fees, staking, and governance. The network operates on a Proof-of-Stake consensus mechanism.

## Interacting with Celestia APIs

Celestia provides a JSON-RPC API through its celestia-node client. This API allows direct interaction with Celestia's Data Availability layer for operations like submitting blobs, querying headers, and managing shares.

Celestia also exposes Cosmos REST APIs and Tendermint RPC methods for querying blockchain state and consensus information. The modular design means that execution happens on rollups and other chains that use Celestia for data availability, while Celestia itself focuses on consensus and data availability functions.

The Quicknode Celestia documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Celestia documentation](https://docs.celestia.org/) for the latest updates and API details.

## Make Celestia API Calls

The quickest way to start building with Celestia is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Celestia endpoints, giving you immediate access to Celestia Mainnet and Testnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production applications
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/celestia/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Celestia networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | celestia | ✓ | ✓ | Yes | None |
| Mocha | Testnet | mocha-4 | ✓ | ✓ | No | pruning-keep-recent = "1832727" |

Archive Data Availability

To query historical data, use the `x-cosmos-block-height` header with REST API requests or specify the height parameter with Tendermint API requests:

**Cosmos REST API Example:**

```bash
curl --location 'https://docs-demo.celestia-mainnet.quiknode.pro/cosmos/bank/v1beta1/balances/celestia1cwhxmw9kaz72nhdsuqvk6ljf9dzes8kg7ysg9d' \

--header 'x-cosmos-block-height: 1000000'
```

**Tendermint API Example:**

```bash
curl --location 'https://docs-demo.celestia-mainnet.quiknode.pro/block?height=1000000'
```

Complete reference for developers building on Celestia with Quicknode:

-   [QuickStart](/docs/celestia/quickstart): Get started with Celestia quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/celestia/endpoints): Learn how to configure and manage your Celestia endpoints for optimal performance and reliability.
-   [API Overview](/docs/celestia/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/celestia/add-ons): Discover endpoint add-ons that extend your Celestia development workflow.
-   [Endpoint Security](/docs/celestia/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.

---

---
title: Celo RPC
description: Get started with Celo RPC on Quicknode. Access reliable, low-latency infrastructure for Celo with globally distributed endpoints for fast mobile payments and Web3 applications.
---

# Celo RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Celo](https://www.quicknode.com/chains/celo) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=celo)

## What is Celo?

Celo is an EVM-compatible blockchain designed for real-world payment applications and financial services. Originally launched as a Layer 1 blockchain, Celo has migrated to a Layer 2 architecture while maintaining full compatibility with Ethereum development tools. Celo uses a **Proof of Stake (PoS)** consensus mechanism and achieves **1-second block finality** after its L2 migration. The network supports **fee abstraction**, allowing gas payments in multiple currencies including native stablecoins like cUSD, cEUR, and cREAL.

The blockchain implements **phone number mapping** to wallet addresses through a decentralized identity protocol for simplified payments. Celo's **algorithmic stability protocol** maintains multiple stablecoins pegged to fiat currencies through a reserve mechanism.

## Interacting with Celo

Celo provides full Ethereum JSON-RPC compatibility with additional methods for Celo-specific features. Developers can use standard Ethereum tools like Ethers.js, Hardhat, and MetaMask with Celo by configuring the appropriate network endpoints.

With this API, you can:

-   Execute all standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, eth_getBalance)
-   Implement fee abstraction to allow gas payments in multiple currencies
-   Subscribe to real-time events via WebSocket connections

You can access the API by:

-   Running a local Celo node
-   Using a hosted provider such as a **Quicknode Celo endpoint**, which provides low-latency access to supported networks

## Supported Networks

Quicknode provides access to the following Celo networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 42220 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Celo with Quicknode:

-   [QuickStart](/docs/celo/quickstart): Get started with Celo quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/celo/endpoints): Learn how to configure and manage your Celo endpoints for optimal performance and reliability.
-   [API Overview](/docs/celo/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/celo/add-ons): Discover endpoint add-ons that extend your Celo development workflow.
-   [Endpoint Security](/docs/celo/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/celo/error-references): Understand common error codes and troubleshooting steps for Celo API requests.

---

---
title: CLI
description: Use the CLI to manage endpoints, Streams, Webhooks, Key-Value Store, usage, billing, and teams from the terminal.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


The **CLI** is the `qn` command-line tool for working with Quicknode product APIs from a terminal, shell script, or CI job.

## Install

Install `qn` with the recommended command for your system. The install tabs are selected from your browser user agent when possible, and you can choose any install path manually.

Recommended for macOS. Homebrew also works on Linux.

```bash
brew install quicknode/tap/qn
```

After installation, check the version:

```bash
qn --version
```

Then authenticate and verify access:

```bash
qn auth login

qn auth whoami
```

Run your first read commands:

```bash
qn chain list

qn endpoint list

qn endpoint list --format json
```

## Product coverage

Use the CLI to inspect and manage:

  

-   **[Admin API](/docs/admin-api)**: Endpoints, teams, usage, billing, logs, metrics, endpoint security, rate limits, and account tags.
-   **[RPC](/docs/admin-api/tooling-access/v0-tooling-access)**: Make on-chain JSON-RPC calls without provisioning an endpoint, or [pay per call with x402 or MPP](/docs/cli/micropayments) without an account or API key.
-   **[Streams](/docs/streams)**: Stream listing, creation, inspection, lifecycle actions, and filter testing.
-   **[Webhooks](/docs/webhooks)**: Webhook listing, template creation, inspection, lifecycle actions, and enabled counts.
-   **[Key-Value Store](/docs/key-value-store)**: Sets and lists for state, watchlists, cursors, filters, and small lookup tables.
-   **[SQL Explorer](/docs/sql-explorer)**: Run SQL queries against indexed blockchain data and retrieve table schemas.

## When to use the CLI

Use the CLI when the terminal is the fastest interface for the job.

Common workflows include:

  

-   List endpoints, URLs, logs, and metrics while debugging.
-   Make on-chain JSON-RPC calls to any supported network with `qn rpc call`.
-   Pay for RPC calls with x402 or MPP without a Quicknode account or API key.
-   Check account usage, billing records, chains, teams, and tags.
-   Create or inspect Streams and Webhooks during development.
-   Read and update Key-Value Store data from scripts.
-   Run SQL queries against indexed blockchain data with SQL Explorer.
-   Run repeatable CI checks with explicit credentials and structured output.

For application code, use the [SDK](/docs/sdk) or the product REST APIs directly.

## Authenticate

Create an API key in the [Quicknode dashboard](https://dashboard.quicknode.com/api-keys), then run:

```bash
qn auth login

qn auth whoami
```

`qn` resolves credentials in this order:

  

1.  `--api-key <KEY>`
2.  `--config-file <PATH>`
3.  `~/.config/qn/config.toml`

The CLI does not read API keys from environment variables. For scripts and CI, pass `--api-key` from a secret store or write a config file outside your repository and pass `--config-file`.

For one command, pass the key explicitly:

```bash
qn --api-key YOUR_API_KEY endpoint list --format json
```

For CI, write a config file outside the repository and point the CLI at it:

```bash
mkdir -p "$RUNNER_TEMP/qn"

printf '[api]\nkey = "%s"\n' "$QUICKNODE_API_KEY" > "$RUNNER_TEMP/qn/config.toml"



qn --config-file "$RUNNER_TEMP/qn/config.toml" endpoint list --format json
```

## Output

Set the output format with `--format` or `-o`.

| Format | Use |
| --- | --- |
| `table` | Human-readable terminal tables. This is the default when stdout is a terminal. |
| `json` | Scripts, jq, tests, and API-shaped output. |
| `yaml` | Readable structured output. |
| `md` | Markdown tables for issues, pull requests, and docs. |
| `toon` | Compact structured output. This is the default when stdout is not a terminal. |

Examples:

```bash
qn endpoint list --format json

qn usage summary --from 7d -o yaml

qn endpoint list --wide
```

## Agent context

Use `qn agent context` to print a self-contained usage guide for AI agents and automated tools. It makes no network request and does not require authentication.

```bash
qn agent context

qn agent context -o json
```

The command is designed for agent context windows, including Claude and other tools that can ingest Markdown or JSON.

## Shell completions

Generate completions for your shell:

```bash
qn completions zsh > ~/.zfunc/_qn

qn completions bash > /etc/bash_completion.d/qn

qn completions fish > ~/.config/fish/completions/qn.fish

qn completions powershell > qn.ps1

qn completions elvish > qn-completions.elv
```

## Common commands

```bash
qn rpc call eth_blockNumber

qn rpc call eth_blockNumber --network ethereum-mainnet --x402 --payment-wallet payer

qn stream list --limit 20

qn webhook enabled-count

qn kv set ls

qn sql query "SELECT * FROM hyperliquid_trades LIMIT 10" --cluster hyperliquid-core-mainnet

qn sql schema --cluster hyperliquid-core-mainnet

qn usage summary --from 7d

qn billing invoices
```

## Confirmations

Commands that can delete, archive, pause, revoke, or otherwise change resources prompt before acting.

```bash
qn endpoint archive 123

qn stream delete 123

qn webhook pause 123
```

In non-interactive environments, confirmation-gated commands exit before sending a request unless you explicitly opt out of prompts. Keep documentation examples prompt-safe by default.

## Next steps

  

-   Use [Examples](/docs/cli/examples) for common product workflows, including Tooling Access and `qn rpc call`.
-   Use [RPC Micropayments](/docs/cli/micropayments) to generate a local wallet and call blockchain RPC methods with x402 or MPP.
-   See the examples in [Admin API](/docs/admin-api), [Streams](/docs/streams), [Webhooks](/docs/webhooks), [Key-Value Store](/docs/key-value-store), and [SQL Explorer](/docs/sql-explorer) for full API behavior.

---

---
title: Cosmos RPC
description: Get started with Cosmos RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Cosmos RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Cosmos](https://www.quicknode.com/chains/cosmos) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=cosmos)

## What is Cosmos?

Cosmos is a decentralized network of interoperable blockchains, often called the “Internet of Blockchains.” Built with the Cosmos SDK, it lets developers create scalable, application-specific chains while the Inter-Blockchain Communication (IBC) protocol enables secure asset and data transfers across them. This design allows each blockchain to remain sovereign yet connected, fostering a more efficient and collaborative ecosystem.

## Interacting With Cosmos APIs

Cosmos nodes expose gRPC and REST interfaces that allow developers to interact with the blockchain programmatically. This means you can query balances, transactions, and state; broadcast transactions; access staking, governance, and distribution data; and monitor validators, network status, and other chain activity.

You can connect by running your own Cosmos node with gRPC/REST enabled, or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

However, because Cosmos chains are modular, some endpoints or behaviors may differ depending on the network. The Quicknode Cosmos documentation is continuously updated, but we recommend cross-referencing with the [official Cosmos SDK documentation](https://docs.cosmos.network/api) for the latest API details.

* * *

## Make Cosmos API Calls

The quickest way to start building on Cosmos is to create a Quicknode endpoint and send your first request.

Quicknode provides managed Cosmos endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Archive data — full historical state for in-depth queries
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/cosmos/quickstart) page to create your endpoint and send your first request.

* * *

## Supported Networks

Quicknode provides access to multiple Cosmos networks.

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Cosmos Hub | Production | cosmoshub-4 | ✓ | ✓ | Yes | Data available from block height 5200791. No support for cosmoshub-1/2/3 |

Archive Data Availability

Quicknode's Cosmos endpoints now provide archive data access starting from block height `5200791`, which corresponds to the beginning of the `Cosmoshub-4` chain. Please note that data from previous chain versions (Cosmoshub-1, Cosmoshub-2, and Cosmoshub-3) is not available.

To query historical data, use the `x-cosmos-block-height` header with REST API requests or specify the height parameter with Tendermint API requests:

**Cosmos REST API Example:**

```bash
curl --location 'https://docs-demo.cosmos-mainnet.quiknode.pro/cosmos/bank/v1beta1/balances/cosmos1t6rlgf80jd8tanpnnvmmxfqdcm9cn7wctrs7hk' \

--header 'x-cosmos-block-height: 5200791'
```

**Tendermint API Example:**

```bash
curl --location 'https://docs-demo.cosmos-mainnet.quiknode.pro/block?height=5200791'
```

Complete reference for developers building on Cosmos with Quicknode:

-   [QuickStart](/docs/cosmos/quickstart): Get started with Cosmos quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/cosmos/endpoints): Learn how to configure and manage your Cosmos endpoints for optimal performance and reliability.
-   [API Overview](/docs/cosmos/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/cosmos/add-ons): Discover endpoint add-ons that extend your Cosmos development workflow.
-   [Endpoint Security](/docs/cosmos/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/cosmos/error-references): Understand common error codes and troubleshooting steps for Cosmos API requests.

---

---
title: Quicknode Custom RPC Options
description: Explore Quicknode's Custom RPC options for projects requiring enhanced performance, workload isolation, and scalability beyond standard plans.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


Quicknode offers **custom RPC options** designed for enterprise customers who require performance, isolation, and scalability beyond standard shared infrastructure. These solutions cater to a diverse range of high-demand applications, from latency-sensitive trading platforms to large-scale dApps with unique traffic patterns.

These custom options are designed to address a range of advanced infrastructure needs. They are particularly well-suited for projects with requirements such as:

  

-   **Latency-Sensitive**: Applications that need deterministic, low-latency responses for time-critical operations
-   **Workload-Isolation Sensitive**: Operations that require a private environment to avoid resource contention and ensure consistent performance
-   **Scalability-Driven**: Projects with performance and capacity needs that exceed what shared infrastructure can reliably offer

## Available Custom RPC Options

Quicknode provides different custom options, each designed for specific use cases and technical requirements.

### Fully Dedicated Setup

The **Fully Dedicated Setup** is our most robust offering, providing a completely isolated and customized infrastructure exclusively to your organization, similar to a private, miniature version of the Quicknode Pro network.

#### Key Features

  

-   **Complete Isolation**: Your traffic runs on fully private hardware, eliminating any “noisy neighbor” effect.
-   **Custom Configuration**: Infrastructure can be tailored to meet specific geographic, performance, or architectural needs.
-   **Optimized Performance**: Delivers the highest levels of performance for latency, throughput, and workload isolation.

#### Ideal Use Cases

  

-   Projects requiring **extensive, globally distributed** infrastructure with numerous edge and backend nodes.
-   Applications with unique, resource-intensive traffic patterns that demand optimized, **non-standard configurations**.
-   Organizations that require complete traffic isolation to meet stringent **security** or **regulatory standards**.

### Hybrid Dedicated gRPC

**Hybrid dedicated gRPC** option provides a single reserved gRPC node with automatic failover to a shared pool for redundancy. This Solana-exclusive option balances dedicated resources with high availability.

#### Key Features

  

-   **Reserved gRPC Node**: Provides a dedicated computational resource for your primary traffic.
-   **Automatic Failover**: Ensures high availability with a seamless transition to a shared pool if the primary node is unresponsive.
-   **Built-in Redundancy**: The architecture is designed to avoid a single point of failure for critical gRPC connections.

#### Ideal Use Cases:

  

-   Solana applications that require a dedicated gRPC resource for performance while retaining the reliability of a shared failover pool.

#### Key Considerations and Limitations:

  

-   Service is currently available only for the Solana blockchain.
-   The architecture provides a single reserved gRPC node, not a cluster of dedicated nodes.

## Custom RPC Options Comparison

| Feature | Fully Dedicated Setup | Hybrid Dedicated gRPC |
| --- | --- | --- |
| **Infrastructure** | Fully isolated, custom-built private network. | Single reserved gRPC node with failover to a shared pool. |
| **Performance** | Highest levels of latency and workload isolation. | Dedicated resource with shared redundancy. |
| **Ideal Use Cases** | Massive scale, custom workloads, total isolation. | Redundancy for Solana gRPC connections. |
| **Chain Availability** | All chains. | Solana only. |
| **Predictable Pricing** | Yes, through custom agreements. | Yes, through custom agreements. |

Quicknode provides a full spectrum of infrastructure options, from shared nodes to fully dedicated setups, ensuring you have the right solution at every stage of your business.

For detailed pricing or to discuss which custom option is the right fit for your project, please contact our [sales team](https://www.quicknode.com/clusters#contact). Our team is available to help analyze your specific workload and recommend the most suitable and cost-effective solution to meet your goals.

---

---
title: Cyber RPC
description: Get started with Cyber RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Cyber RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Cyber](https://www.quicknode.com/chains/cyber) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=cyber)

## Cyber Overview

Cyber is an Ethereum Layer 2 built on the OP Stack with a focus on social applications. The network provides infrastructure for developers to build decentralized social applications with features like user profiles, social graphs, and content creation.

Cyber uses **CYBER** as its native token for transaction fees, governance, and staking. The network integrates with EigenLayer for restaking, allowing stakers to help secure the network and earn rewards.

## Interacting with Cyber APIs

Cyber is fully EVM-compatible and supports standard Ethereum JSON-RPC methods. Developers can use familiar Ethereum tools like Hardhat, Foundry, Web3.js, and Ethers.js without modification.

As an OP Stack chain, Cyber follows the same RPC interface as other Optimism-based networks. This means applications built for Ethereum or other OP Stack chains can be deployed on Cyber with minimal changes. Cyber also provides access to its social features through the CyberConnect protocol, which developers can integrate into their applications.

The Quicknode Cyber documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Cyber documentation](https://docs.cyber.co/) for the latest updates and features.

## Make Cyber API Calls

The quickest way to start building on Cyber is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Cyber endpoints, giving you immediate access to Cyber Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production applications
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/cyber/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Cyber networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 7560 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 111557560 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Cyber with Quicknode:

-   [QuickStart](/docs/cyber/quickstart): Get started with Cyber quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/cyber/endpoints): Learn how to configure and manage your Cyber endpoints for optimal performance and reliability.
-   [API Overview](/docs/cyber/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/cyber/add-ons): Discover endpoint add-ons that extend your Cyber development workflow.
-   [Endpoint Security](/docs/cyber/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/cyber/error-references): Understand common error codes and troubleshooting steps for Cyber API requests.

---

---
title: DATA Network RPC
description: Get started with DATA Network RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# DATA Network RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [DATA Network](https://www.quicknode.com/chains/data) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=data)

DATA Network deprecation notice

Quicknode will **discontinue support for DATA Network** after **September 30, 2026**. Please migrate any applications or workloads that use DATA Network endpoints before this date to avoid service disruption.

## DATA Network Overview

DATA Network is a purpose-built Layer 1 blockchain designed to establish provenance, confidentiality, and rights governance for data assets. It is 100% EVM-compatible with a CometBFT-based consensus layer enabling fast finality and economical transactions. The network addresses three critical needs: Trace (provenance and verifiable records), CDR (confidentiality through threshold encryption), and IP & Licensing (programmable usage rights). DATA Network supports diverse data types including images, datasets, AI training data, and real-world assets, with the $DATA token used for gas fees.

## Interacting With DATA Network APIs

DATA Network exposes Ethereum-compatible JSON-RPC methods that allow developers to interact with the network programmatically. You can query blockchain state, send transactions, deploy and interact with smart contracts, and subscribe to real-time events via WebSocket.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

The Quicknode DATA Network documentation is continuously updated, but we recommend cross-referencing with the [official Data Foundation documentation](https://docs.datafdn.org/) for the latest API details.

## Make DATA Network API Calls

The quickest way to start building on DATA Network is to create a Quicknode endpoint and send your first request. Quicknode provides managed DATA Network endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/data/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following DATA Network networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 1514 | ✓ | ✓ | Yes | None |
| DATA Network Aeneid | Testnet | 1315 | ✓ | ✓ | Yes | None |

Complete reference for developers building on DATA Network with Quicknode:

-   [QuickStart](/docs/data/quickstart): Get started with DATA Network quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/data/endpoints): Learn how to configure and manage your DATA Network endpoints for optimal performance and reliability.
-   [API Overview](/docs/data/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/data/add-ons): Discover endpoint add-ons that extend your DATA Network development workflow.
-   [Endpoint Security](/docs/data/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/data/error-references): Understand common error codes and troubleshooting steps for DATA Network API requests.

---

---
title: Doge RPC
description: Get started with Doge RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Dogecoin RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Dogecoin](https://www.quicknode.com/chains/doge) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Start building](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=doge)[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

## Overview

At Quicknode, we’re committed to helping developers and enterprises explore and build on the latest, most innovative blockchain networks. [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains) offer a flexible, on-demand infrastructure that supports emerging chains, enabling users to access a broader range of networks with high potential.

With [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains), developers can:

-   Build and innovate on cutting-edge, high-potential chains.
-   Unlock new opportunities within Web3 ecosystems.
-   Leverage Quicknode’s industry-leading reliability and performance without waiting for full infrastructure deployment.

[**Dogecoin**](https://dogecoin.com/#what-is-dogecoin) is a decentralized, community-driven cryptocurrency secured by Proof-of-Work. Initially launched as a lighthearted parody, it has grown into a reliable digital currency known for fast, low-cost transactions and a vibrant, philanthropic community.

  

Info

To learn more about Select Access Chains, check out this blog on [Introducing Select Access Chains: Your Chain, Your Choice](https://blog.quicknode.com/introducing-select-access-chains/)

## Access

You can access Dogecoin through the [Quicknode Developer Portal](https://dashboard.quicknode.com).

For enterprises with unique needs or large-scale projects, Quicknode offers custom solutions tailored to specific requirements. Our team is ready to collaborate with you to ensure you have the infrastructure, support, and resources necessary for success in the expanding blockchain ecosystem. Talk with our team to [create a custom plan today](https://www.quicknode.com/contact-us).

## Dogecoin Network Support

| Network | HTTPS |
| --- | --- |
| MAINNET | ✅ |
| TESTNET | ✅ |

## Dogecoin JSON-RPC API Documentation

  

Note

Dogecoin uses a Bitcoin-like JSON-RPC API, so its API methods are similar (or identical) to those used by [Bitcoin Core](https://www.quicknode.com/docs/bitcoin).

## API Credits

Usage in our pricing plans is measured in API Credits. To learn more about the API Credits for Dogecoin, please visit [this page](https://www.quicknode.com/api-credits/doge).

## Endpoint Authentication Options

  

Note:

Please note that setting JWT (JSON Web Tokens), configuring all whitelist options, and changing any rate limits beyond credits per second are only available to users on the **Build plan and higher**. Users on the **Free Trial** plan can only change their requests per second rate limit or add, use, and delete an authentication token. Visit [our pricing](https://www.quicknode.com/pricing) page for more information.

### Token Authentication

By default, all endpoints created on Quicknode are protected by a token in the URL which looks something like this:

  

```
http://sample-endpoint-name.network.quiknode.pro/token-goes-here/
```

### Approved Referrer List

For endpoints on the shared network, you are able to add a list of approved referrers. This requires any HTTP request to send a **REFERRER** header or any WebSocket request to send an **ORIGIN** header populated with one of the referrers you entered into our user panel.

### Disabling Token Authentication

You can also disable the token authentication completely in your security settings for a given endpoint. This will allow anyone to make requests to the endpoint without the token.

### JWT (JSON Web Tokens)

For additional security, you can also enable JWT for each of your deployed endpoints. JWT allows for stateless authentication between you and your endpoint. Learn how to use JWT with Quicknode in [this step-by-step guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-implement-json-web-tokens-jwt-authorization-with-quicknode).

### Multiple Authentication Tokens

Create multiple authentication tokens for each of your deployed endpoints. This allows you to revoke any tokens that may be comprised, without needing to restart your non-compromised endpoint.

To roll an individual authentication token, create an additional token and then delete the previous token. Learn more about multiple authentication tokens in [this Quicknode guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-set-up-multi-token-authentication-on-quicknode).

---

> For the complete documentation index, see [llms.txt](/docs/llms.txt)

---
title: Quicknode Earn Documentation
description: Documentation for Quicknode Earn, a non-custodial USDC yield optimizer.
---

Quicknode [Earn](https://earn.quicknode.com) is a non-custodial USDC yield optimizer that automatically rebalances your capital across Morpho vaults on Ethereum, Optimism, Base, Arbitrum, Polygon, Unichain, and Monad.

Get Started

[

What is Earn

Learn about how Earn works and its core concepts.

](/docs/earn/get-started/what-is-earn)[

Supported wallets

Wallets compatible with Quicknode Earn.

](/docs/earn/get-started/supported-wallets)[

Connect and deposit

Connect your wallet and make your first deposit.

](/docs/earn/get-started/connect-and-deposit)[

Earn Dashboard

Open Earn to view and manage your strategies.

](https://earn.quicknode.com)

Using Earn

[

Creating a strategy

Set up an automated yield strategy.

](/docs/earn/using-earn/creating-a-strategy)[

Monitoring strategies and positions

Monitor and manage your active positions.

](/docs/earn/using-earn/monitoring-strategies-and-positions)[

Closing a strategy

How to close a strategy and withdraw funds.

](/docs/earn/using-earn/closing-a-strategy)

How It Works

[

Vaults

Understanding Morpho vaults and how they're selected.

](/docs/earn/how-it-works/vaults)[

Rebalancing

How automatic rebalancing works.

](/docs/earn/how-it-works/rebalancing)[

Cross-chain bridging

How funds move between chains via CCTP.

](/docs/earn/how-it-works/cross-chain-bridging)[

Fees and gas

Fee structure and gas costs.

](/docs/earn/how-it-works/fees-and-gas)

Reference

[

Smart contracts

Contract addresses and technical details.

](/docs/earn/reference/smart-contracts)[

API

Public API reference.

](/docs/earn/reference/api)[

Security and audits

Security practices and audit reports.

](/docs/earn/reference/security-and-audits)[

FAQ

Frequently asked questions.

](/docs/earn/reference/faq)

Community and Support

[

Earn Telegram

Join the Quicknode Earn community on Telegram.

](https://t.me/quicknode_earn)[

Direct Support

Get personalized help from our support team.

](https://portal.usepylon.com/quicknode/forms/submit-a-support-ticket)

---

---
title: Ethereum RPC
description: Get started with Ethereum RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Ethereum RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Ethereum](https://www.quicknode.com/chains/eth) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=ethereum)

## What is Ethereum?

Ethereum is the most widely adopted smart contract blockchain, powered by the Ethereum Virtual Machine (EVM). Developers write smart contracts primarily in Solidity (or other EVM-compatible languages like Vyper, Yul), which compile to EVM bytecode and deploy across Ethereum's decentralized network of validator and full nodes.

Since 2022, Ethereum uses a **proof-of-stake (PoS) consensus mechanism** and maintains an **account-based model** to track balances and smart contract state. Together, these features make Ethereum a secure, programmable foundation for decentralized applications (dApps).

## What is the Ethereum JSON-RPC API?

Ethereum nodes expose a JSON-RPC interface that allows developers to interact with the blockchain programmatically. This is known as the **Ethereum JSON-RPC API**.

With this API, you can:

-   Query blockchain state (blocks, transactions, receipts, logs)
-   Send transactions
-   Deploy and interact with smart contracts
-   Subscribe to real-time events (via WebSocket subscriptions such as eth_subscribe)

You can access the API by:

-   Running a local Ethereum client (e.g., Geth, Nethermind, Besu). You can learn how by looking at our node setup guides [here](https://www.quicknode.com/guides/infrastructure/node-setup/how-to-install-and-run-a-geth-node).
-   Using a hosted provider such as a **Quicknode Ethereum endpoint**, which delivers low-latency global access, archive data, and enhanced reliability out of the box.

## Supported Networks

Quicknode provides access to the following Ethereum networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 1 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 11155111 | ✓ | ✓ | Yes | None |
| Hoodi | Testnet | 560048 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Ethereum with Quicknode:

-   [QuickStart](/docs/ethereum/quickstart): Get started with Ethereum quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/ethereum/endpoints): Learn how to configure and manage your Ethereum endpoints for optimal performance and reliability.
-   [API Overview](/docs/ethereum/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/ethereum/add-ons): Discover endpoint add-ons that extend your Ethereum development workflow.
-   [Endpoint Security](/docs/ethereum/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/ethereum/error-references): Understand common error codes and troubleshooting steps for Ethereum API requests.

## Frequently Asked Questions

**How can I access the Ethereum JSON-RPC API?**

You can access the API by running a local Ethereum client like Geth, Nethermind, or Besu, or by using a hosted provider such as a Quicknode Ethereum endpoint for low-latency global access with enhanced reliability.

**What Ethereum networks does Quicknode support?**

Quicknode provides access to Ethereum Mainnet (Chain ID 1), Sepolia testnet (Chain ID 11155111), and Hoodi testnet (Chain ID 560048), all with HTTP and WebSocket support, archive data, and no pruning.

**Does Quicknode support WebSocket connections for Ethereum?**

Yes, Quicknode endpoints support WebSocket (WSS) connections for all supported Ethereum networks, enabling real-time event subscriptions like eth_subscribe.

**What can I do with Quicknode's Ethereum RPC service?**

You can query blockchain state including blocks, transactions, receipts, and logs, send transactions, deploy and interact with smart contracts, and subscribe to real-time blockchain events.

**Does Quicknode provide archive node access for Ethereum?**

Yes, all Quicknode Ethereum networks (Mainnet, Sepolia, and Hoodi) offer full archive data with no pruning.

---

---
title: Fantom RPC
description: Get started with Fantom RPC on Quicknode. Access reliable, low-latency infrastructure for Fantom Opera with globally distributed endpoints for high-performance DeFi applications.
---

# Fantom RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Fantom](https://www.quicknode.com/chains/ftm) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=fantom)

## What is Fantom?

Fantom is a high-performance, scalable blockchain platform that uses a unique consensus mechanism called Lachesis to achieve near-instant transaction finality. Built as a Directed Acyclic Graph (DAG) based network, Fantom can process thousands of transactions per second while maintaining EVM compatibility, low fees and high throughput.

## Interacting with Fantom

The Fantom JSON-RPC API is fully compatible with Ethereum's API, enabling developers to use existing Ethereum development tools and libraries. Fantom supports all standard Ethereum JSON-RPC methods, allowing applications to interact with smart contracts, transfer FTM tokens, and access DeFi protocols using familiar interfaces.

## Supported Networks

Quicknode provides access to the following Fantom networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 250 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Fantom with Quicknode:

-   [QuickStart](/docs/fantom/quickstart): Get started with Fantom quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/fantom/endpoints): Learn how to configure and manage your Fantom endpoints for optimal performance and reliability.
-   [API Overview](/docs/fantom/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/fantom/add-ons): Discover endpoint add-ons that extend your Fantom development workflow.
-   [Endpoint Security](/docs/fantom/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/fantom/error-references): Understand common error codes and troubleshooting steps for Fantom API requests.

---

---
title: Flare RPC
description: Get started with Flare RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Flare RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Flare](https://www.quicknode.com/chains/flare) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=flare)

Beta

Beta

## Flare Overview

Flare is an EVM-compatible Layer 1 blockchain that provides decentralized access to external data. The network includes two native oracle protocols at the network layer:

Flare enables developers to build applications that can access cryptocurrency prices, cross-chain transaction data, and Web2 event information without relying on centralized providers. The network uses **FLR** as its native token for transaction fees, staking, and governance, and operates on a Proof-of-Stake consensus mechanism.

## Interacting with Flare APIs

Flare is fully compatible with the Ethereum Virtual Machine (EVM) and supports standard Ethereum JSON-RPC methods. This means developers can use familiar Ethereum development tools like Hardhat, Foundry, Web3.js, and Ethers.js without modification.

Since Flare uses the same JSON-RPC interface as Ethereum, applications built for Ethereum can be deployed on Flare with minimal changes. The network also provides access to its native oracle protocols through smart contracts, allowing developers to integrate price feeds and cross-chain data into their applications.

The Quicknode Flare documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Flare documentation](https://dev.flare.network/) for the latest updates and protocol-specific features.

## Make Flare API Calls

The quickest way to start building on Flare is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Flare endpoints, giving you immediate access to Flare Mainnet and Coston2 Testnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production applications
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/flare/quickstart) page to create your endpoint and send your first request.

## Flare Public Endpoints

  

HTTPS Endpoint

WSS Endpoint

Upgrade

-   ✓Higher Rate Limits
-   ✓Debug API
-   ✓Advanced Metrics & Security
-   ✓API Logs

[Get started](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=flare-public-rpc)

## Supported Networks

Quicknode provides access to the following Flare networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 14 | ✓ | ✓ | Yes | None |
| Coston2 Testnet | Testnet | 114 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Flare with Quicknode:

-   [QuickStart](/docs/flare/quickstart): Get started with Flare quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/flare/endpoints): Learn how to configure and manage your Flare endpoints for optimal performance and reliability.
-   [API Overview](/docs/flare/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/flare/add-ons): Discover endpoint add-ons that extend your Flare development workflow.
-   [Endpoint Security](/docs/flare/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/flare/error-references): Understand common error codes and troubleshooting steps for Flare API requests.

---

---
title: Flow RPC
description: Get started with Flow RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Flow REST API, RPC & gRPC (Access API)

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Flow REST API, & gRPC (Access API)](https://www.quicknode.com/chains/flow) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=flow)

## Flow Overview

Flow is a Layer 1 blockchain built for consumer applications and digital assets. Flow supports two execution environments:

  

-   **Cadence**: Flow's native smart contract language with resource-oriented programming for managing digital assets
-   **EVM (Flow EVM)**: Full EVM equivalence introduced with the Crescendo upgrade in September 2024, allowing Ethereum contracts to run on Flow without code changes

Flow uses **FLOW** as its native token for transaction fees, staking, and network governance.

## Interacting with Flow APIs

Flow provides three API options for developers:

  

-   **Flow REST API**: HTTP-based API for querying blockchain data and submitting transactions
-   **Flow gRPC (Access API)**: High-performance gRPC interface for accessing Flow network data
-   **Ethereum JSON-RPC API (Beta)**: EVM-compatible JSON-RPC endpoints for Ethereum tooling and smart contracts

The EVM compatibility means developers can use standard Ethereum tools like Hardhat, Foundry, Web3.js, and Ethers.js. Cadence developers can interact with EVM contracts, and EVM contracts can access Cadence functionality through the VM Bridge, enabling cross-environment composability.

The Quicknode Flow documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Flow documentation](https://developers.flow.com/) for the latest updates and features.

## Make Flow API Calls

The quickest way to start building on Flow is to create a Quicknode endpoint and send your first API request.

**Quicknode** provides managed Flow endpoints, giving you immediate access to Flow Mainnet and Testnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production applications
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/flow/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Flow networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 747 | ✓ | ✓ | No | Root of current spork (epoch) |
| Testnet | Testnet | 545 | ✓ | ✓ | No | Root of current spork (epoch) |

Complete reference for developers building on Flow with Quicknode:

-   [QuickStart](/docs/flow/quickstart): Get started with Flow quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/flow/endpoints): Learn how to configure and manage your Flow endpoints for optimal performance and reliability.
-   [API Overview](/docs/flow/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/flow/add-ons): Discover endpoint add-ons that extend your Flow development workflow.
-   [Endpoint Security](/docs/flow/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/flow/error-references): Understand common error codes and troubleshooting steps for Flow API requests.

---

---
title: Fluent RPC
description: Get started with Fluent RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Fluent RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Fluent](https://www.quicknode.com/chains/fluent) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=fluent)

Beta

Beta

Note:

The Quicknode Fluent documentation constantly evolves as the chain undergoes upgrades and changes. We highly recommend cross-referencing with the [Fluent Documentation](https://docs.fluent.xyz/) for the latest updates.

## What is Fluent?

Fluent is the first blended execution network: a zkVM-powered Ethereum Layer 2 and development framework for building diverse blockchain applications. It simulates the execution environments of multiple VMs (EVM, SVM, Wasm) to enable real-time composability of contracts written in languages like Solidity and Rust on a shared state.

## Interacting With Fluent APIs

Fluent exposes Ethereum-compatible JSON-RPC and Debug methods that allow developers to interact with the network programmatically. You can query blocks and transactions, deploy and interact with smart contracts, and trace execution for debugging. You can connect to a Fluent Node by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

* * *

## Make Fluent API Calls

The quickest way to start building on Fluent is to create a Quicknode endpoint and send your first request. Quicknode provides managed Fluent endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/fluent/quickstart) page to create your endpoint and send your first request.

* * *

## Supported Networks

Quicknode provides access to Fluent Mainnet and Testnet.

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✓ | Yes | None |
| Testnet | Testnet | ✓ | ✓ | Yes | None |

Complete reference for developers building on Fluent with Quicknode:

-   [QuickStart](/docs/fluent/quickstart): Get started with Fluent quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/fluent/endpoints): Learn how to configure and manage your Fluent endpoints for optimal performance and reliability.
-   [API Overview](/docs/fluent/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/fluent/add-ons): Discover endpoint add-ons that extend your Fluent development workflow.
-   [Endpoint Security](/docs/fluent/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/fluent/error-references): Understand common error codes and troubleshooting steps for Fluent API requests.

---

---
title: Fraxtal RPC
description: Get started with Fraxtal RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Fraxtal RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Fraxtal](https://www.quicknode.com/chains/frax) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Start building](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=fraxtal)[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

## Overview

At Quicknode, we’re committed to helping developers and enterprises explore and build on the latest and most innovative blockchain networks. [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains) offer a flexible, on-demand infrastructure that supports emerging chains, enabling users to access a broader range of networks with high potential.

With [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains), developers can:

-   Build and innovate on cutting-edge, high-potential chains.
-   Unlock new opportunities within Web3 ecosystems.
-   Leverage Quicknode’s industry-leading reliability and performance without waiting for full infrastructure deployment.

[**Fraxtal**](https://www.frax.com/) is a Layer 2 blockchain built on the OP stack with Ethereum compatibility. It uses Frax Ether (frxETH) as its native gas token and rewards users and developers through its Flox incentive system. Fraxtal focuses on efficient scaling and modular blockchain interaction.

  

Info

To learn more about Select Access Chains, check out this blog on [Introducing Select Access Chains: Your Chain, Your Choice](https://blog.quicknode.com/introducing-select-access-chains/)

## Access

You can access Fraxtal through the [Quicknode Developer Portal](https://dashboard.quicknode.com).

For enterprises with unique needs or large-scale projects, Quicknode offers custom solutions tailored to specific requirements. Our team is ready to collaborate with you to ensure you have the infrastructure, support, and resources necessary for success in the expanding blockchain ecosystem. Talk with our team to [create a custom plan today](https://www.quicknode.com/contact-us).

## Fraxtal Network Support

| Network | WSS | HTTPS |
| --- | --- | --- |
| MAINNET | ✅ | ✅ |

## Fraxtal JSON-RPC API Documentation

For detailed API documentation and usage guides, please refer to the [official Fraxtal documentation](https://docs.frax.com/fraxtal).

## Fraxtal Tools and Resources

| **Resource** | **Description** | **Link/Details** |
| --- | --- | --- |
| **Chain ID** | The unique identifier for the Fraxtal network. | Mainnet: 252, Testnet: 2522 |
| **Currency Symbol** | The symbol representing the native currency for transactions on Fraxtal. | frxETH |
| **Fraxtal Explorer** | A blockchain explorer to view transactions, blocks, and network activity on Fraxtal. | Mainnet: [https://fraxscan.com](https://fraxscan.com) Testnet: [https://holesky.fraxscan.com](https://holesky.fraxscan.com) |
| **Fraxtal Status Page** | Provides real-time updates on Fraxtal’s network status, uptime, and incidents. | [https://snowtrace.freshstatus.io/](https://snowtrace.freshstatus.io/) |

## API Credits

Usage in our pricing plans is measured in API Credits. To learn more about the API Credits for Fraxtal, please visit [this page](https://www.quicknode.com/api-credits/fraxtal).

## WebSocket Limits

WebSocket responses are capped at a certain limit, which is subject to change. In cases where responses are potentially large, it is recommended to use a **POST** request. If the response size exceeds the limit, the associated error code will be **\-32616**.

## Endpoint Authentication Options

  

Note:

Please note that setting JWT (JSON Web Tokens), configuring all whitelist options, and changing any rate limits beyond credits per second are only available to users on the **Build plan and higher**. Users on the **Free Trial** plan can only change their requests per second rate limit or add, use, and delete an authentication token. Visit [our pricing](https://www.quicknode.com/pricing) page for more information.

### Token Authentication

By default, all endpoints created on Quicknode are protected by a token in the URL which looks something like this:

  

```
http://sample-endpoint-name.network.quiknode.pro/token-goes-here/
```

### Approved Referrer List

For endpoints on the shared network, you are able to add a list of approved referrers. This requires any HTTP request to send a **REFERRER** header or any WebSocket request to send an **ORIGIN** header populated with one of the referrers you entered into our user panel.

### Disabling Token Authentication

You can also disable the token authentication completely in your security settings for a given endpoint. This will allow anyone to make requests to the endpoint without the token.

### JWT (JSON Web Tokens)

For additional security, you can also enable JWT for each of your deployed endpoints. JWT allows for stateless authentication between you and your endpoint. Learn how to use JWT with Quicknode in [this step-by-step guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-implement-json-web-tokens-jwt-authorization-with-quicknode).

### Multiple Authentication Tokens

Create multiple authentication tokens for each of your deployed endpoints. This allows you to revoke any tokens that may be comprised, without needing to restart your non-compromised endpoint.

To roll an individual authentication token, create an additional token and then delete the previous token. Learn more about multiple authentication tokens in [this Quicknode guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-set-up-multi-token-authentication-on-quicknode).

---

---
title: Fuel GraphQL API
description: Get started with Fuel GraphQL API on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Fuel GraphQL API

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Fuel GraphQL API](https://www.quicknode.com/chains/fuel) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=fuel)

Beta

Beta

## Fuel Overview

Fuel is a modular execution layer designed to scale Ethereum by separating transaction execution from consensus and data availability. At its core is the FuelVM, a purpose-built virtual machine that uses a UTXO model and parallel execution to process transactions concurrently across multiple CPU threads.

What distinguishes Fuel is its use of GraphQL instead of traditional JSON-RPC for blockchain interactions, offering more precise and flexible data querying. The platform also introduces Sway, a Rust-based smart contract language designed specifically for the FuelVM.

## Interacting with Fuel's APIs

Fuel does not use traditional JSON-RPC methods for blockchain interactions. Instead, it leverages GraphQL, which provides more flexible and precise data querying capabilities. This allows developers to request exactly the data they need in a single query, reducing overhead and improving efficiency.

The Quicknode Fuel documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Fuel documentation](https://docs.fuel.network/docs/graphql/overview/) for the latest updates and GraphQL query examples.

## Make Fuel API Calls

The quickest way to start building on Fuel is to create a Quicknode endpoint and send your first GraphQL request.

**Quicknode** provides managed Fuel endpoints, giving you immediate access to Fuel Mainnet and Sepolia Testnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/fuel/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Fuel networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 9889 | ✓ | ✗ | Yes | None |
| Sepolia | Testnet | 0 | ✓ | ✗ | Yes | None |

Complete reference for developers building on Fuel with Quicknode:

-   [QuickStart](/docs/fuel/quickstart): Get started with Fuel quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/fuel/endpoints): Learn how to configure and manage your Fuel endpoints for optimal performance and reliability.
-   [API Overview](/docs/fuel/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/fuel/add-ons): Discover endpoint add-ons that extend your Fuel development workflow.
-   [Endpoint Security](/docs/fuel/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.

---

---
title: GIWA RPC
description: Get started with GIWA RPC on Quicknode. Access Ethereum-compatible JSON-RPC, Debug, and Flashblocks APIs on GIWA Sepolia.
---

# GIWA RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [GIWA](https://www.quicknode.com/chains/giwa) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=giwa)

## What is GIWA?

GIWA is an Ethereum Layer 2 network built on the OP Stack. It executes transactions through an EVM-equivalent environment, uses ETH for transaction fees, and settles rollup data and state commitments to Ethereum.

GIWA produces blocks every second and provides Flashblocks-aware RPC access for applications that need preconfirmation data before the enclosing block is sealed. The network is developed with Upbit and is currently available through the GIWA Sepolia testnet.

## How GIWA differs from Ethereum

GIWA is EVM-equivalent, so most Ethereum contracts and developer tools work without modification. However, its Layer 2 architecture changes how blocks are produced, how cross-chain transactions behave, and when blocks reach finality.

| Characteristic | Ethereum | GIWA |
| --- | --- | --- |
| Block time | Approximately 12 seconds | Approximately 1 second |
| Block production | Proposers and validators | Sequencer |

Developers should also account for these Layer 2 behaviors:

-   **Bridging:** Deposits originate on Ethereum and update GIWA state, while withdrawals originate on GIWA and require proof and a fault-proof challenge period before finalization on Ethereum.
-   **Address aliasing:** When an Ethereum smart contract initiates a deposit transaction, GIWA records an aliased sender address on Layer 2. Cross-chain applications should not assume the Layer 1 and Layer 2 sender addresses are identical.
-   **Mempool access:** GIWA does not expose a public mempool. Pending transactions are visible to the sequencer, which currently prioritizes transactions by fee.
-   **Finality:** A GIWA block can be `unsafe` when produced by the sequencer, `safe` after its data is published to Ethereum, or `finalized` after the corresponding Ethereum block is finalized.

See the official [Ethereum and GIWA comparison](https://docs.giwa.io/giwa-chain/en/network-information/diffs-ethereum-giwa) for additional protocol details.

## Interacting with GIWA

GIWA exposes Ethereum-compatible JSON-RPC methods together with Debug and Flashblocks APIs. Existing Solidity contracts and Ethereum tooling can interact with GIWA by connecting to a GIWA endpoint.

With this API, you can:

-   Query blocks, transactions, receipts, account state, contract storage, and event logs
-   Submit signed transactions and simulate contract calls
-   Read preconfirmation state through Flashblocks-aware methods
-   Subscribe to real-time events via WebSocket connections

You can access the API by:

-   Using a hosted provider such as a **Quicknode GIWA endpoint**, which provides managed HTTP and WebSocket access without operating your own node

## Supported Networks

Quicknode provides access to the following GIWA networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Sepolia | Testnet | 91342 | ✓ | ✓ | Yes | None |

Complete reference for developers building on GIWA with Quicknode:

-   [QuickStart](/docs/giwa/quickstart): Get started with GIWA quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/giwa/endpoints): Learn how to configure and manage your GIWA endpoints for optimal performance and reliability.
-   [API Overview](/docs/giwa/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Endpoint Security](/docs/giwa/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/giwa/error-references): Understand common error codes and troubleshooting steps for GIWA API requests.

---

---
title: Gnosis RPC
description: Get started with Gnosis RPC on Quicknode. Access reliable, low-latency infrastructure for Gnosis Chain with globally distributed endpoints for stable, low-cost transactions.
---

# Gnosis RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Gnosis](https://www.quicknode.com/chains/xdai) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=gnosis)

## What is Gnosis Chain?

Gnosis Chain is an EVM-compatible blockchain that prioritizes stability, affordability, and decentralization. Originally launched as xDai Chain, it was rebranded as Gnosis Chain following its merge with the Gnosis ecosystem. The network uses xDai as its native token for gas fees, providing predictable and stable transaction costs.

Built on a Proof-of-Stake consensus mechanism, Gnosis Chain offers fast transaction confirmation times and extremely low fees, making it ideal for everyday transactions, payments, and applications requiring stable operating costs. The network maintains full Ethereum compatibility while providing a more accessible blockchain experience.

## Interacting with Gnosis

The Gnosis Chain is fully compatible with Ethereum's API, enabling developers to use existing Ethereum tools and libraries without modification. The API supports all standard Ethereum JSON-RPC methods, allowing developers to interact with smart contracts, transfer tokens, and build applications using familiar development environments.

With this API, you can:

-   Query blockchain state (blocks, transactions, receipts, logs)
-   Send transactions
-   Deploy and interact with smart contracts
-   Subscribe to real-time events (via WebSocket subscriptions such as eth_subscribe)

You can access the API by:

-   Running a local Gnosis client. You can learn how by looking at our node setup guides [here](https://www.quicknode.com/guides/infrastructure/node-setup/how-to-install-and-run-a-geth-node).
-   Using a hosted provider such as a **Quicknode Gnosis endpoint**, which delivers low-latency global access, archive data, and enhanced reliability out of the box.

## Supported Networks

Quicknode provides access to the following Gnosis networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 100 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Gnosis with Quicknode:

-   [QuickStart](/docs/gnosis/quickstart): Get started with Gnosis quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/gnosis/endpoints): Learn how to configure and manage your Gnosis endpoints for optimal performance and reliability.
-   [API Overview](/docs/gnosis/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/gnosis/add-ons): Discover endpoint add-ons that extend your Gnosis development workflow.
-   [Endpoint Security](/docs/gnosis/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/gnosis/error-references): Understand common error codes and troubleshooting steps for Gnosis API requests.

---

---
title: Gravity RPC
description: Get started with Gravity RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Gravity RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Gravity](https://www.quicknode.com/chains/gravity) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=gravity)

Beta

Beta

## Gravity Overview

Gravity is a Layer-1 blockchain designed as an omnichain settlement layer that enables applications to execute user intents across multiple blockchains. The platform focuses on full-chain abstraction, aiming to conceal the complexity of cross-chain interactions for users and developers.

Gravity is fully EVM-compatible, allowing developers to deploy and interact with smart contracts using existing Ethereum development tools and practices. The platform targets use cases like intent-based transactions, gas abstraction for multi-chain operations, and omnichain applications.

### Gravity Mainnet (L1)

The current Gravity Mainnet is an independent Layer-1 blockchain with chain ID **127001** (`0x1f019`). It runs on the Reth client and serves as the primary network for production deployments. This L1 architecture provides Gravity with full sovereignty over its consensus and execution layers.

### Gravity Alpha Mainnet (Legacy L2)

Gravity Alpha Mainnet was the original network launched in August 2024 as an Arbitrum Nitro-based Layer-2 with chain ID **1625** (`0x659`), settling to Ethereum. This network has been superseded by the new Gravity L1 Mainnet. Developers with existing deployments on Alpha Mainnet should plan to migrate to the new L1 Mainnet.

## Interacting with Gravity's APIs

Gravity supports standard Ethereum JSON-RPC methods, enabling developers to use Ethereum's native tools such as Hardhat, Foundry, and popular Web3 libraries without modification.

The Quicknode Gravity documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Gravity documentation](https://docs.gravity.xyz/) for the latest updates and features.

## Make Gravity API Calls

The quickest way to start building on Gravity is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Gravity endpoints, giving you immediate access to Gravity Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/gravity/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Gravity networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 127001 | ✓ | ✓ | Yes | None |
| Alpha Mainnet | Production | 1625 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Gravity with Quicknode:

-   [QuickStart](/docs/gravity/quickstart): Get started with Gravity quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/gravity/endpoints): Learn how to configure and manage your Gravity endpoints for optimal performance and reliability.
-   [API Overview](/docs/gravity/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/gravity/add-ons): Discover endpoint add-ons that extend your Gravity development workflow.
-   [Endpoint Security](/docs/gravity/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/gravity/error-references): Understand common error codes and troubleshooting steps for Gravity API requests.

---

---
title: Hedera RPC
description: Get started with Hedera RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Hedera RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Hedera](https://www.quicknode.com/chains/hedera) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=hedera)

## Hedera Overview

Hedera is a public distributed ledger that uses hashgraph consensus instead of traditional blockchain architecture. Rather than organizing transactions into sequential blocks, hashgraph employs a directed acyclic graph (DAG) structure with asynchronous Byzantine Fault Tolerance (aBFT). The network offers native services including the Hedera Token Service (HTS) for token creation, Hedera Consensus Service (HCS) for message ordering, Smart Contract Service for EVM compatibility, and File Service for decentralized storage.

Hedera provides dual execution environments for developers. The JSON-RPC Relay enables EVM compatibility with standard Ethereum tooling like Web3.js, Ethers, Hardhat, and Foundry, while native Hedera services can be accessed through official SDKs. Smart contracts can integrate with native services like HTS through system contracts, allowing hybrid applications that combine EVM functionality with Hedera specific capabilities.

## Interacting with Hedera's APIs

Hedera provides multiple API options for developers. The JSON-RPC Relay enables EVM compatibility for developers using standard Ethereum tools like Ethers.js, Viem, Hardhat, and Foundry. The Mirror Node REST API provides access to historical data, account information, and transaction queries. Native Hedera services can be accessed through official SDKs.

The Quicknode Hedera documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Hedera documentation](https://docs.hedera.com/) for the latest updates and features.

## Make Hedera API Calls

The quickest way to start building on Hedera is to create a Quicknode endpoint and send your first API request.

**Quicknode** provides managed Hedera endpoints, giving you immediate access to Hedera Mainnet and Testnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/hedera/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Hedera networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 295 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 296 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Hedera with Quicknode:

-   [QuickStart](/docs/hedera/quickstart): Get started with Hedera quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/hedera/endpoints): Learn how to configure and manage your Hedera endpoints for optimal performance and reliability.
-   [API Overview](/docs/hedera/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/hedera/add-ons): Discover endpoint add-ons that extend your Hedera development workflow.
-   [Endpoint Security](/docs/hedera/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/hedera/error-references): Understand common error codes and troubleshooting steps for Hedera API requests.

---

---
title: Hemi RPC
description: Get started with Hemi RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Hemi RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Hemi](https://www.quicknode.com/chains/hemi) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=hemi)

Beta

Beta

## Hemi Overview

Hemi is a modular Layer-2 protocol that integrates Bitcoin and Ethereum as unified components of a supernetwork. Rather than treating these blockchains as isolated ecosystems, Hemi embeds Bitcoin awareness directly into an Ethereum Virtual Machine, enabling developers to build applications that leverage both blockchains simultaneously. The platform uses Proof-of-Proof consensus to anchor transactions to Bitcoin's security model while maintaining Ethereum's execution layer familiarity.

Hemi provides two core technical components: the Hemi Virtual Machine (hVM) combines a full Bitcoin node within an EVM environment, and the Hemi Bitcoin Kit (hBK) grants smart contracts granular access to Bitcoin state. This architecture enables Bitcoin DeFi applications previously impractical through standard EVM implementations. As a fully EVM-compatible platform, Hemi allows developers to use standard Ethereum tooling like Hardhat, Foundry, and Web3 libraries while accessing cross-chain functionality through its Tunnels feature for trustless asset transfers.

## Interacting with Hemi's APIs

Hemi supports standard Ethereum JSON-RPC methods along with Debug APIs and OP-Node JSON-RPC API extensions, enabling developers to use Ethereum's native tools without modification. The platform maintains full compatibility with Solidity and existing Ethereum development workflows.

The Quicknode Hemi documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Hemi documentation](https://docs.hemi.xyz/) for the latest updates and features.

## Make Hemi API Calls

The quickest way to start building on Hemi is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Hemi endpoints, giving you immediate access to Hemi Testnet and Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/hemi/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Hemi networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 43111 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 743111 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Hemi with Quicknode:

-   [QuickStart](/docs/hemi/quickstart): Get started with Hemi quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/hemi/endpoints): Learn how to configure and manage your Hemi endpoints for optimal performance and reliability.
-   [API Overview](/docs/hemi/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/hemi/add-ons): Discover endpoint add-ons that extend your Hemi development workflow.
-   [Endpoint Security](/docs/hemi/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/hemi/error-references): Understand common error codes and troubleshooting steps for Hemi API requests.

---

---
title: Hyperliquid RPC
description: Get started with Hyperliquid on Quicknode. Access HyperEVM (smart contracts) and HyperCore (exchange data) through HTTP, WebSocket, and gRPC protocols.
---

# Hyperliquid RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Hyperliquid](https://www.quicknode.com/chains/hyperliquid) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=hyperliquid)

## Hyperliquid Overview

Hyperliquid is a blockchain designed for on-chain trading with speed and fees that approach centralized exchange performance. The architecture consists of two interconnected components:

**HyperCore** - The on-chain order book engine that manages trade execution and provides market data. HyperCore exposes multiple real-time data streams through gRPC, JSON-RPC/HTTP, and WebSocket APIs, with protocol availability varying by stream type (see [Available Data Streams](#available-data-streams) below).

**HyperEVM** - An EVM-compatible execution layer for smart contract deployment and interaction. Developers can launch new asset classes, build trading strategy vaults, create DeFi protocols, and manage digital assets using standard Ethereum JSON-RPC methods. HyperEVM supports all major Ethereum development tools including Foundry, Hardhat, Web3.js, Ethers.js, and Viem.

Both components operate under [HyperBFT](https://hyperliquid-co.gitbook.io/wiki/architecture/hyperbft) consensus (based on [HotStuff](https://github.com/hot-stuff/libhotstuff)) and use the native **HYPE** token for transaction fees.

### HyperCore Market Primitives

Hyperliquid defines distinct market types through Hyperliquid Improvement Proposals (HIPs):

-   **HIP-1 - Perpetual markets**: On-chain perpetual futures with isolated and cross-margin modes. Perp pairs appear as plain symbols (e.g., `BTC`, `ETH`) in the API.
-   **HIP-2 - Spot token listings**: Native spot markets for user-deployed tokens. Spot pairs use `@index` notation (e.g., `@107`) in the API.
-   **HIP-3 - Builder-deployed perpetuals**: Independent builders can deploy their own perp DEX on HyperCore with separate order books and collateral. Query builder DEXes by passing the `dex` parameter to info endpoints; use [`perpDexs`](/docs/hyperliquid/info-endpoints/perpDexs) to list all active ones.
-   **HIP-4 - Outcome markets**: Fully collateralized outcome contracts (binary and multi-price) settling within a fixed price range. Binary (`priceBinary`) markets settle Yes or No; multi-price (`priceBucket`) question markets group multiple binary sub-outcomes into price buckets so exactly one settles Yes. Outcome sides use `#N` notation (e.g., `#0` for Yes, `#1` for No of the first outcome). See [`outcomeMeta`](/docs/hyperliquid/info-endpoints/outcomeMeta) for the info endpoint.

Plan Requirement

Access to `/hypercore` (JSON-RPC and WebSocket) and HyperCore gRPC streaming requires a **Quicknode Build plan or higher**. [View pricing](https://www.quicknode.com/pricing) to upgrade.

## Interacting with Hyperliquid's APIs

HyperCore and HyperEVM are Hyperliquid-native protocol components available from any infrastructure provider. Quicknode provides managed access to both layers through a single endpoint, handling node infrastructure, reliability, and performance. In addition to the native APIs, Quicknode offers complementary products: [Streams](/docs/streams) (push-based HyperEVM event delivery), [Webhooks](/docs/webhooks) (HTTP event notifications), [SQL Explorer](/docs/sql-explorer) (SQL queries on indexed Hyperliquid data), [community SDKs](#supported-sdks), and [add-ons](https://www.quicknode.com/add-ons).

Quicknode provides access to both Hyperliquid components through specialized APIs designed for different use cases:

### HyperEVM APIs

HyperEVM supports standard Ethereum JSON-RPC methods, allowing developers to use familiar Ethereum tools like Foundry, Hardhat, and Web3 libraries without modification. Access HyperEVM through two specialized paths:

**`/evm` path** - Standard blockchain operations including account balances, transaction queries, smart contract calls (eth_call), gas estimation, and transaction broadcasting. This path is designed for read operations and high-frequency queries. **Note:** The `/evm` endpoint retains only recent block data and does not provide archival access. Queries for blocks older than the retention window will return errors. Use `/nanoreth` for historical data needs.

**`/nanoreth` path** - Provides all standard methods plus advanced debugging capabilities (debug_traceTransaction, debug_storageRangeAt), transaction tracing (trace_transaction, trace_block, trace_filter), WebSocket support for real-time blockchain events, and a full historical data archive. This path also supports historical eth_call queries on any block, whereas `/evm` only supports the latest block.

**Compatible with:** Foundry, Hardhat, Truffle, Web3.js, Ethers.js, Viem, Metamask, and all standard Ethereum development frameworks.

Due to Hyperliquid's architectural differences, some RPC methods may behave differently from Ethereum. We recommend cross-referencing with the official [Hyperliquid documentation](https://hyperliquid.gitbook.io/hyperliquid-docs) for the latest updates.

> **Cross-layer integration**: Smart contracts on HyperEVM can read HyperCore oracle prices. See our [guide on accessing HyperCore data from contracts](https://www.quicknode.com/guides/other-chains/hyperliquid/read-hypercore-oracle-prices-in-hyperevm).

### HyperCore APIs

HyperCore provides real-time and historical access to exchange data through multiple API protocols:

**Info Endpoint** (`/info` path) - Query comprehensive market data, user positions, order status, trading history, vault information, and exchange state through 73 specialized methods covering perpetual and spot markets. Quicknode's `/info` endpoint supports 71 of 73 methods natively; see the [Endpoints page](/docs/hyperliquid/endpoints#hypercore-info-endpoint) for details.

**REST API** - Trading operations (build and send orders with signatures), builder fee approval management, market discovery (list markets/DEXes, open orders, order status), and order validation (preflight). Supports order lifecycle management from building unsigned actions to submitting signed transactions, with enhanced endpoints for checking approval status and querying enriched order data.

  

Plan Requirement

If you are on a **free trial** plan, we provide a URL for you to use, but it is not specific to your Quicknode account. Please see [hyperliquidapi.com](https://hyperliquidapi.com) for details and our [Discord](https://discord.gg/quicknode) for support.

**JSON-RPC/HTTP** (`/hypercore` path) - Historical exchange data queries (hl_getLatestBlocks, hl_getBlock, hl_getBatchBlocks) for backfilling and batch processing of up to 200 blocks per request, plus portfolio and clearinghouse state queries (hl_portfolioState, hl_batchClearinghouseStates, hl_batchPortfolioStates) for retrieving positions, balances, and margin data for single or multiple users, and order data queries (hl_batchOpenOrders) for retrieving open orders for up to 100 users in a single request.

**gRPC Streaming** (port 10000) - Bidirectional streaming with sub-millisecond latency for market data. Supports all thirteen data streams with native zstd compression (reduces bandwidth by ~70%), including [`StreamL2Book`](/docs/hyperliquid/datasets/l2-book) (aggregated depth) and [`StreamL4Book`](/docs/hyperliquid/datasets/l4-book) (individual order) with built-in snapshots. Suitable for market makers, algorithmic trading systems, and real-time analytics applications requiring low latency.

**WebSocket** (`/hypercore/ws` path) - Browser-compatible real-time subscriptions using standard WebSocket libraries. JSON-based protocol with hl_subscribe and hl_unsubscribe methods. Supports six data streams (`TRADES`, `ORDERS`, `BOOK_UPDATES`, `TWAP`, `EVENTS`, `WRITER_ACTIONS`). `BLOCKS` and the `OrderBookStreaming` methods (`StreamL2Book`, `StreamL4Book`, `StreamBboBook`, `StreamL2BookDiff`, `StreamL4BookUpdates`, `StreamTpslUpdates`) are gRPC-only. Suitable for web-based trading dashboards, price monitors, and portfolio trackers.

### Available Data Streams

| Stream | Description | gRPC | WebSocket | JSON-RPC |
| --- | --- | --- | --- | --- |
| TRADES | Executed trades with maker/taker info | ✓ | ✓ | ✓ |
| ORDERS | Order lifecycle events (18+ status types) | ✓ | ✓ | ✓ |
| BOOK_UPDATES | Incremental order book changes | ✓ | ✓ | ✓ |
| TWAP | TWAP algorithm execution data | ✓ | ✓ | ✓ |
| EVENTS | Balance changes, transfers, liquidations | ✓ | ✓ | ✓ |
| WRITER_ACTIONS | HyperCore ↔ HyperEVM bridge data | ✓ | ✓ | ✓ |
| BLOCKS | Raw blockchain data (replica_cmds) | ✓ | \\- | \\- |
| StreamL2Book | Aggregated price-level depth (full snapshot every block) | ✓ | \\- | \\- |
| StreamL4Book | Individual order book (snapshot + diffs per block) | ✓ | \\- | \\- |
| StreamBboBook | Top-of-book best bid/ask, emitted only when the BBO changes | ✓ | \\- | \\- |
| StreamL2BookDiff | Incremental L2 price-level changes with per-coin sequence numbers | ✓ | \\- | \\- |
| StreamL4BookUpdates | Typed per-order add/update/remove diffs | ✓ | \\- | \\- |
| StreamTpslUpdates | Trigger (TP/SL) order add/remove updates with open-order snapshot | ✓ | \\- | \\- |
| MEMPOOL_TXS | Pending mempool transactions | ✓ | \\- | \\- |

All streams support filtering by user addresses, trading pairs, and more. Filter limits vary by plan tier.

Learn more about [HyperCore data streams and filtering](/docs/hyperliquid/datasets).

## Indexed Data & Analytics

For analytical workloads that span large time ranges, such as aggregated metrics, historical trades, funding rates, and liquidation history, Quicknode provides indexed and event-driven products that complement the native APIs above.

-   **[SQL Explorer](/docs/sql-explorer)**: Query pre-indexed Hyperliquid data with standard SQL, with no indexing pipeline to build or maintain. See the [Hyperliquid query examples](/docs/sql-explorer/hyperliquid-queries) and [schema reference](/docs/sql-explorer/schema-reference) to get started.
-   **[Streams](/docs/streams)**: Push-based delivery of real-time and historical HyperEVM data to your own destinations, with exactly-once guarantees and custom filtering.
-   **[Webhooks](/docs/webhooks)**: Trigger HTTP notifications on HyperEVM events to power event-driven workflows.

Use SQL Explorer for ad-hoc and historical analysis, and use Streams or Webhooks for continuous, event-driven data delivery.

## Supported SDKs

Quicknode maintains open-source community SDKs for Hyperliquid in multiple languages. These SDKs handle transaction building, signing, and submission for HyperCore trading operations and HyperEVM interactions.

Community SDKs

These open-source SDKs are developed and maintained by Quicknode. They are community-oriented and not affiliated with, endorsed by, or associated with Hyperliquid Foundation or Hyperliquid Labs.

**Available SDKs:**

-   **Python** - [hyperliquid-sdk on PyPI](https://pypi.org/project/hyperliquid-sdk/)
-   **TypeScript/JavaScript** - [@quicknode/hyperliquid-sdk on npm](https://www.npmjs.com/package/@quicknode/hyperliquid-sdk)
-   **Rust** - [quicknode-hyperliquid-sdk on crates.io](https://crates.io/crates/quicknode-hyperliquid-sdk)
-   **Go** - Available in the [SDK repository](https://github.com/quiknode-labs/hyperliquid-sdk)

All SDKs are open source and available on [GitHub](https://github.com/quiknode-labs/hyperliquid-sdk). The SDKs integrate with Quicknode endpoints for accessing `/info`, `/exchange`, `/evm`, `/nanoreth`, `/hypercore`, and gRPC streams. They can be used with or without a Quicknode endpoint.

**For detailed SDK documentation, examples, and setup guides, see the [SDKs & Libraries](/docs/hyperliquid/supported-hyperliquid-sdks) page.**

## Make Hyperliquid API Calls

To start building on Hyperliquid, create a Quicknode endpoint and access both HyperEVM and HyperCore services.

**Quicknode** provides managed Hyperliquid infrastructure, giving you access to both components without running your own nodes. These endpoints offer:

-   **Reliability** - Globally distributed infrastructure to minimize downtime
-   **Performance** - Low latency and request handling for production applications
-   **Dual-component access** - Single endpoint provides access to both HyperEVM (smart contracts via `/evm` and `/nanoreth`) and HyperCore (exchange data via `/hypercore` HTTP/WebSocket and gRPC)
-   **Multiple protocols** - HTTP, WebSocket, and gRPC streaming support
-   **Ecosystem integration** - Complementary products including [Streams](/docs/streams), [Webhooks](/docs/webhooks), and [SQL Explorer](/docs/sql-explorer). See [Indexed Data & Analytics](#indexed-data--analytics) above for details.

> Visit the [QuickStart](/docs/hyperliquid/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Hyperliquid networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 999 | ✓ | ✓ | Yes | See comment below\\* |
| Testnet | Testnet | 998 | ✓ | ✓ | Yes | See comment below\\* |

**\*Pruning Policy:**

**`/evm`** → Recent data only. The `/evm` endpoint does not provide archival access — older block data is periodically pruned (approximately every 12 hours). Requests for blocks outside the retention window will return an `invalid block height` error. Use `/nanoreth` for historical queries.

**`/nanoreth`** → Full historical archive with tracing support. Includes all debug and trace methods plus WebSocket functionality.

-   **Mainnet:** Full historical archive
-   **Testnet:** Starts from block 34112653 (not genesis)

**HyperCore Data Availability:**

`/info` (HTTP) - Comprehensive market data and user information via 73 info methods (meta, clearinghouseState, userFills, l2Book, portfolio, etc.)

`REST API` - Trading operations (build/send orders, cancel, modify), builder fee management (approve/revoke), market queries (list markets/DEXes, open orders, order status), and order validation (preflight)

`/hypercore` (HTTP) - Historical block queries (hl_getLatestBlocks, hl_getBlock, hl_getBatchBlocks), portfolio/clearinghouse state queries (hl_portfolioState, hl_batchClearinghouseStates, hl_batchPortfolioStates), and order data queries (hl_batchOpenOrders)

`/hypercore/ws` (WebSocket) - Real-time streaming for 6 data streams (TRADES, ORDERS, BOOK_UPDATES, TWAP, EVENTS, WRITER_ACTIONS)

`gRPC` - Real-time streaming for all 13 data streams with zstd compression support

  

Quick Reference

**HyperEVM:** `/evm` (HTTP only) • `/nanoreth` (HTTP + WebSocket + tracing/debugging)

**HyperCore:** `/info` (73 info methods) • `/hypercore/..` REST API (trading & market queries) • `/hypercore` (historical block queries) • `/hypercore/ws` WebSocket (6 streams) • gRPC (13 streams including `StreamL2Book`/`StreamL4Book` + compression)

Learn more about [HyperEVM and HyperCore endpoints](/docs/hyperliquid/endpoints)

### API Availability by Network

| API / Endpoint | Mainnet | Testnet |
| --- | --- | --- |
| HyperCore Info Endpoint (/info) | ✓ | ✓ |
| HyperCore Exchange API (/hypercore/\\*) | ✓ | ✗ |
| HyperCore JSON-RPC/WSS (/hypercore) | ✓ | ✓ |
| gRPC Streaming (port 10000) | ✓ | ✓ |
| HyperEVM (/evm) | ✓ | ✓ |
| Debug API (/nanoreth) | ✓ | ✓ |
| Trace API (/nanoreth) | ✓ | ✓ |

Complete reference for developers building on Hyperliquid with Quicknode:

-   [QuickStart](/docs/hyperliquid/quickstart): Get started with Hyperliquid quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/hyperliquid/endpoints): Learn how to configure and manage your Hyperliquid endpoints for optimal performance and reliability.
-   [API Overview](/docs/hyperliquid/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/hyperliquid/add-ons): Discover endpoint add-ons that extend your Hyperliquid development workflow.
-   [Endpoint Security](/docs/hyperliquid/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/hyperliquid/error-references): Understand common error codes and troubleshooting steps for Hyperliquid API requests.

---

---
title: Immutable zkEVM RPC
description: Get started with Immutable zkEVM RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Immutable zkEVM RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Immutable zkEVM](https://www.quicknode.com/chains/imx) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=immutable-zkevm)

## What is Immutable zkEVM?

Immutable zkEVM is an EVM-compatible Layer 2 chain built for gaming and digital assets. It uses zk-rollups to deliver low-cost, high-throughput transactions while inheriting the security of Ethereum. Because it’s fully EVM-compatible, developers can deploy existing Ethereum smart contracts and applications on Immutable zkEVM with little to no changes, making it an accessible and scalable platform for Web3 games.

## Interacting With Immutable zkEVM’s APIs

Immutable zkEVM is fully EVM-compatible. Its nodes expose a JSON-RPC interface that is compatible with Ethereum’s JSON-RPC API, allowing developers to use Ethereum’s native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification.

However, due to Immutable zkEVM’s architectural differences, some RPC methods may behave differently from those on Ethereum. The Quicknode Immutable zkEVM documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official Immutable zkEVM documentation](https://docs.immutable.com/docs/zkEVM/overview) for the latest updates and RPC differences.

* * *

## Make Immutable zkEVM API Calls

The quickest way to start building on Immutable zkEVM is to create a Quicknode endpoint and send your first request.

Quicknode provides managed Immutable zkEVM endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Archive data — full historical state for in-depth queries
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/immutable-zkevm/quickstart) page to create your endpoint and send your first request.

* * *

## Supported Networks

Quicknode provides access to multiple Immutable zkEVM networks.

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 13371 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 13473 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Immutable zkEVM with Quicknode:

-   [QuickStart](/docs/immutable-zkevm/quickstart): Get started with Immutable zkEVM quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/immutable-zkevm/endpoints): Learn how to configure and manage your Immutable zkEVM endpoints for optimal performance and reliability.
-   [API Overview](/docs/immutable-zkevm/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/immutable-zkevm/add-ons): Discover endpoint add-ons that extend your Immutable zkEVM development workflow.
-   [Endpoint Security](/docs/immutable-zkevm/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/immutable-zkevm/error-references): Understand common error codes and troubleshooting steps for Immutable zkEVM API requests.

---

---
title: Injective RPC
description: Get started with Injective RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Injective RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Injective](https://www.quicknode.com/chains/inj) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=injective)

Beta

Beta

## What is Injective?

Injective is a Layer 1 blockchain built for decentralized finance (DeFi). It provides core financial features like exchanges, derivatives, lending, staking, and oracles directly on-chain, so developers don’t need to build everything from scratch with complex smart contracts. Injective is built with the Cosmos SDK, giving it fast transaction finality and interoperability with other blockchains in the Cosmos ecosystem. It also offers a smooth, gas-free user experience, a built-in decentralized order book, support for smart contracts through CosmWasm, and tools for creating specialized blockchains tailored to unique applications.

## Interacting With Injective’s APIs

Injective nodes expose a JSON-RPC interface that is compatible with Ethereum’s JSON-RPC API. This means developers can use Ethereum’s native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification.

However, due to Injective’s architectural differences, some RPC methods may behave differently from those on Ethereum. The Quicknode Injective documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official Injective documentation](https://docs.injective.network) for the latest updates and RPC differences.

* * *

## Make Injective API Calls

The quickest way to start building on Injective is to create a Quicknode endpoint and send your first request.

Quicknode provides managed Injective endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/injective/quickstart) page to create your endpoint and send your first request.

* * *

## Supported Networks

Quicknode provides access to multiple Injective networks.

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 1776 | ✓ | ✓ | No | pruning-keep-recent = "1832727" and pruning-interval = "16" |
| Testnet | Testnet | 1439 | ✓ | ✓ | No | pruning-keep-recent = "1832727" and pruning-interval = "16" |

Archive Data Availability

Injective endpoints on Quicknode do not currently offer archive data. Nodes are configured with pruning, retaining approximately the most recent 1,832,727 blocks of state history. Queries for blocks or state outside the retained range will return an error.

To query data within the available range, use the `x-cosmos-block-height` header with REST API requests or specify the `height` parameter with Tendermint API requests. Ensure the block height used is within the recent pruning window.

**Cosmos REST API Example:**

```bash
curl --location 'https://docs-demo.injective-mainnet.quiknode.pro/cosmos/distribution/v1beta1/delegators/inj1jclptl8mx6vtc4l6mjv5smwdpxmc2pp3kelmjr/rewards' \

--header 'x-cosmos-block-height: 113823949'
```

**Tendermint API Example:**

```bash
curl --location 'https://docs-demo.injective-mainnet.quiknode.pro/block?height=113823949'
```

Complete reference for developers building on Injective with Quicknode:

-   [QuickStart](/docs/injective/quickstart): Get started with Injective quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/injective/endpoints): Learn how to configure and manage your Injective endpoints for optimal performance and reliability.
-   [API Overview](/docs/injective/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/injective/add-ons): Discover endpoint add-ons that extend your Injective development workflow.
-   [Endpoint Security](/docs/injective/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/injective/error-references): Understand common error codes and troubleshooting steps for Injective API requests.

---

---
title: Ink RPC
description: Get started with Ink RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Ink RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Ink](https://www.quicknode.com/chains/ink) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=ink)

Beta

Beta

## What is Ink?

Ink is an EVM-compatible Ethereum Layer 2 developed by Kraken, focused on fast, low-cost transactions with seamless Ethereum interoperability. It supports standard Ethereum JSON-RPC methods for building dapps and provides OP-Node–compatible endpoints to access rollup state, configuration, and synchronization data.

## Interacting With Ink APIs

Ink exposes Ethereum-compatible JSON-RPC and rollup-specific methods that allow developers to interact with the network programmatically. You can query blocks and transactions, deploy and interact with smart contracts, and access rollup status and configuration.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

* * *

## Make Ink API Calls

The quickest way to start building on Ink is to create a Quicknode endpoint and send your first request. Quicknode provides managed Ink endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/ink/quickstart) page to create your endpoint and send your first request.

* * *

## Supported Networks

Quicknode provides access to Ink Mainnet and Testnet.

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 57073 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 763373 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Ink with Quicknode:

-   [QuickStart](/docs/ink/quickstart): Get started with Ink quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/ink/endpoints): Learn how to configure and manage your Ink endpoints for optimal performance and reliability.
-   [API Overview](/docs/ink/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/ink/add-ons): Discover endpoint add-ons that extend your Ink development workflow.
-   [Endpoint Security](/docs/ink/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/ink/error-references): Understand common error codes and troubleshooting steps for Ink API requests.

---

---
title: Getting Started with the IPFS REST API
description: Getting Started with the IPFS REST API
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


Quicknode's decentralized storage solution allows you to upload, store, manage, and retrieve data on the [IPFS](https://ipfs.tech/), **InterPlanetary File System**, network. IPFS ensures data integrity, mitigates risks, and offers improved performance and resilience. With Quicknode's IPFS REST API, you can connect seamlessly to the IPFS network and utilize the following APIs:

-   **Gateway**: Create and manage gateway from the IPFS network through the gateway API.
-   **Pinning**: Pin, view and manage pinned content to ensure its availability.
-   **Account**: Fetch account usage information, including bandwidth and storage metrics.

## API Specifications (OpenAPI)

Download the machine-readable API specifications for use with compatible tooling (e.g. [Swagger Editor](https://editor.swagger.io/)).

  

-   [IPFS API (OpenAPI)](/docs/openapi/ipfs.openapi.json)

## The IPFS REST API Endpoint

To interact with the IPFS REST API, the following API endpoint is used:  

```bash
https://api.quicknode.com/ipfs/rest
```

### Authentication

To authenticate with the IPFS REST API, an API key is required to be sent with each request in the HTTP headers, you must first generate an [API key](https://dashboard.quicknode.com/api-keys). This key will serve as an authentication mechanism for your requests and should be included as an **x-api-key** header as shown below:

```bash
'x-api-key: your-api-key-here'
```

## Making IPFS REST API Requests

In this documentation, you will see example requests made with cURL and various programming languages for each supported IPFS method. This section will explain how to execute it on your machine.

### cURL

Most \*nix based systems have cURL support out of the box. cURL is a command line tool and library for transferring data with URLs. Check if you have it by running the following:

```text
curl -h
```

### Python

To run our Python code examples, you'll need to have Python installed as well as the requests package. You can install this package with the following command:

```python
python -m pip install requests
```

### JavaScript

To run our JavaScript code examples, you'll need to have Node v18 and up installed. You can follow this [official document](https://nodejs.org/en/download/) to install the latest, stable version of Node globally. Check if you have it by running the following:

```js
node -v
```

### Ruby

To run our Ruby code examples, you'll need to have Ruby installed. You can follow this [official installation document](https://www.ruby-lang.org/en/documentation/installation/) for more information. Check if you have it by running the following:

```text
ruby -v
```

To learn more about Quicknode Storage, check out the following guide: [How to Create and Host a Blog on IPFS using Quicknode Storage](https://www.quicknode.com/guides/quicknode-products/ipfs/how-to-create-and-host-a-blog-with-ipfs)

---

---
title: JOC RPC
description: Get started with Japan Open Chain RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# JOC RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [JOC](https://www.quicknode.com/chains/joc) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=joc)

## What is JOC?

Japan Open Chain (JOC) is a Layer 1 blockchain built on Go Ethereum that combines full Ethereum compatibility with a Proof of Authority consensus model operated by trusted Japanese enterprises. Unlike Layer 2 scaling solutions, JOC operates as an independent chain with 21 validators drawn from major Japanese companies including Sony subsidiaries, Dentsu, and NTT Group. This consortium approach balances developer accessibility through complete EVM compatibility with institutional reliability and regulatory compliance under Japanese law.

JOC provides developers with standard Ethereum JSON-RPC APIs and Debug APIs, making it accessible to the broader Web3 developer community. The network employs Proof of Authority consensus with validators generating blocks at 15-second intervals, achieving finality through validator signature majorities. The platform serves as infrastructure for regulated financial applications including stablecoins, remittance systems, and enterprise NFT projects, while maintaining core compatibility with Ethereum standards and tooling.

## Interacting with JOC's APIs

Japan Open Chain supports standard Ethereum JSON-RPC methods and Debug APIs, enabling developers to use Ethereum's native tools like Web3.js, Ethers, Hardhat, and Foundry without modification. The platform maintains full compatibility with EVM bytecode and accepts transactions formatted according to Ethereum specifications.

The Quicknode Japan Open Chain documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Japan Open Chain documentation](https://www.japanopenchain.org/docs/about/intro/) for the latest updates and features.

## Make JOC API Calls

The quickest way to start building on Japan Open Chain is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Japan Open Chain endpoints, giving you immediate access to JOC Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/joc/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Japan Open Chain networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 81 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Japan Open Chain with Quicknode:

-   [QuickStart](/docs/joc/quickstart): Get started with Japan Open Chain quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/joc/endpoints): Learn how to configure and manage your Japan Open Chain endpoints for optimal performance and reliability.
-   [API Overview](/docs/joc/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/joc/add-ons): Discover endpoint add-ons that extend your Japan Open Chain development workflow.
-   [Endpoint Security](/docs/joc/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/joc/error-references): Understand common error codes and troubleshooting steps for Japan Open Chain API requests.

---

---
title: Kaia RPC
description: Get started with Kaia RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Kaia RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Kaia](https://www.quicknode.com/chains/eth) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=kaia)

## Kaia Overview

Kaia is a Layer-1 blockchain utilizing an optimized Istanbul BFT consensus mechanism. Under the hood, the Kaia Virtual Machine (KVM) is EVM-compatible with support for all EVM opcodes and Kaia-specific precompiled contracts. Kaia also supports four different node types: Consensus Node (CN), which participates in block generation and validation; Proxy Node (PN), which provides network interfaces, transmits transactions, and propagates blocks; Endpoint Node (EN), which serves RPC API requests and handles data processing; and Bootnode, which facilitates new node discovery and network joining.

Its network is divided into three logical subnetworks, dividing responsibilities and operations. Its first subnetwork is called Core Cell Network (CCN), which is responsible for transaction execution, verification, and block creation. The subnetwork responsible for RPC requests is the Endpoint Node Network (ENN), while the Service Chain Network (SCN) is a sub-blockchain independently operated by dApps deployed on Kaia.

## Interacting with Kaia APIs

Kaia's KVM is fully EVM compatible, supporting standard Ethereum JSON-RPC methods. This allows developers to use familiar Ethereum development tools including Foundry, Hardhat, Remix, and popular Web3 libraries without modification. The KVM supports all standard EVM opcodes plus additional Kaia specific precompiled contracts for enhanced functionality.

For the most current information on Kaia specific features and RPC behavior, we recommend referencing the [official Kaia documentation](https://docs.kaia.io/) alongside our documentation.

## Making Kaia API Calls

The quickest way to start building on Hyperliquid is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Hyperliquid endpoints, giving you immediate access to the Hyperliquid Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

Visit the [QuickStart](https://www.quicknode.com/docs/kaia/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Kaia networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 8217 | ✓ | ✓ | Yes | None |
| Kairos Testnet | Testnet | 1001 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Kaia with Quicknode:

-   [QuickStart](/docs/kaia/quickstart): Get started with Kaia quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/kaia/endpoints): Learn how to configure and manage your Kaia endpoints for optimal performance and reliability.
-   [API Overview](/docs/kaia/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/kaia/add-ons): Discover endpoint add-ons that extend your Kaia development workflow.
-   [Endpoint Security](/docs/kaia/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/kaia/error-references): Understand common error codes and troubleshooting steps for Kaia API requests.

---

---
title: Katana RPC
description: Get started with Katana RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Katana RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Katana](https://www.quicknode.com/chains/katana) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=katana)

## Katana Overview

Katana is a DeFi-focused Ethereum Layer 2 built on the OP Stack and Polygon CDK. It is designed to provide high-throughput, low-cost infrastructure while concentrating liquidity and enabling sustainable yield for decentralized applications.

Katana uses **ETH** as its native gas token. The network leverages Ethereum for data availability and settlement, while integrating with AggLayer to enable seamless cross-chain interoperability and liquidity sharing.

Unlike general-purpose L2s, Katana is purpose-built for DeFi, featuring native yield-generating primitives and deeply integrated core applications to improve capital efficiency and user experience.

## Interacting with Katana APIs

Katana is EVM-equivalent and supports standard Ethereum JSON-RPC methods. Developers can use familiar tools like Hardhat, Foundry, Web3.js, and Ethers.js with minimal changes.

As an OP Stack-based chain, Katana follows the same RPC interface as other Optimism-compatible networks. This allows applications built for Ethereum or other OP Stack chains to be deployed on Katana with little to no modification.

The Quicknode Katana documentation is continuously evolving as the network undergoes upgrades. We recommend cross-referencing the official [Katana documentation](https://docs.katana.network/) for the latest updates and features.

## Make Katana API Calls

The quickest way to start building on Katana is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Katana endpoints, giving you immediate access to Katana Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production applications
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/katana/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Katana networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 747474 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Katana with Quicknode:

-   [QuickStart](/docs/katana/quickstart): Get started with Katana quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/katana/endpoints): Learn how to configure and manage your Katana endpoints for optimal performance and reliability.
-   [API Overview](/docs/katana/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/katana/add-ons): Discover endpoint add-ons that extend your Katana development workflow.
-   [Endpoint Security](/docs/katana/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/katana/error-references): Understand common error codes and troubleshooting steps for Katana API requests.

---

---
title: Getting Started with Key-Value Store
description: Getting Started with Key-Value Store
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


**Key-Value Store** is a robust data storage solution that enables you to manage extensive lists of datapoints, such as hundreds (or millions) of wallet addresses, and individual values. With Key-Value Store, you can update your lists and values on demand, manage and use them at any time via REST API or seamlessly within your Streams filter.

## Why Key-Value Store?

When you are dealing with large volumes of data, efficient storage and quick retrieval are critical. Key-Value Store seamlessly integrates with Streams, enabling you to easily evaluate your lists and values against streaming real-time and historical data with ease, manage your lists and values, and track datapoints block-over-block with high efficiency.

This solution is particularly useful for use cases that require tracking, updating and evaluating large datasets in real-time, such as:

-   Wallet and portfolio applications that want to track the activity of a large, dynamic list of wallet addresses
-   Tracking and checking token holdings
-   Applications that track and alert on changes in values over time

## Key-Value Store Features

  

-   **Scalable Data Management** - Manage, access, and evaluate large lists of data, such as millions of addresses or other data points, with ease.
-   **Real-Time Updates** - Update your data on demand and access it instantly.
-   **API Access** - Interact with your lists and values via REST API.
-   **Streams Integration** - Use Key-Value Store seamlessly within Streams filters for enhanced data processing capabilities.
-   **High Performance** - Key-Value Store features ultra-fast access time for efficient data lookup and updates.

## Example Use Cases

  

-   **Wallet Address Management:** Manage lists of wallet addresses to evaluate against streaming data.
-   **Historical Data Tracking:** Track values over time for various metrics.
-   **Data Analysis:** Calculate deltas and other statistics over large datasets.

By leveraging the Key-Value Store, you can enhance and customize Streams, enabling you to create more sophisticated, efficient, and responsive streaming datasets based on your specifications.

## Lists vs. Values: Choosing the Right Data Type

|  | **Lists** | **Values** |
| --- | --- | --- |
| **What it stores** | A named collection of string items under a single key | A single key-value pair |
| **Best for** | Membership checks (e.g., "is this address in my watchlist?") | Storing and retrieving individual data points |
| **Example** | A list called `watched_wallets` containing thousands of wallet addresses | A key called `lastProcessedBlock` with value `19271294` |
| **Streams function** | `qnContainsListItems`, `qnUpsertList`, `qnAddListItem` | `qnGetValue`, `qnAddValue`, `qnBulkValues` |

Use **lists** when you need to manage and evaluate a dynamic collection of items (e.g., wallet addresses, token contracts, account IDs) against streaming data. Use **values** when you need to store and retrieve individual data points that may change over time (e.g., tracking a running total, storing the last processed block number, caching a computed value between blocks).

## Feature Availability & Costs

Key-Value Store is available on all Quicknode plans. Beginning **September 1, 2026**, the following usage consumes API credits:

| Usage | Cost | Example |
| --- | --- | --- |
| Add an item to a list or create a value | 20 API credits per item created | [POST /values](/docs/key-value-store/rest-api/values/create-value) or [POST /lists/{key}/items](/docs/key-value-store/rest-api/lists/add-item-to-list). |
| Item storage | 10 API credits per item per month | Begins after an item is created and continues while it remains stored. |
| Make a Key-Value Store REST API request | 5 API credits per request | [GET /values/{key}](/docs/key-value-store/rest-api/values/retrieve-value) or [GET /lists/{key}](/docs/key-value-store/rest-api/lists/retrieve-list-by-key). |

The following methods do not consume API credits:

  

-   Comparing list items in Streams filters with [qnContainsListItem](/streams/filters/key-value-store#working-with-lists) or [qnContainsListItems](/streams/filters/key-value-store#working-with-lists).
-   Reading lists and values in Streams filters with [qnGetList](/streams/filters/key-value-store#working-with-lists) or [qnGetValue](/streams/filters/key-value-store#working-with-values).
-   [Using a Key-Value Store list with a Webhook](/docs/webhooks/rest-api/getting-started#using-list-references)

The free Streams filter methods above do not include Key-Value Store REST API requests.

To reduce storage charges, remove any lists, values, or items you no longer need in the [Key-Value Store dashboard](https://dashboard.quicknode.com/kvstore). For plan information, see the [pricing page](https://www.quicknode.com/pricing).

### Limits

You can store **millions of items** in a list. The following per-item size limits apply:

| Item | Maximum size |
| --- | --- |
| List item | 128 characters |
| List name (key) | 256 characters |
| Value key | 255 characters |
| Value | 800,000 characters |

Performance

List size does not impact lookup performance. `qnContainsListItems` maintains consistent performance even for very large lists (100k+ items). For best results, batch all membership checks into as few `qnContainsListItems` calls as possible to minimize round trips.

## Access

Access Key-Value Store within Streams in the [Quicknode Developer Portal](https://dashboard.quicknode.com/streams), and via [Key-Value Store REST API](/docs/key-value-store/rest-api/getting-started).

## Using Key-Value Store with Streams filters

  

Note

Key-Value Store items are **case-sensitive**. This is particularly important to remember when working with blockchain addresses, as they must be entered exactly as they appear onchain.

Key-Value Store can be accessed and managed seamlessly within a Streams filter. You can create new lists and values, add and remove items from your lists, update values, and evaluate your Key-Value Store data against streaming blockchain data.

Terminology

In Key-Value Store, a **value** refers to a single key-value pair. A **list** is a named collection of string items associated with a single key.

Use **lists** when you want to associate many values to one key, for instance you could manage and evaluate a large list of wallet addresses by adding them as `items` to a list called `addresses`.

Use **values** when you want to store datapoints for easy retrieval and updating, for instance you could calculate the average gas price in a block and store the value with the key `gasPrice`, and then retrieve it in the next block to calculate the delta.

## Available Key-Value Store Functions inside your Streams Filter

The functions below are the **Go** methods available on the `qn` filter context. For the JavaScript equivalents (the `qnLib.*` API), see the [Streams Filters documentation](/docs/streams/filters#using-key-value-store-with-streams-filters).

### Lists

  

-   **`qn.ContainsListItem(listName, item)`**: Checks whether a single item is in a list. Returns `bool`.
-   **`qn.ContainsListItems(listName, items)`**: Batch membership check for many items; returns a `[]bool` aligned with `items`. Batch all lookups into as few calls as possible to reduce round trips and improve performance.
-   **`qn.AddListItem(listName, item)`**: Adds an item to a list. Returns `error`.
-   **`qn.RemoveListItem(listName, item)`**: Removes an item from a list. Returns `error`.
-   **`qn.GetList(listName)`**: Retrieves every item in a list. Returns `([]string, error)`.
-   **`qn.DeleteList(listName)`**: Deletes a list. Returns `error`.

### Example Filter Code for Lists

For a complete working example demonstrating all list operations (`qn.ContainsListItem`, `qn.ContainsListItems`, `qn.AddListItem`, `qn.RemoveListItem`, `qn.GetList`, `qn.DeleteList`), see the [Streams Filters documentation](/docs/streams/filters#lists).

### Values

  

-   **`qn.GetValue(key)`**: Retrieves the value for a key. Returns `(string, error)`.
-   **`qn.AddValue(key, value)`**: Creates or updates a key-value pair. Returns `error`.
-   **`qn.DeleteValue(key)`**: Deletes a key-value pair. Returns `error`.

### Example Filter Code for Key-Value Store Values

For a complete working example demonstrating all value operations (`qn.GetValue`, `qn.AddValue`, `qn.DeleteValue`), see the [Streams Filters documentation](/docs/streams/filters#values-key-values).

* * *

---

---
title: Linea RPC
description: Get started with Linea RPC on Quicknode. Access reliable, low-latency infrastructure for Linea with globally distributed endpoints for ConsenSys.
---

# Linea RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Linea](https://www.quicknode.com/chains/linea) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=linea)

## What is Linea?

Linea is a zero-knowledge rollup (zkRollup) Layer 2 solution for Ethereum, developed by ConsenSys. It uses SNARK-based validity proofs to batch transactions off-chain and verify them on Ethereum mainnet, ensuring that all transactions are mathematically valid while inheriting Ethereum's security.

Unlike optimistic rollups, Linea does not require challenge periods for withdrawals because validity proofs provide immediate cryptographic certainty. Finality on Linea depends on proof submission intervals — typically minutes rather than days — but is still faster than optimistic rollups. Transaction costs are significantly reduced compared to Ethereum mainnet, with savings coming from transaction batching and calldata compression.

Linea emphasizes high compatibility with the Ethereum Virtual Machine (EVM). This zkEVM architecture (classified as a Type 2 zkEVM) supports nearly all EVM opcodes and precompiles, with only minor differences such as gas cost discrepancies. This ensures that most existing Ethereum smart contracts and applications can be deployed without modification, preserving strong compatibility with Ethereum's execution environment, tooling, and developer ecosystem. The system inherits Ethereum's base-layer security while providing zero-knowledge scaling benefits.

## Interacting with Linea

Linea extends the standard Ethereum JSON-RPC interface with additional Layer 2–specific functionality, while maintaining broad compatibility with existing Ethereum tooling. Developers can use Linea seamlessly with tools such as MetaMask, Hardhat, Foundry, and Web3 libraries without code changes.

With this API, you can:

-   Execute all standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, eth_getBalance)
-   Use Linea-specific API methods
-   Subscribe to real-time data via WebSocket connections

You can connect to the API by:

-   Running a local Linea node
-   Using a hosted provider such as a Quicknode Linea endpoint, which provides access to Linea Mainnet with high reliability, archive data, and enhanced performance

## Supported Networks

Quicknode provides access to the following Linea networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 59144 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Linea with Quicknode:

-   [QuickStart](/docs/linea/quickstart): Get started with Linea quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/linea/endpoints): Learn how to configure and manage your Linea endpoints for optimal performance and reliability.
-   [API Overview](/docs/linea/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/linea/add-ons): Discover endpoint add-ons that extend your Linea development workflow.
-   [Endpoint Security](/docs/linea/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/linea/error-references): Understand common error codes and troubleshooting steps for Linea API requests.

---

---
title: Lisk RPC
description: Get started with Lisk RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Lisk RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Lisk](https://www.quicknode.com/chains/lisk) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Start building](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=lisk)[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

## Overview

At Quicknode, we’re committed to helping developers and enterprises explore and build on the latest and most innovative blockchain networks. [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains) offer a flexible, on-demand infrastructure that supports emerging chains, enabling users to access a broader range of networks with high potential.

With [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains), developers can:

-   Build and innovate on cutting-edge, high-potential chains.
-   Unlock new opportunities within Web3 ecosystems.
-   Leverage Quicknode’s industry-leading reliability and performance without waiting for full infrastructure deployment.

[**Lisk**](https://lisk.com/) is a blockchain platform enabling scalable and interoperable dApps using JavaScript and TypeScript. Secured by Delegated Proof of Stake (DPoS), Lisk offers a developer-friendly SDK for building custom blockchain applications. Its interoperability protocol ensures seamless communication between blockchains, fostering innovation and adoption in the blockchain ecosystem.

  

Info

To learn more about Select Access Chains, check out this blog on [Introducing Select Access Chains: Your Chain, Your Choice](https://blog.quicknode.com/introducing-select-access-chains/)

## Access

You can access Lisk through the [Quicknode Developer Portal](https://dashboard.quicknode.com).

For enterprises with unique needs or large-scale projects, Quicknode offers custom solutions tailored to specific requirements. Our team is ready to collaborate with you to ensure you have the infrastructure, support, and resources necessary for success in the expanding blockchain ecosystem. Talk with our team to [create a custom plan today](https://www.quicknode.com/contact-us).

## Lisk Network Support

| Network | WSS | HTTPS |
| --- | --- | --- |
| MAINNET | ✅ | ✅ |

## Lisk JSON-RPC API Documentation

For detailed API documentation and usage guides, please refer to the [official Lisk documentation](https://docs.lisk.com/docs).

## Lisk Tools and Resources

| **Resource** | **Description** | **Link/Details** |
| --- | --- | --- |
| **Chain ID** | The unique identifier for the Lisk network. | Mainnet: 1135, Testnet: 4202 |
| **Currency Symbol** | The symbol representing the native currency for transactions on Lisk. | ETH |
| **Lisk Explorer** | A blockchain explorer to view transactions, blocks, and network activity on Lisk. | Mainnet: [https://blockscout.lisk.com](https://blockscout.lisk.com) Testnet: [https://sepolia-blockscout.lisk.com](https://sepolia-blockscout.lisk.com) |
| **Lisk Status Page** | Provides real-time updates on Lisk’s network status, uptime, and incidents. | [https://status.lisk.com/](https://status.lisk.com/) |

## API Credits

Usage in our pricing plans is measured in API Credits. To learn more about the API Credits for Lisk, please visit [this page](https://www.quicknode.com/api-credits/lisk).

## WebSocket Limits

WebSocket responses are capped at a certain limit, which is subject to change. In cases where responses are potentially large, it is recommended to use a **POST** request. If the response size exceeds the limit, the associated error code will be **\-32616**.

## Endpoint Authentication Options

  

Note:

Please note that setting JWT (JSON Web Tokens), configuring all whitelist options, and changing any rate limits beyond credits per second are only available to users on the **Build plan and higher**. Users on the **Free Trial** plan can only change their requests per second rate limit or add, use, and delete an authentication token. Visit [our pricing](https://www.quicknode.com/pricing) page for more information.

### Token Authentication

By default, all endpoints created on Quicknode are protected by a token in the URL which looks something like this:

  

```
http://sample-endpoint-name.network.quiknode.pro/token-goes-here/
```

### Approved Referrer List

For endpoints on the shared network, you are able to add a list of approved referrers. This requires any HTTP request to send a **REFERRER** header or any WebSocket request to send an **ORIGIN** header populated with one of the referrers you entered into our user panel.

### Disabling Token Authentication

You can also disable the token authentication completely in your security settings for a given endpoint. This will allow anyone to make requests to the endpoint without the token.

### JWT (JSON Web Tokens)

For additional security, you can also enable JWT for each of your deployed endpoints. JWT allows for stateless authentication between you and your endpoint. Learn how to use JWT with Quicknode in [this step-by-step guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-implement-json-web-tokens-jwt-authorization-with-quicknode).

### Multiple Authentication Tokens

Create multiple authentication tokens for each of your deployed endpoints. This allows you to revoke any tokens that may be comprised, without needing to restart your non-compromised endpoint.

To roll an individual authentication token, create an additional token and then delete the previous token. Learn more about multiple authentication tokens in [this Quicknode guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-set-up-multi-token-authentication-on-quicknode).

---

---
title: Litecoin RPC
description: Get started with Litecoin RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Litecoin RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Litecoin](https://www.quicknode.com/chains/litecoin) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Start building](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=litecoin)[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

## Overview

At Quicknode, we’re committed to helping developers and enterprises explore and build on the latest and most innovative blockchain networks. [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains) offer a flexible, on-demand infrastructure that supports emerging chains, enabling users to access a broader range of networks with high potential.

With [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains), developers can:

-   Build and innovate on cutting-edge, high-potential chains.
-   Unlock new opportunities within Web3 ecosystems.
-   Leverage Quicknode’s industry-leading reliability and performance without waiting for full infrastructure deployment.

[Litecoin](https://litecoin.info/docs) is a digital currency enabling instant, near-zero cost payments globally. It is built on an open-source foundation and operates on a fully decentralized payment network. Secured by cryptography, Litecoin empowers individuals with full control over their finances.

  

Info

To learn more about Select Access Chains, check out this blog on [Introducing Select Access Chains: Your Chain, Your Choice](https://blog.quicknode.com/introducing-select-access-chains/)

## Access

You can access Litecoin through the [Quicknode Developer Portal](https://dashboard.quicknode.com).

For enterprises with unique needs or large-scale projects, Quicknode offers custom solutions tailored to specific requirements. Our team is ready to collaborate with you to ensure you have the infrastructure, support, and resources necessary for success in the expanding blockchain ecosystem. Talk with our team to [create a custom plan today](https://www.quicknode.com/contact-us).

## Litecoin Network Support

Quicknode provides access to the following Litecoin networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | Yes | None |
| Testnet | Testnet | ✓ | ✗ | Yes | None |

## Litecoin JSON-RPC API Documentation

For detailed API documentation and usage guides, please refer to the [official Litecoin documentation](https://litecoin.info/docs).

## Litecoin Tools and Resources

| **Resource** | **Description** | **Link/Details** |
| --- | --- | --- |
| **Currency Symbol** | The symbol representing the native currency for transactions on Litecoin. | LTC |
| **Litecoin Explorer** | A blockchain explorer to view transactions, blocks, and network activity on Litecoin. | Mainnet: [https://litecoinspace.org/](https://litecoinspace.org/) |
| **Litecoin Status Page** | Provides real-time updates on Litecoin’s network status, uptime, and incidents. | [https://statusgator.com/services/ledger/litecoin-ltc](https://statusgator.com/services/ledger/litecoin-ltc) |

## API Credits

Usage in our pricing plans is measured in API Credits. To learn more about the API Credits for Litecoin, please visit [this page](https://www.quicknode.com/api-credits/litecoin).

## Endpoint Authentication Options

  

Note:

Please note that setting JWT (JSON Web Tokens), configuring all whitelist options, and changing any rate limits beyond credits per second are only available to users on the **Build plan and higher**. Users on the **Free Trial** plan can only change their requests per second rate limit or add, use, and delete an authentication token. Visit [our pricing](https://www.quicknode.com/pricing) page for more information.

### Token Authentication

By default, all endpoints created on Quicknode are protected by a token in the URL which looks something like this:

  

```
http://sample-endpoint-name.network.quiknode.pro/token-goes-here/
```

### Approved Referrer List

For endpoints on the shared network, you are able to add a list of approved referrers. This requires any HTTP request to send a **REFERRER** header or any WebSocket request to send an **ORIGIN** header populated with one of the referrers you entered into our user panel.

### Disabling Token Authentication

You can also disable the token authentication completely in your security settings for a given endpoint. This will allow anyone to make requests to the endpoint without the token.

### JWT (JSON Web Tokens)

For additional security, you can also enable JWT for each of your deployed endpoints. JWT allows for stateless authentication between you and your endpoint. Learn how to use JWT with Quicknode in [this step-by-step guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-implement-json-web-tokens-jwt-authorization-with-quicknode).

### Multiple Authentication Tokens

Create multiple authentication tokens for each of your deployed endpoints. This allows you to revoke any tokens that may be comprised, without needing to restart your non-compromised endpoint.

To roll an individual authentication token, create an additional token and then delete the previous token. Learn more about multiple authentication tokens in [this Quicknode guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-set-up-multi-token-authentication-on-quicknode).

---

---
title: Mantle RPC
description: Get started with Mantle RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Mantle RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Mantle](https://www.quicknode.com/chains/mantle) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=mantle)

## Mantle Overview

Mantle Network is an EVM-compatible scaling solution for Ethereum built as an optimistic rollup with a modular architecture.

Under the hood, Mantle separates transaction execution, consensus, settlement, and storage into individual modules. Its core infrastructure includes an EVM-compatible execution layer for transaction execution, consensus and settlement layers completed on Ethereum, and an external data availability component powered by Mantle DA (data availability).

Mantle utilizes Ethereum validators and consensus protocols, with L2 state transitions verified by Ethereum validators through the same consensus and settlement processes as L1 transactions. Users can customize transaction confirmation requirements for low confirmation latency.

## Interacting with Mantle APIs

Mantle supports standard Ethereum JSON-RPC methods, allowing developers to use familiar Ethereum development tools and libraries without modification. All contracts and tools running on Ethereum can operate on Mantle Network with minimal changes.

For the most current information on Mantle specific features and RPC behavior, we recommend referencing the [official Mantle documentation](https://docs.mantle.xyz/network) alongside our documentation.

## Making API Requests on Mantle

The quickest way to start building on Mantle is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Mantle endpoints, giving you immediate access to Mantle Mainnet and Sepolia without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

Visit the [QuickStart](https://www.quicknode.com/docs/mantle/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Mantle networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 5000 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 5001 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Mantle with Quicknode:

-   [QuickStart](/docs/mantle/quickstart): Get started with Mantle quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/mantle/endpoints): Learn how to configure and manage your Mantle endpoints for optimal performance and reliability.
-   [API Overview](/docs/mantle/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/mantle/add-ons): Discover endpoint add-ons that extend your Mantle development workflow.
-   [Endpoint Security](/docs/mantle/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/mantle/error-references): Understand common error codes and troubleshooting steps for Mantle API requests.

---

---
title: MegaETH RPC
description: Get started with MegaETH RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# MegaETH RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [MegaETH](https://www.quicknode.com/chains/megaeth) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=megaeth)

Beta

Beta

## MegaETH Overview

MegaETH is a high-performance blockchain platform featuring MegaEVM, an advanced execution environment built on Ethereum standards. The latest hardfork, **Rex**, is based on Optimism Isthmus (derived from Ethereum Prague), ensuring broad smart contract compatibility with the Ethereum ecosystem.

MegaETH is EVM-compatible, allowing most existing Ethereum-based Solidity contracts to run with minimal or no changes. All standard development tools like **Hardhat**, **Foundry**, and **Remix** work seamlessly. Key enhancements include a multidimensional gas model (separating compute and storage costs), higher contract limits (512 KB vs Ethereum's 24 KB), and advanced resource management. Note that contracts using deprecated opcodes like SELFDESTRUCT or relying on specific gas mechanics may require adjustments.

## Interacting with MegaETH's APIs

MegaETH nodes expose a JSON-RPC interface that is compatible with Ethereum's JSON-RPC API. This means developers can use Ethereum's native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification.

However, due to MegaETH's architectural differences (including its multidimensional gas model and enhanced contract limits), some RPC methods may behave differently from those on Ethereum. We highly recommend cross-referencing with the official [MegaETH documentation](https://docs.megaeth.com/megaevm) for the latest updates and technical specifications.

## Make MegaETH API Calls

The quickest way to start building on MegaETH is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed MegaETH endpoints, giving you immediate access to the MegaETH Mainnet and Testnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/megaeth/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following MegaETH networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 4326 | ✓ | ✓ | No | Block and transaction data retained indefinitely; historical state data pruned with ~15-day retention window |

## Data Availability & Pruning Policy

Quicknode's MegaETH nodes run with `--prune.policy=full`, which applies a **~15-day (1,296,064-block) retention window** for certain data categories. Here's what this means for data availability:

**Available indefinitely:**

-   **Block data** — Block headers and bodies are never pruned. Methods like `eth_getBlockByNumber` and `eth_getBlockByHash` work for all historical blocks.
-   **Transaction data** — Transaction records and hash-to-block lookups are retained indefinitely. Methods like `eth_getTransactionByHash` work for all historical transactions.

**Subject to ~15-day retention window:**

-   **Receipt data** — Transaction receipts (`eth_getTransactionReceipt`, `eth_getBlockReceipts`) are pruned from the database after ~15 days but are also persisted in static files.
-   **Historical state queries** — Methods that require account or storage history at a past block (e.g., `eth_call`, `eth_getBalance`, `eth_getStorageAt`, `eth_getCode`, `eth_getTransactionCount` with a historical block number) are limited to the ~15-day pruning window. Queries for state older than ~15 days may return errors or incomplete data.

Pruning Details

The following data categories are pruned under the `full` policy:

-   `account_history` — account state change sets (~15-day window)
-   `storage_history` — storage state change sets (~15-day window)
-   `receipts` — transaction receipts (~15-day window)
-   `salt_history` — salt change sets (~15-day window)
-   `withdrawal_history` — (~90-day window)
-   `sender_recovery` — fully pruned

The following are **never pruned**: `headers`, `transactions`, `transaction_lookup`, `bodies_history`.

Complete reference for developers building on MegaETH with Quicknode:

-   [QuickStart](/docs/megaeth/quickstart): Get started with MegaETH quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/megaeth/endpoints): Learn how to configure and manage your MegaETH endpoints for optimal performance and reliability.
-   [API Overview](/docs/megaeth/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/megaeth/add-ons): Discover endpoint add-ons that extend your MegaETH development workflow.
-   [Endpoint Security](/docs/megaeth/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/megaeth/error-references): Understand common error codes and troubleshooting steps for MegaETH API requests.

---

---
title: Moca RPC
description: Get started with Moca RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Moca RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Moca](https://www.quicknode.com/chains/moca) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=moca)

Beta

Beta

## What is Moca?

Moca Network is a chain-agnostic decentralized identity network with privacy-preserving infrastructure. The network provides users with ownership and control over their digital identity data across applications and blockchain ecosystems.

Moca Network consists of two primary components: **Moca Chain**, a decentralized blockchain providing interoperable and programmable identity storage, and **AIR Kit**, an SDK for integrating decentralized identity features into applications. The network uses $MOCA Coin as its utility and governance token.

## Interacting With Moca's APIs

Moca Chain provides JSON-RPC API access for developers building decentralized identity applications and integrations. The blockchain layer enables:

-   **Identity Storage**: Secure, decentralized storage of user identity data with privacy-preserving mechanisms
-   **Proof Verification**: Users can present proofs about themselves (age, qualifications, memberships) without exposing sensitive personal data
-   **Cross-Chain Interoperability**: Chain-agnostic architecture allowing identity to work across multiple blockchain ecosystems
-   **Zero-Knowledge Proofs**: Privacy-preserved verification mechanisms utilizing zero-knowledge proof technology

Developers can interact with Moca Chain using standard JSON-RPC interfaces, while the AIR Kit SDK provides higher-level abstractions for identity integration. The Quicknode Moca documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the [official Moca documentation](https://docs.moca.network) for the latest updates and feature additions.

## Make Moca API Calls

To start building on Moca, create a Quicknode endpoint and send your first request.

Quicknode provides managed Moca endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Low latency — optimized routing for fast identity verification and data retrieval
-   Enhanced performance — optimized request handling for production-grade identity applications

Visit the [QuickStart](/docs/moca/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the Moca network listed below:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Testnet | Testnet | 10904 | ✓ | ✓ | No | pruning-keep-recent = "550000" and pruning-interval = "16" |

Complete reference for developers building on Moca with Quicknode:

-   [QuickStart](/docs/moca/quickstart): Get started with Moca quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/moca/endpoints): Learn how to configure and manage your Moca endpoints for optimal performance and reliability.
-   [API Overview](/docs/moca/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/moca/add-ons): Discover endpoint add-ons that extend your Moca development workflow.
-   [Endpoint Security](/docs/moca/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/moca/error-references): Understand common error codes and troubleshooting steps for Moca API requests.

---

---
title: Mode RPC
description: Get started with Mode RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Mode RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Mode](https://www.quicknode.com/chains/mode) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Start building](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=mode)[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

## Overview

At Quicknode, we’re committed to helping developers and enterprises explore and build on the latest and most innovative blockchain networks. [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains) offer a flexible, on-demand infrastructure that supports emerging chains, enabling users to access a broader range of networks with high potential.

With [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains), developers can:

-   Build and innovate on cutting-edge, high-potential chains.
-   Unlock new opportunities within Web3 ecosystems.
-   Leverage Quicknode’s industry-leading reliability and performance without waiting for full infrastructure deployment.

[**Mode**](https://www.mode.network/) is a decentralized finance (DeFi) platform built as a Layer 2 solution on the Ethereum blockchain, utilizing Optimism's OP Stack technology. It aims to offer scalability and cost-efficiency, making it particularly attractive for developers and users in the DeFi space.

  

Info

To learn more about Select Access Chains, check out this blog on [Introducing Select Access Chains: Your Chain, Your Choice](https://blog.quicknode.com/introducing-select-access-chains/)

## Access

You can access Mode through the [Quicknode Developer Portal](https://dashboard.quicknode.com).

For enterprises with unique needs or large-scale projects, Quicknode offers custom solutions tailored to specific requirements. Our team is ready to collaborate with you to ensure you have the infrastructure, support, and resources necessary for success in the expanding blockchain ecosystem. Talk with our team to [create a custom plan today](https://www.quicknode.com/contact-us).

## Mode Network Support

| Network | WSS | HTTPS |
| --- | --- | --- |
| MAINNET | ✅ | ✅ |

## Mode JSON-RPC API Documentation

For detailed API documentation and usage guides, please refer to the [official Mode documentation](https://docs.mode.network/).

## Mode Tools and Resources

| **Resource** | **Description** | **Link/Details** |
| --- | --- | --- |
| **Chain ID** | The unique identifier for the Mode network. | Mainnet: 34443, Sepolia: 919 |
| **Currency Symbol** | The symbol representing the native currency for transactions on Mode. | ETH |
| **Mode Explorer** | A blockchain explorer to view transactions, blocks, and network activity on Mode. | Mainnet: [https://explorer.mode.network/](https://explorer.mode.network/) Sepolia: [https://sepolia.explorer.mode.network/](https://sepolia.explorer.mode.network/) |
| **Mode Status Page** | Provides real-time updates on Mode’s network status, uptime, and incidents. | [https://explorer.mode.network/stats](https://explorer.mode.network/stats) |

## API Credits

Usage in our pricing plans is measured in API Credits. To learn more about the API Credits for Mode, please visit [this page](https://www.quicknode.com/api-credits/mode).

## WebSocket Limits

WebSocket responses are capped at a certain limit, which is subject to change. In cases where responses are potentially large, it is recommended to use a **POST** request. If the response size exceeds the limit, the associated error code will be **\-32616**.

## Endpoint Authentication Options

  

Note:

Please note that setting JWT (JSON Web Tokens), configuring all whitelist options, and changing any rate limits beyond credits per second are only available to users on the **Build plan and higher**. Users on the **Free Trial** plan can only change their requests per second rate limit or add, use, and delete an authentication token. Visit [our pricing](https://www.quicknode.com/pricing) page for more information.

### Token Authentication

By default, all endpoints created on Quicknode are protected by a token in the URL which looks something like this:

  

```
http://sample-endpoint-name.network.quiknode.pro/token-goes-here/
```

### Approved Referrer List

For endpoints on the shared network, you are able to add a list of approved referrers. This requires any HTTP request to send a **REFERRER** header or any WebSocket request to send an **ORIGIN** header populated with one of the referrers you entered into our user panel.

### Disabling Token Authentication

You can also disable the token authentication completely in your security settings for a given endpoint. This will allow anyone to make requests to the endpoint without the token.

### JWT (JSON Web Tokens)

For additional security, you can also enable JWT for each of your deployed endpoints. JWT allows for stateless authentication between you and your endpoint. Learn how to use JWT with Quicknode in [this step-by-step guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-implement-json-web-tokens-jwt-authorization-with-quicknode).

### Multiple Authentication Tokens

Create multiple authentication tokens for each of your deployed endpoints. This allows you to revoke any tokens that may be comprised, without needing to restart your non-compromised endpoint.

To roll an individual authentication token, create an additional token and then delete the previous token. Learn more about multiple authentication tokens in [this Quicknode guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-set-up-multi-token-authentication-on-quicknode).

---

---
title: Monad RPC
description: Get started with Monad RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Monad RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Monad](https://www.quicknode.com/chains/monad) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=monad)

Beta

Beta

## Monad Overview

Monad is a Layer 1 blockchain built to scale the Ethereum Virtual Machine (EVM), providing deterministic finality, low latency and low-cost transactions. It introduces **MonadBFT**, a consensus protocol inspired by [HotStuff](https://github.com/hot-stuff/libhotstuff), designed to increase block throughput and minimize the risk of chain forks.

Monad is fully EVM-compatible, allowing developers to deploy existing Ethereum-based applications without changes. Its native token, **Monad (MON)**, is used to pay for transaction fees.

## Interacting with Monad’s APIs

Monad nodes expose a JSON-RPC interface that is compatible with Ethereum’s JSON-RPC API. This means developers can use Ethereum’s native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification.

However, due to Monad’s architectural differences, some RPC methods may behave differently from those on Ethereum. The Quicknode [Monad documentation](https://docs.monad.xyz/) is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the official Monad documentation for the latest updates and [RPC differences](https://docs.monad.xyz/reference/rpc-differences).

## Make Monad API Calls

The quickest way to start building on Monad is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed Monad endpoints, giving you immediate access to the Monad Mainnet and Testnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/monad/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Monad networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 143 | ✓ | ✓ | Yes | Over 40,000 recent blocks available |
| Testnet | Testnet | 10143 | ✓ | ✓ | Yes | Over 40,000 recent blocks available |

Complete reference for developers building on Monad with Quicknode:

-   [QuickStart](/docs/monad/quickstart): Get started with Monad quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/monad/endpoints): Learn how to configure and manage your Monad endpoints for optimal performance and reliability.
-   [API Overview](/docs/monad/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/monad/add-ons): Discover endpoint add-ons that extend your Monad development workflow.
-   [Endpoint Security](/docs/monad/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/monad/error-references): Understand common error codes and troubleshooting steps for Monad API requests.

---

---
title: Morph RPC
description: Get started with Morph RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Morph RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Morph](https://www.quicknode.com/chains/eth) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=morph)

## Morph Overview

Morph is blockchain designed for finance. It aims to power payments that are used in real world financial activity.

Under the hood, Morph is an Optimistic zkEVM Ethereum Layer-2 solution that is fully EVM-compatible. Its core infrastructure is based on a decentralized sequencer network, an optimistic zkEVM with responsive validity proofs, and a modular rollup design.

The Morph ecosystem also offers tools such as Morph Pay, which is a payment service supporting identity verification and more. While, Morph Rails is a permissionless infrastructure stack for developers, providing different services enabling the real world finance use-cases.

## Interacting with Morph APIs

Morph supports standard Ethereum JSON-RPC methods, allowing developers to use familiar Ethereum development tools like Hardhat, Foundry, Remix, and Web3 libraries without modification.

For the most current information on Morph-specific features and RPC behavior, we recommend referencing the [official Morph documentation](https://docs.morph.network/docs/about-morph/user-navigation-page) alongside this guide.

## Making API Requests on Morph

The quickest way to start building on Morph is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Morph endpoints, giving you immediate access to the Morph Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

Visit the [QuickStart](https://www.quicknode.com/docs/morph/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Morph networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 2818 | ✓ | ✓ | Yes | None |
| Hoodi | Testnet | 2910 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Morph with Quicknode:

-   [QuickStart](/docs/morph/quickstart): Get started with Morph quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/morph/endpoints): Learn how to configure and manage your Morph endpoints for optimal performance and reliability.
-   [API Overview](/docs/morph/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/morph/add-ons): Discover endpoint add-ons that extend your Morph development workflow.
-   [Endpoint Security](/docs/morph/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/morph/error-references): Understand common error codes and troubleshooting steps for Morph API requests.

---

---
title: NEAR RPC
description: Get started with NEAR RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# NEAR RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [NEAR](https://www.quicknode.com/chains/near) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=near)

## NEAR Overview

NEAR is a Layer 1, proof-of-stake blockchain designed for scalability and developer experience. It utilizes Nightshade, a sharding technology that divides the network into multiple parallel shards to process transactions simultaneously, achieving ~600ms block times with 1.2s finality. NEAR features WebAssembly (WASM) runtime support for smart contracts written in Rust and JavaScript, with human-readable account names and developer-friendly gas fee sharing.

## Interacting With NEAR APIs

NEAR exposes JSON-RPC methods that allow developers to interact with the network programmatically. You can query blockchain state, send transactions, call smart contract methods, and access account information. Through this API, you can query account details and access keys, call view methods on smart contracts, submit transactions and track their status, and retrieve block and chunk information.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

The Quicknode NEAR documentation is continuously updated, but we recommend cross-referencing with the [official NEAR documentation](https://docs.near.org/api/rpc/introduction) for the latest API details.

## Make NEAR API Calls

The quickest way to start building on NEAR is to create a Quicknode endpoint and send your first request. Quicknode provides managed NEAR endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/near/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following NEAR networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✓ | Yes | None |
| Testnet | Testnet | ✓ | ✓ | Yes | None |

Complete reference for developers building on NEAR with Quicknode:

-   [QuickStart](/docs/near/quickstart): Get started with NEAR quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/near/endpoints): Learn how to configure and manage your NEAR endpoints for optimal performance and reliability.
-   [API Overview](/docs/near/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/near/add-ons): Discover endpoint add-ons that extend your NEAR development workflow.
-   [Endpoint Security](/docs/near/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.

---

---
title: Optimism RPC
description: Get started with Optimism RPC on Quicknode. Access reliable, low-latency infrastructure for Optimism with globally distributed endpoints for fast Layer 2 applications.
---

# Optimism RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Optimism](https://www.quicknode.com/chains/optimism) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=optimism)

## What is Optimism?

Optimism is a Layer 2 scaling solution for Ethereum that uses **optimistic rollup technology** to increase throughput while maintaining Ethereum's security. Optimism processes transactions off-chain and posts compressed transaction data to Ethereum mainnet, inheriting its security guarantees through a **7-day fraud proof window**.

Optimism implements the **Optimism Virtual Machine (OVM)**, which is EVM-equivalent at the bytecode level. The network uses **sequencers** to order transactions and produce blocks with **2-second block times**. The network supports **cross-chain messaging** through its native bridge contracts, allowing assets and data to move between L1 and L2. Optimism uses **ETH for gas fees** and implements the same account model and transaction types as Ethereum.

## Interacting with Optimism

The Optimism JSON-RPC API extends the standard Ethereum JSON-RPC interface with L2-specific functionality. Since Optimism maintains EVM equivalence, developers can use existing Ethereum tools and libraries without modification.

With this API, you can:

-   Execute all standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, eth_getBalance)
-   Access Optimism-specific methods for L2 operations and gas estimation
-   Query L1 to L2 message status and cross-chain transaction receipts
-   Retrieve L2 block and transaction data including L1 batch information
-   Subscribe to real-time events via WebSocket connections

You can access the API by:

-   Running a local Optimism node (op-node and op-geth)
-   Using a hosted provider such as a **Quicknode Optimism endpoint**, which provides instant access to mainnet and testnet with archive data support

## Supported Networks

Quicknode provides access to the following Optimism networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 10 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 11155420 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Optimism with Quicknode:

-   [QuickStart](/docs/optimism/quickstart): Get started with Optimism quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/optimism/endpoints): Learn how to configure and manage your Optimism endpoints for optimal performance and reliability.
-   [API Overview](/docs/optimism/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/optimism/add-ons): Discover endpoint add-ons that extend your Optimism development workflow.
-   [Endpoint Security](/docs/optimism/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/optimism/error-references): Understand common error codes and troubleshooting steps for Optimism API requests.

---

---
title: Osmosis RPC
description: Get started with Osmosis RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Osmosis RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Osmosis](https://www.quicknode.com/chains/osmosis) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Start building](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=osmosis)[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

## Overview

At Quicknode, we’re committed to helping developers and enterprises explore and build on the latest and most innovative blockchain networks. [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains) offer a flexible, on-demand infrastructure that supports emerging chains, enabling users to access a broader range of networks with high potential.

With [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains), developers can:

-   Build and innovate on cutting-edge, high-potential chains.
-   Unlock new opportunities within Web3 ecosystems.
-   Leverage Quicknode’s industry-leading reliability and performance without waiting for full infrastructure deployment.

[Osmosis](https://docs.osmosis.zone/overview/educate/osmosis) is an application-specific Layer 1 blockchain built using the Cosmos SDK. It enables custom AMMs (Automated Market Makers) and facilitates cross-chain DeFi through the Inter-Blockchain Communication (IBC) protocol. The Osmosis platform focuses on enabling highly customizable liquidity pools and incentivizes liquidity providers with OSMO, its native governance token. Its modular architecture allows developers to create and integrate decentralized exchanges (DEXs) tailored to specific needs.

  

Info

To learn more about Select Access Chains, check out this blog on [Introducing Select Access Chains: Your Chain, Your Choice](https://blog.quicknode.com/introducing-select-access-chains/)

## Access

You can access Osmosis through the [Quicknode Developer Portal](https://dashboard.quicknode.com).

For enterprises with unique needs or large-scale projects, Quicknode offers custom solutions tailored to specific requirements. Our team is ready to collaborate with you to ensure you have the infrastructure, support, and resources necessary for success in the expanding blockchain ecosystem. Talk with our team to [create a custom plan today](https://www.quicknode.com/contact-us).

## Osmosis Network Support

| Network | WSS | HTTPS |
| --- | --- | --- |
| MAINNET | ✅ | ✅ |

## Osmosis JSON-RPC API Documentation

For detailed API documentation and usage guides, please refer to the [official Osmosis documentation](https://docs.osmosis.zone/overview/endpoints/).

## Osmosis Tools and Resources

| **Resource** | **Description** | **Link/Details** |
| --- | --- | --- |
| **Chain ID** | The unique identifier for the Osmosis network. | Mainnet: osmosis-1, Testnet: osmo-test-5 |
| **Currency Symbol** | The symbol representing the native currency for transactions on Osmosis. | OSMO |
| **Osmosis Explorer** | A blockchain explorer to view transactions, blocks, and network activity on Osmosis. | Mainnet: [https://www.mintscan.io/osmosis](https://www.mintscan.io/osmosis)   Testnet: [https://testnet.mintscan.io/osmosis-testnet](https://testnet.mintscan.io/osmosis-testnet) |
| **Osmosis Status Page** | Provides real-time updates on Osmosis’s network status, uptime, and incidents. | [https://status.osmosis.zone/](https://status.osmosis.zone/) |
| **Supported Methods** | Supported methods for interacting with Osmosis’s network. | Tendermint RPC: [https://rpc-docs.osmosis.zone/](https://rpc-docs.osmosis.zone/)   Osmosis - gRPC Gateway docs : [https://lcd.osmosis.zone/swagger/](https://lcd.osmosis.zone/swagger/) |

## API Credits

Usage in our pricing plans is measured in API Credits. To learn more about the API Credits for Osmosis, please visit [this page](https://www.quicknode.com/api-credits/osmosis).

## WebSocket Limits

WebSocket responses are capped at a certain limit, which is subject to change. In cases where responses are potentially large, it is recommended to use a **POST** request. If the response size exceeds the limit, the associated error code will be **\-32616**.

## Endpoint Authentication Options

  

Note:

Please note that setting JWT (JSON Web Tokens), configuring all whitelist options, and changing any rate limits beyond credits per second are only available to users on the **Build plan and higher**. Users on the **Free Trial** plan can only change their requests per second rate limit or add, use, and delete an authentication token. Visit [our pricing](https://www.quicknode.com/pricing) page for more information.

### Token Authentication

By default, all endpoints created on Quicknode are protected by a token in the URL which looks something like this:

  

```
http://sample-endpoint-name.network.quiknode.pro/token-goes-here/
```

### Approved Referrer List

For endpoints on the shared network, you are able to add a list of approved referrers. This requires any HTTP request to send a **REFERRER** header or any WebSocket request to send an **ORIGIN** header populated with one of the referrers you entered into our user panel.

### Disabling Token Authentication

You can also disable the token authentication completely in your security settings for a given endpoint. This will allow anyone to make requests to the endpoint without the token.

### JWT (JSON Web Tokens)

For additional security, you can also enable JWT for each of your deployed endpoints. JWT allows for stateless authentication between you and your endpoint. Learn how to use JWT with Quicknode in [this step-by-step guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-implement-json-web-tokens-jwt-authorization-with-quicknode).

### Multiple Authentication Tokens

Create multiple authentication tokens for each of your deployed endpoints. This allows you to revoke any tokens that may be comprised, without needing to restart your non-compromised endpoint.

To roll an individual authentication token, create an additional token and then delete the previous token. Learn more about multiple authentication tokens in [this Quicknode guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-set-up-multi-token-authentication-on-quicknode).

---

---
title: Peaq RPC
description: Get started with Peaq RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Peaq RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Peaq](https://www.quicknode.com/chains/peaq) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=peaq)

Beta

Beta

## Peaq Overview

Peaq is a **Layer 1 blockchain built on Substrate** that focuses on decentralized physical infrastructure networks (DePIN) and Machine Real World Assets (RWAs). The platform uses **parallelized block production** and **asynchronous backing** to process transactions efficiently while operating as a Polkadot parachain.

Peaq provides **dual execution environments**—developers can deploy **EVM-based smart contracts** (Solidity) or **Substrate pallets** (Rust) depending on their needs. This architecture enables **cross-chain communication** through Polkadot's Cross-Consensus Messaging (XCM) protocol while maintaining compatibility with Ethereum development tooling like Hardhat, Foundry, and Web3 libraries.

## Interacting with Peaq's APIs

Peaq supports both Ethereum JSON-RPC methods for EVM compatibility and Polkadot JSON-RPC API for Substrate-native interactions. Developers can use standard Ethereum development tools or Polkadot ecosystem libraries to build and deploy applications on the network.

The Quicknode Peaq documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Peaq documentation](https://docs.peaq.xyz/) for the latest updates and features.

## Make Peaq API Calls

The quickest way to start building on Peaq is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Peaq endpoints, giving you immediate access to Peaq Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/peaq/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Peaq networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 3338 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Peaq with Quicknode:

-   [QuickStart](/docs/peaq/quickstart): Get started with Peaq quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/peaq/endpoints): Learn how to configure and manage your Peaq endpoints for optimal performance and reliability.
-   [API Overview](/docs/peaq/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/peaq/add-ons): Discover endpoint add-ons that extend your Peaq development workflow.
-   [Endpoint Security](/docs/peaq/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/peaq/error-references): Understand common error codes and troubleshooting steps for Peaq API requests.

---

---
title: Plasma RPC
description: Get started with Plasma RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Plasma RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Plasma](https://www.quicknode.com/chains/plasma) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=plasma)

Beta

Beta

## Plasma Overview

Plasma is a **Layer 2 scaling solution** built on Ethereum that enables high-throughput, low-cost transactions while inheriting the security of the Ethereum mainnet. The platform uses **child chains** and **fraud proofs** to process transactions efficiently while periodically committing state updates to the Ethereum blockchain.

Plasma provides **Ethereum-compatible smart contract execution** using standard Solidity development tools. This architecture enables **high transaction throughput** with significantly reduced gas costs compared to Ethereum mainnet, while maintaining compatibility with existing Ethereum development tooling like Hardhat, Foundry, and Web3 libraries.

## Interacting with Plasma's APIs

Plasma supports standard Ethereum JSON-RPC methods for full EVM compatibility. Developers can use familiar Ethereum development tools and libraries to build and deploy applications on the network with reduced costs and faster confirmation times.

The Quicknode Plasma documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official Plasma documentation for the latest updates and features.

## Make Plasma API Calls

The quickest way to start building on Plasma is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Plasma endpoints, giving you immediate access to Plasma networks without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/plasma/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Plasma networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Testnet | Testnet | 9746 | ✓ | ✓ | Yes | None |
| Mainnet | Production | 9745 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Plasma with Quicknode:

-   [QuickStart](/docs/plasma/quickstart): Get started with Plasma quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/plasma/endpoints): Learn how to configure and manage your Plasma endpoints for optimal performance and reliability.
-   [API Overview](/docs/plasma/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/plasma/add-ons): Discover endpoint add-ons that extend your Plasma development workflow.
-   [Endpoint Security](/docs/plasma/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/plasma/error-references): Understand common error codes and troubleshooting steps for Plasma API requests.

---

---
title: Polkadot RPC
description: Get started with Polkadot RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Polkadot RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Polkadot](https://www.quicknode.com/chains/dot) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=polkadot)

## Polkadot Overview

Polkadot operates as a **Layer 0 relay chain** that provides **shared security** and cross-chain communication for independent blockchains called **parachains**. Rather than each blockchain maintaining its own validator set, Polkadot's relay chain validators secure all connected parachains simultaneously. Interoperability occurs through **Cross-Consensus Messaging (XCM)**, enabling parachains to communicate while maintaining sovereignty.

Polkadot provides the **Substrate framework** for building custom blockchains. Developers write parachain runtime logic in **Rust** using Substrate's modular architecture. The platform exposes multiple API interfaces—the **Polkadot JSON-RPC API** for relay chain operations, **Substrate API Sidecar** for RESTful queries, and **Asset Hub API** for the system parachain that handles token transfers and NFT operations.

## Interacting with Polkadot's APIs

Polkadot supports JSON-RPC API methods for querying blockchain state and submitting transactions, Substrate API Sidecar for RESTful access to historical data and account information, and Asset Hub JSON-RPC API for parachain interactions. Developers can use Polkadot.js libraries or standard HTTP/WebSocket clients to communicate with Polkadot nodes.

The Quicknode Polkadot documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Polkadot documentation](https://wiki.polkadot.com/) for the latest updates and features.

## Make Polkadot API Calls

The quickest way to start building on Polkadot is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Polkadot endpoints, giving you immediate access to Polkadot Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/polkadot/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Polkadot networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✓ | Yes | None |

Network Access

Quicknode's Polkadot endpoint provides access to both AssetHub and Relaychain networks through a unified interface.

**AssetHub** handles most current operations including token transfers, NFT management, and parachain state queries. REST API calls target AssetHub by default:

```bash
# AssetHub (default)

curl 'https://your-endpoint.pro/blocks/head'
```

**Polkadot Relaychain** provides access to relay chain data, validator information, and historical records. Prefix REST API calls with `/rc` to access the relaychain:

```bash
# Polkadot Relaychain

curl 'https://your-endpoint.pro/rc/blocks/head'
```

JSON-RPC methods operate without network prefixes and maintain standard compatibility across both networks.

Complete reference for developers building on Polkadot with Quicknode:

-   [QuickStart](/docs/polkadot/quickstart): Get started with Polkadot quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/polkadot/endpoints): Learn how to configure and manage your Polkadot endpoints for optimal performance and reliability.
-   [API Overview](/docs/polkadot/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/polkadot/add-ons): Discover endpoint add-ons that extend your Polkadot development workflow.
-   [Endpoint Security](/docs/polkadot/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.

---

---
title: Polygon RPC
description: Get started with Polygon RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Polygon RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Polygon](https://www.quicknode.com/chains/polygon) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=polygon)

## Polygon Overview

Polygon PoS is an EVM-compatible, proof-of-stake sidechain for Ethereum . The Polygon Proof-of-Stake (PoS) network is designed to address scalability challenges within the Ethereum ecosystem and consists of a consensus layer called Heimdall and execution layer called Bor . The network architecture includes:

  

-   **Heimdall Layer**: A set of proof-of-stake Heimdall nodes running in parallel to the Ethereum mainnet, monitoring the set of staking contracts deployed on the Ethereum mainnet
-   **Bor Layer**: Bor is Polygon PoS's block producer — the entity responsible for aggregating transactions into blocks
-   **Ethereum Integration**: Core contracts on the Ethereum mainnet incorporate a key feature for security and functionality: the exit queue
-   **Checkpoint System**: A checkpoint of the validated transactions is created and submitted to the core contracts on the Ethereum mainnet every 30 minutes or so

Public checkpoint nodes serve as validators in the Polygon PoS architecture and ensure security through periodic state commitments to Ethereum.

## Interacting with Polygon's APIs

  

Erigon Deprecation Notice

The `erigon_*` and `trace_*` method namespaces will be deprecated on **Amoy Testnet (July 1, 2026)** and **Mainnet (July 15, 2026)** as Quicknode migrates from Erigon to Bor. Use the `debug_trace*` namespace and `eth_getLogs` as alternatives. See [Polygon Labs' Erigon sunset notice](https://forum.polygon.technology/t/sunsetting-erigon-support/21872) for details.

All your favorite Ethereum tools (Foundry, Remix, Ethers.js) work seamlessly on Polygon, with the same familiar UX . The JSON-RPC API extends standard Ethereum methods with Polygon-specific functionality for accessing the sidechain's unique features.

You don't have to worry about the underlying architecture while moving or deploying your dApps to the Polygon PoS network as long as it is EVM-compatible . However, developers should understand Polygon's checkpoint system and dual-layer architecture when building applications that require cross-chain functionality or validator interactions.

## Make Polygon API Calls

The quickest way to start building on Polygon is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Polygon endpoints, giving you immediate access to Polygon Mainnet and Mumbai Testnet without the overhead of running your own infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through specialized APIs and Quicknode add-ons

> Visit the [QuickStart](/docs/polygon/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Polygon networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 137 | ✓ | ✓ | Yes | None |
| Amoy Testnet | Testnet | 80002 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Polygon with Quicknode:

-   [QuickStart](/docs/polygon/quickstart): Get started with Polygon quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/polygon/endpoints): Learn how to configure and manage your Polygon endpoints for optimal performance and reliability.
-   [API Overview](/docs/polygon/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/polygon/add-ons): Discover endpoint add-ons that extend your Polygon development workflow.
-   [Endpoint Security](/docs/polygon/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/polygon/error-references): Understand common error codes and troubleshooting steps for Polygon API requests.

---

---
title: Robinhood RPC
description: Get started with Robinhood RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Robinhood RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Robinhood](https://www.quicknode.com/chains/robinhood) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=robinhood)

Beta

Beta

## Robinhood Overview

Robinhood Chain is a permissionless, Ethereum-compatible Layer-2 blockchain built on Arbitrum Orbit, designed for a new generation of onchain financial infrastructure. It enables the convergence of traditional markets, crypto, and tokenized real-world assets on a fast, cost-efficient, and open network, while inheriting Ethereum’s security guarantees.

The network is fully EVM-compatible, allowing developers to deploy existing Solidity contracts and use familiar tools such as Hardhat, Foundry, and Remix without modification. Built on the Arbitrum Nitro stack and leveraging Ethereum for settlement and data availability, Robinhood Chain provides scalable execution with low transaction costs and strong security assurances.

MEV Protection and Redistribution

MEV Protection and Redistribution can redistribute a portion of eligible value captured from Robinhood Chain transaction flow as Quicknode billing credits. When enabled, eligible transactions may be routed through Quicknode's MEV infrastructure and third-party provider network. Credits are applied only after provider data is reconciled and may be delayed, adjusted, or unavailable. [Learn how the feature works and review its eligibility and limitations.](/docs/robinhood/endpoints#mev-protection-and-redistribution)

## Interacting with Robinhood's APIs

Robinhood nodes expose a JSON-RPC interface that is compatible with Ethereum's JSON-RPC API. This means developers can use Ethereum's native tools, such as Foundry, Hardhat, and popular Web3 libraries, without modification.

As an Arbitrum Orbit chain, Robinhood supports standard Ethereum JSON-RPC methods along with Debug API methods for advanced tracing and debugging. We highly recommend cross-referencing with the official [Robinhood documentation](https://robinhood.com/web3) for the latest updates and technical specifications.

## Make Robinhood API Calls

The quickest way to start building on Robinhood is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed Robinhood endpoints, giving you immediate access to both the Robinhood Mainnet and Testnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/robinhood/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Robinhood networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 4663 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 46630 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Robinhood with Quicknode:

-   [QuickStart](/docs/robinhood/quickstart): Get started with Robinhood quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/robinhood/endpoints): Learn how to configure and manage your Robinhood endpoints for optimal performance and reliability.
-   [API Overview](/docs/robinhood/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/robinhood/add-ons): Discover endpoint add-ons that extend your Robinhood development workflow.
-   [Endpoint Security](/docs/robinhood/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/robinhood/error-references): Understand common error codes and troubleshooting steps for Robinhood API requests.

---

---
title: Sahara RPC
description: Get started with Sahara RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Sahara RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Sahara](https://www.quicknode.com/chains/sahara) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=sahara)

## Sahara Overview

Sahara is a AI-based Layer-1 blockchain allowing developers to build, monetize and share AI models. Its architecture is built off different components such as the Sahara blockchain itself, AI infrastructure that allows shared compute of training models and a marketplace allowing developers and dApps to monetize models, datasets and AI agents. Sahara also offers a encrypted storage and access controls for keeping data secure as well as development tools like the Sahara SDK.

## Interacting with Sahara APIs

Sahara supports standard Ethereum JSON-RPC methods, allowing developers to use familiar Ethereum development tools like Hardhat, Foundry, Remix, and Web3 libraries without modification.

For the most current information on Sahara-specific features and RPC behavior, we recommend referencing the [official Sahara documentation](https://docs.saharaai.com/) alongside this guide.

## Making API Requests on Sahara

The quickest way to start building on Sahara is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Sahara endpoints, giving you immediate access to Sahara Mainnet and Sepolia without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

Visit the [QuickStart](https://www.quicknode.com/docs/sahara/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Sahara networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Testnet | Testnet | 313313 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Sahara with Quicknode:

-   [QuickStart](/docs/sahara/quickstart): Get started with Sahara quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/sahara/endpoints): Learn how to configure and manage your Sahara endpoints for optimal performance and reliability.
-   [API Overview](/docs/sahara/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/sahara/add-ons): Discover endpoint add-ons that extend your Sahara development workflow.
-   [Endpoint Security](/docs/sahara/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/sahara/error-references): Understand common error codes and troubleshooting steps for Sahara API requests.

---

---
title: Scroll RPC
description: Get started with Scroll RPC on Quicknode. Access reliable, low-latency infrastructure for Scroll with globally distributed endpoints for zero-knowledge Layer 2 scaling.
---

# Scroll RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Scroll](https://www.quicknode.com/chains/scroll) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=scroll)

## What is Scroll?

Scroll is a zero-knowledge rollup (zkRollup) Layer 2 solution for Ethereum, developed by a team of cryptography researchers and engineers. It uses SNARK-based validity proofs to batch transactions off-chain and verify them on Ethereum mainnet, ensuring that all transactions are mathematically valid while inheriting Ethereum's security.

Unlike optimistic rollups, Scroll does not require challenge periods for withdrawals because validity proofs provide immediate cryptographic certainty. Finality on Scroll depends on proof submission intervals — typically minutes rather than days — but is still faster than optimistic rollups. Transaction costs are significantly reduced compared to Ethereum mainnet, with savings coming from transaction batching and calldata compression.

Scroll emphasizes bytecode-level compatibility with the Ethereum Virtual Machine (EVM). This zkEVM architecture (classified as Type 1 zkEVM) ensures that existing Ethereum smart contracts and applications can be deployed without modification, preserving full compatibility with Ethereum's execution environment, tooling, and developer ecosystem. While the system inherits Ethereum's base-layer security, components like sequencer decentralization are part of Scroll's ongoing roadmap.

## Interacting with Scroll

Scroll extends the standard Ethereum JSON-RPC interface with additional Layer 2–specific functionality, while maintaining full compatibility with existing Ethereum tooling. Developers can use Scroll seamlessly with tools such as MetaMask, Hardhat, Foundry, and Web3 libraries without code changes.

With this API, you can:

-   Execute all standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, eth_getBalance)
-   Use Scroll-specific API methods such as estimating L1 data fees
-   Subscribe to real-time data via WebSocket connections

You can connect to the API by:

-   Running a local Scroll node
-   Using a hosted provider such as a Quicknode Scroll endpoint, which provides access to Scroll Mainnet with high reliability, archive data, and enhanced performance

## Supported Networks

Quicknode provides access to the following Scroll networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 534352 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Scroll with Quicknode:

-   [QuickStart](/docs/scroll/quickstart): Get started with Scroll quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/scroll/endpoints): Learn how to configure and manage your Scroll endpoints for optimal performance and reliability.
-   [API Overview](/docs/scroll/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/scroll/add-ons): Discover endpoint add-ons that extend your Scroll development workflow.
-   [Endpoint Security](/docs/scroll/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/scroll/error-references): Understand common error codes and troubleshooting steps for Scroll API requests.

---

---
title: SDK
description: Use the SDK to manage Quicknode product APIs from Rust, Python, Node.js, and Ruby.
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


The **SDK** is a single SDK for working with Quicknode product APIs from the language you already use: Rust, Python, Node.js, and Ruby.

Use it to build Quicknode product workflows, operational services, scripts, and AI agents that need typed access to:

  

-   **[Admin API](/docs/admin-api)**: Manage endpoints, usage, billing, teams, endpoint security, rate limits, logs, metrics, and account tags.
-   **[RPC](/docs/admin-api/tooling-access/v0-tooling-access)**: Make onchain JSON-RPC calls to any supported network without provisioning an endpoint, or [pay per call with x402 or MPP](/docs/sdk/micropayments) without an account or API key.
-   **[Streams](/docs/streams)**: Create, update, pause, activate, test, and delete Streams.
-   **[Webhooks](/docs/webhooks)**: Create and manage webhook subscriptions from Quicknode webhook templates.
-   **[Key-Value Store](/docs/key-value-store)**: Store and retrieve sets and lists for application state, stream filters, watchlists, cursors, and agent memory.
-   **[SQL Explorer](/docs/sql-explorer)**: Run SQL queries against indexed blockchain data and retrieve table schemas.

Complete reference for developers and agents building with the SDK:

-   [QuickStart](/docs/sdk/quick-start): Install the SDK, configure an API key, and make your first Admin API request from Rust, Python, Node.js, or Ruby.
-   [Examples](/docs/sdk/examples): See read-only examples for Admin API, Streams, Webhooks, Key-Value Store, SQL Explorer, and agent workflows.

## When to use the SDK

Use the SDK when you want one consistent client for Quicknode product APIs, especially when your app or agent needs to coordinate multiple products in one workflow.

Common workflows include:

  

-   Create or manage endpoints with the Admin API.
-   Make onchain JSON-RPC calls to any supported network.
-   Pay for RPC calls with x402 or MPP without a Quicknode account or API key.
-   Create a Stream and deliver filtered onchain data to a webhook destination.
-   Store processing state or watchlists in Key-Value Store.
-   Create webhooks from templates and manage their lifecycle.
-   Run SQL queries against indexed blockchain data with SQL Explorer.
-   Build agent workflows that can inspect account state, provision resources, and clean up test infrastructure.

## Packages

| Language | Package | Install |
| --- | --- | --- |
| Node.js / TypeScript | [@quicknode/sdk](https://www.npmjs.com/package/@quicknode/sdk) | `npm install @quicknode/sdk` |
| Python | [quicknode-sdk](https://pypi.org/project/quicknode-sdk/) | `pip install quicknode-sdk` |
| Rust | [quicknode-sdk](https://crates.io/crates/quicknode-sdk) | `cargo add quicknode-sdk --features rust` |
| Ruby | [quicknode_sdk](https://rubygems.org/gems/quicknode_sdk) | `gem install quicknode_sdk` |

## Platform support

The SDK is built around a shared Rust core with bindings for specific languages. The core compiles to native libraries for each supported platform, giving you predictable performance and a small dependency footprint. The trade-off is that we publish binaries for a specific set of targets rather than running in every environment our host languages support.

### Supported targets

Precompiled native modules are published for:

| Platform | Targets |
| --- | --- |
| Linux (glibc) | x86_64, aarch64 on glibc 2.17+ (manylinux2014) |
| Linux (musl) | x86_64, aarch64 on Alpine and other musl distros |
| macOS | Apple Silicon (arm64) |

Linux glibc binaries are built against glibc 2.17, so they load on any distro released from 2014 onward, including RHEL 7+, Ubuntu 14.04+, Debian 8+, Amazon Linux 2+, SLES 12+, and Fedora 19+.

### Not supported

  

-   **Browsers**: The SDK is not browser-compatible. It uses a Rust core through native bindings, which require Node.js or another runtime that supports native add-ons. Standard browser bundles cannot load these bindings.
-   **Windows**: No precompiled binary is published. WSL2 works and is the recommended path for Windows developers.
-   **Intel macOS**: Apple Silicon only.
-   **Older Linux distros**: below the glibc floor: RHEL/CentOS 6 (glibc 2.12), Debian 7 (glibc 2.13), Ubuntu 12.04 (glibc 2.15), SLES 11 (glibc 2.11).

On an unsupported platform, importing the SDK fails fast at load time with an error listing the available targets. The failure surfaces at install or import, not at first call.

## Product clients

Construct the SDK once, then use the product clients exposed from that shared configuration.

| Client | Purpose | REST API |
| --- | --- | --- |
| `admin` | Endpoints, teams, usage, logs, billing, metrics, security, and rate limits | `https://api.quicknode.com/v0/` |
| `rpc` | On-chain JSON-RPC calls via Tooling Access or x402/MPP micropayments | Tooling Access, x402, or MPP gateway |
| `streams` | Streams creation, updates, lifecycle, and filter testing | `https://api.quicknode.com/streams/rest/v1/` |
| `webhooks` | Webhook templates, destinations, lifecycle, and counts | `https://api.quicknode.com/webhooks/rest/v1/` |
| `kvstore` | Sets and lists for persisted state | `https://api.quicknode.com/kv/rest/v1/` |
| `sql` | SQL queries against indexed blockchain data | `https://api.quicknode.com/sql/rest/v1/` |

The SDK entry point is `QuicknodeSdk` in each language binding. Ruby exposes it as `QuicknodeSdk::SDK`.

### SQL Explorer methods

The `sql` client provides two methods:

-   **`query(sql, clusterId)`**: Execute a SQL query against indexed blockchain data. Returns typed rows and query statistics (credits, rows scanned, bytes read).
-   **`getSchema(clusterId)`**: Retrieve the table schema for a cluster.

```javascript
const qn = new QuicknodeSdk();



// Run a SQL query

const resp = await qn.sql.query(

  "SELECT action_type, user FROM hyperliquid_system_actions LIMIT 3",

  "hyperliquid-core-mainnet"

);

console.log(`${resp.rows} rows, ${resp.credits} credits`);



// Get the schema for a cluster

const schema = await qn.sql.getSchema("hyperliquid-core-mainnet");
```

## Authentication

Create an API key in the [Quicknode dashboard](https://dashboard.quicknode.com/api-keys), then configure the SDK with the `QN_SDK__API_KEY` environment variable.

```bash
export QN_SDK__API_KEY="YOUR_API_KEY"
```

The SDK also supports base URL overrides for local development, staging, and agent sandboxes:

| Environment variable | Default |
| --- | --- |
| `QN_SDK__ADMIN__BASE_URL` | `https://api.quicknode.com/v0/` |
| `QN_SDK__STREAMS__BASE_URL` | `https://api.quicknode.com/streams/rest/v1/` |
| `QN_SDK__WEBHOOKS__BASE_URL` | `https://api.quicknode.com/webhooks/rest/v1/` |
| `QN_SDK__KVSTORE__BASE_URL` | `https://api.quicknode.com/kv/rest/v1/` |
| `QN_SDK__SQL__BASE_URL` | `https://api.quicknode.com/sql/rest/v1/` |
| `QN_SDK__HTTP__TIMEOUT_SECS` | `30` |

## For agents

The SDK is designed to be useful for humans and agents. Agents can initialize one SDK handle, reuse the same credentials across product clients, and rely on typed method inputs and responses instead of composing raw REST calls for each workflow.

## Next steps

  

-   Start with the [QuickStart](/docs/sdk/quick-start) to install and initialize the SDK.
-   Use [RPC Micropayments](/docs/sdk/micropayments) to call blockchain RPC methods with x402 or MPP and no API key.
-   Use [Examples](/docs/sdk/examples) to see Admin API, RPC & Tooling Access, Streams, Webhooks, and Key-Value Store workflows.
-   Refer to the product API docs for complete endpoint behavior: [Admin API](/docs/admin-api), [Streams](/docs/streams), [Webhooks](/docs/webhooks), [Key-Value Store](/docs/key-value-store), and [SQL Explorer](/docs/sql-explorer).

---

---
title: Sei RPC
description: Get started with Sei RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Sei RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Sei](https://www.quicknode.com/chains/sei) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=sei)

## Sei Overview

Sei is a high-performance Layer 1 blockchain with a focus on speed and efficiency to achieve a Web2-like experience. It runs transactions in parallel and uses an efficient consensus design to handle up to 200,000 TPS, with finality under 400 ms. It's fully EVM-compatible and processes transactions at sub-cent costs.

## Interacting With Sei APIs

Sei exposes Ethereum-compatible JSON-RPC methods that allow developers to interact with the network programmatically. You can query blockchain state, send transactions, deploy and interact with smart contracts, and subscribe to real-time events via WebSocket.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

The Quicknode Sei documentation is continuously updated, but we recommend cross-referencing with the [official Sei documentation](https://docs.sei.io/) for the latest API details.

## Make Sei API Calls

The quickest way to start building on Sei is to create a Quicknode endpoint and send your first request. Quicknode provides managed Sei endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/sei/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Sei networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 1329 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 1328 | ✓ | ✓ | No | 3240000 blocks |

Archive Data Availability

Quicknode's **Sei Pacific** endpoints provide full archive data access starting from **block height `1`** (genesis).

**For blocks >= 78309999:** Use the `x-cosmos-block-height` header with REST API requests or specify the height parameter with Tendermint API requests:

**Cosmos REST API Example:**

```bash
curl --location 'https://docs-demo.sei-pacific.quiknode.pro/cosmos/distribution/v1beta1/delegators/sei1xyp8xxely9txewfe7nes2nxrzr0qyrfghrj5cs/rewards' \

--header 'x-cosmos-block-height: 78309999'
```

**Tendermint API Example:**

```bash
curl --location 'https://docs-demo.sei-pacific.quiknode.pro/block?height=78309999'
```

**For Sei EVM methods:** No special headers are required. The earliest block number for EVM methods is `79123881` (Sei V2 upgrade block).

Complete reference for developers building on Sei with Quicknode:

-   [QuickStart](/docs/sei/quickstart): Get started with Sei quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/sei/endpoints): Learn how to configure and manage your Sei endpoints for optimal performance and reliability.
-   [API Overview](/docs/sei/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/sei/add-ons): Discover endpoint add-ons that extend your Sei development workflow.
-   [Endpoint Security](/docs/sei/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/sei/error-references): Understand common error codes and troubleshooting steps for Sei API requests.

---

---
title: Solana RPC
description: Get started with Solana RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for high-performance development.
---

# Solana RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Solana](https://www.quicknode.com/chains/solana) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=solana)

## What is Solana?

Solana is a high-performance L1 blockchain that combines Proof of History (PoH) with Proof of Stake (PoS) to achieve high throughput, low latency, and low transaction cost. It operates as a single global state machine, where all accounts and programs live on one shared ledger with consistent execution rules.

As of December 2025, blocks are produced approximately every 400 milliseconds with single-slot finality, and the network can process thousands of transactions per second under typical load.

Solana will be migrating to a next-generation consensus protocol named [Alpenglow](https://blog.quicknode.com/solana-alpenglow-upgrade/) in early 2026. This protocol redesigns validator voting and data propagation to achieve deterministic, sub-second finality (targeting ~150ms).

Solana’s **Sealevel** runtime enables true parallel transaction execution by analyzing which accounts each transaction reads and writes. This parallelism keeps base transaction fees low (typically a fraction of a cent). When many transactions compete for the same account, users can optionally include a priority fee to have validators process their transactions first.

➡️ [**Solana Fundamentals Reference Guide**](https://www.quicknode.com/guides/solana-development/getting-started/solana-fundamentals-reference-guide)

## Building on Solana

Solana runs with one shared state for all programs and accounts. Every program you deploy can directly read, write, and coordinate with any other program through [cross-program invocation (CPI)](https://www.quicknode.com/guides/solana-development/anchor/what-are-cpis) in a single atomic transaction. This makes it straightforward to plug into core on-chain services and the rest of the ecosystem using the same set of primitives.

Solana on-chain programs are typically written in Rust using frameworks built for Solana (C, C++, and other LLVM-compatible languages can also be used). [Anchor](https://www.anchor-lang.com/docs) offers helpers for accounts and instructions so you write less boilerplate while [Pinocchio](https://github.com/anza-xyz/pinocchio) is a lean, no_std framework designed to optimize Solana programs and keep their size as small as possible.

For front-end development, libraries like [Solana Kit](https://github.com/anza-xyz/kit), [Kite](https://github.com/solanakite/kite), [Gill](https://github.com/gillsdk/gill), [Umi](https://github.com/metaplex-foundation/umi), and [Wallet Adapter](https://github.com/anza-xyz/wallet-adapter) provide higher-level APIs for managing accounts, building and sending transactions, and integrating with wallets.

Official and community SDKs exist for [TypeScript/JavaScript](https://solana.com/docs/clients/official/javascript), [Rust](https://solana.com/docs/clients/official/rust), [Python](https://solana.com/docs/clients/community/python), [Go](https://solana.com/docs/clients/community/go), and other languages as well.

## Core Concepts for Developers

### Accounts

On Solana, everything is an account. Each account has:

-   **Owner**: The program allowed to change its data
-   **Data**: Serialized bytes your program defines
-   **Lamports:** The account's balance of SOL
-   **Executable Flag**: Executable accounts hold program code where non-executable accounts hold state.

➡️ [**An Introduction to the Solana Account Model**](https://www.quicknode.com/guides/solana-development/getting-started/an-introduction-to-the-solana-account-model)

Accounts must hold a minimum lamport (the smallest unit of SOL) balance to stay "rent-exempt" and kept on-chain. Previously, Solana accounts could have rent deducted and eventually be reclaimed, but now all new accounts must be created with enough lamports to be rent-exempt from the start).

➡️ [**What is Rent on Solana and How to Calculate it**](https://www.quicknode.com/guides/solana-development/getting-started/understanding-rent-on-solana)

### Programs (Smart Contracts)

Programs on Solana are deployed as stateless code stored in executable accounts. They do not keep data between calls. All state data lives in separate accounts that the program owns or receives as inputs.

Most programs are deployed with the BPF Upgradeable Loader, which lets you update a program after deployment as long as you control the upgrade authority. You can also make programs immutable by deploying them that way or revoking the upgrade authority later making the code permanent.

Solana ships with several native programs that handle core tasks like creating accounts and transferring SOL, staking SOL, and validator voting. Any custom programs you deploy for your application logic are invoked in a similar way from transactions and can be composed together.

### Transactions

Transactions include an explicit list of all accounts they will read or write. The runtime uses this list to check permissions and to schedule work. Because it knows which accounts are read or written to, it can run transactions in parallel when their account sets do not overlap.

Solana organizes time into short windows called slots, and each slot has a chosen leader (a validator) from a rotating schedule. When your app sends a transaction, it connects to an RPC endpoint, which checks the transaction and forwards it into Solana’s Gulf Stream pipeline instead of a shared "mempool".

Because of this, RPC quality really matters. A good RPC setup forwards transactions quickly, handles load and retries, and stays well connected to the network, which leads to faster confirmations and more reliable behavior when the network is busy.

➡️ [**Maximizing Performance - A Guide to Efficient RPC Calls with Quicknode**](https://www.quicknode.com/guides/quicknode-products/apis/guide-to-efficient-rpc-requests)

### Infrastructure

For Devnet and Mainnet-beta, [Quicknode RPC and WebSocket endpoints](https://www.quicknode.com/docs/solana/endpoints) enable sending transactions, subscribing to account or log changes, and tuning requests for performance and reliability.

For local development, you [run a local validator](https://www.quicknode.com/guides/solana-development/getting-started/start-a-solana-local-validator) to test programs and clients without real funds or network latency. Tools like [LiteSVM](https://www.quicknode.com/guides/solana-development/tooling/litesvm), Surfpool, and Mollusk provide faster local runtimes, simulation, and fuzz-style testing utilities that plug into your normal test workflow and help catch issues before you deploy.

## Supported Networks

Solana has several clusters, each with a different role in your workflow. Here’s what you need to when deciding where to develop, test, and deploy your program:

**Localnet**

A local validator is for writing program logic, defining account layouts, or writing tests. It lets you airdrop SOL freely, reset the chain, and script deterministic scenarios. The tradeoff is that it doesn’t mirror Mainnet-beta data by default, so you'll need to export and deploy those programs into your local setup if you need them.

**Devnet**

Devnet is Solana’s public testing cluster designed for builders. You get free (rate-limited) airdrops of SOL, most ecosystem programs eventually deploy there, and it’s treated as a playground for apps, tutorials, and demos.

**Testnet**

Testnet is primarily for validator and protocol testing, not for application deployment. Its purpose is to trial new validator client releases, stress-test consensus changes, and simulate network load.

**Mainnet-beta**

Mainnet-beta is where you deploy your program so anyone on Solana can use it. When you deploy here, you pay real costs to fund the program and any related state accounts with enough SOL to be rent-exempt, and transaction fees to write that code on-chain.

Quicknode provides access to the following Solana networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet-beta | Production | ✓ | ✓ | Yes | None |
| Testnet | Testnet | ✓ | ✓ | No | 10964176 slots |
| Devnet | Testnet | ✓ | ✓ | No | 6578505 slots |
| Alpenglow Testnet | Testnet | ✓ | ✓ | No | best-effort — not guaranteed. History may reset to near-zero after node maintenance/upgrades or the cluster's periodic re-genesis. |

## Ecosystem and Use Cases

Solana’s fast transactions and low fees enable a wide range of applications that may not be practical on other blockchains.

This shows up in DeFi protocols with frequent trades, games that update onchain state in real time, NFT platforms that support large collections, and payment or consumer apps where users expect quick confirmations without worrying about fees.

Projects often combine standard building blocks rather than building everything from the ground up. SPL Token and [Token-2022](https://www.quicknode.com/guides/solana-development/spl-tokens/token-2022/overview) handle fungible assets, Metaplex covers NFTs and collections, and other on-chain protocols provide swaps, lending, order books, identity, and more.

Programs can call into these directly, so it’s straightforward to wire up features like on-chain markets, reward systems, or in-app currencies.

For large-scale use cases, compressed assets make it possible to store and update large numbers of objects at low cost. On the off-chain side, RPC and indexing infrastructure transform raw onchain account data into usable APIs and dashboards for feeds, leaderboards, analytics, and monitoring. This lets applications remain responsive while working with substantial amounts of on chain data.

Check out some of our [sample applications built on Solana](https://www.quicknode.com/sample-app-library/welcome?chains=Solana) for practical examples.

## Frequently Asked Questions

**Why does RPC quality matter for Solana transactions?**

Solana transactions are forwarded to the Gulf Stream pipeline instead of a mempool, so a good RPC setup forwards transactions quickly, handles load and retries, and stays well connected to the network, leading to faster confirmations especially when the network is busy.

**What is the Alpenglow upgrade?**

Solana will migrate to the Alpenglow consensus protocol in early 2026, which redesigns validator voting and data propagation to achieve deterministic sub-second finality targeting approximately 150ms, improving on current ~400ms block times.

**What languages can I use to build on Solana?**

Solana on-chain programs are typically written in Rust using frameworks like Anchor or Pinocchio, though C, C++, and other LLVM-compatible languages can also be used. For client development, SDKs exist for TypeScript/JavaScript, Rust, Python, Go, and other languages.

**What Solana networks does Quicknode support?**

Quicknode supports Solana Mainnet-beta (production), Devnet (testnet), and Testnet. Mainnet-beta has full archive support with no pruning, while Devnet and Testnet are pruned at 6,578,505 and 10,964,176 slots respectively.

**When should I use Devnet versus Mainnet-beta?**

Devnet is Solana's public testing cluster for builders with free SOL airdrops and most ecosystem programs deployed for testing apps and demos. Mainnet-beta is for production deployment where you pay real costs for program deployment and transactions.

## Learn More

Complete reference for developers building on Solana with Quicknode:

-   [QuickStart](/docs/solana/quickstart): Get started with Solana quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/solana/endpoints): Learn how to configure and manage your Solana endpoints for optimal performance and reliability.
-   [API Overview](/docs/solana/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/solana/add-ons): Discover endpoint add-ons that extend your Solana development workflow.
-   [Endpoint Security](/docs/solana/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/solana/error-references): Understand common error codes and troubleshooting steps for Solana API requests.

---

---
title: Soneium RPC
description: Get started with Soneium RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Soneium RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Soneium](https://www.quicknode.com/chains/soneium) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=soneium)

Beta

Beta

## Soneium Overview

Soneium is an Ethereum Layer 2 network developed by Sony Block Solution Labs. It's EVM compatible and designed for fast, low-cost transactions. Soneium supports standard Ethereum JSON-RPC methods along with endpoints for rollup state and synchronization.

## Interacting With Soneium APIs

Soneium exposes Ethereum-compatible JSON-RPC and rollup-specific methods that allow developers to interact with the network programmatically. You can query blocks and transactions, deploy and interact with smart contracts, and access rollup status and configuration.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

The Quicknode Soneium documentation is continuously updated, but we recommend cross-referencing with the [official Soneium documentation](https://docs.soneium.org/) for the latest API details.

## Make Soneium API Calls

The quickest way to start building on Soneium is to create a Quicknode endpoint and send your first request. Quicknode provides managed Soneium endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/soneium/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Soneium networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 1868 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Soneium with Quicknode:

-   [QuickStart](/docs/soneium/quickstart): Get started with Soneium quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/soneium/endpoints): Learn how to configure and manage your Soneium endpoints for optimal performance and reliability.
-   [API Overview](/docs/soneium/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/soneium/add-ons): Discover endpoint add-ons that extend your Soneium development workflow.
-   [Endpoint Security](/docs/soneium/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/soneium/error-references): Understand common error codes and troubleshooting steps for Soneium API requests.

---

---
title: Sonic RPC
description: Get started with Sonic RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Sonic RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Sonic](https://www.quicknode.com/chains/sonic) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=sonic)

Beta

Beta

## Sonic Overview

Sonic is a high-performance EVM Layer-1 built for the next wave of DeFi. It blends a novel consensus design with strong incentives and production-grade infrastructure to reach sub-second finality, while maintaining full EVM compatibility.

## Interacting With Sonic APIs

Sonic exposes Ethereum-compatible JSON-RPC methods that allow developers to interact with the network programmatically. You can query blockchain state, send transactions, deploy and interact with smart contracts, and subscribe to real-time events via WebSocket.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

The Quicknode Sonic documentation is continuously updated, but we recommend cross-referencing with the [official Sonic documentation](https://docs.soniclabs.com/) for the latest API details.

## Make Sonic API Calls

The quickest way to start building on Sonic is to create a Quicknode endpoint and send your first request. Quicknode provides managed Sonic endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/sonic/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Sonic networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 146 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Sonic with Quicknode:

-   [QuickStart](/docs/sonic/quickstart): Get started with Sonic quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/sonic/endpoints): Learn how to configure and manage your Sonic endpoints for optimal performance and reliability.
-   [API Overview](/docs/sonic/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/sonic/add-ons): Discover endpoint add-ons that extend your Sonic development workflow.
-   [Endpoint Security](/docs/sonic/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/sonic/error-references): Understand common error codes and troubleshooting steps for Sonic API requests.

---

---
title: Getting Started with SQL Explorer
description: Getting Started with SQL Explorer
tags: []
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


**[SQL Explorer](https://www.quicknode.com/sql-explorer)** gives you direct SQL access to billions of rows of indexed blockchain data, without managing infrastructure. Query trades, orders, positions, liquidations, and more using standard SQL, all within the same platform you already use for RPC and Streams.

**SQL Explorer is currently in Beta.** We are actively expanding dataset coverage and adding new features based on user feedback.

  

Using AI Agents?

Install the [Build Web3 plugin](/docs/build-with-ai/build-web3-plugin) so your agent can build on SQL Explorer, with full knowledge of its queries and schemas and of the broader Quicknode platform. In Claude Code:

```bash
/plugin marketplace add quicknode/agent-plugins
```

For SQL query generation, download the [machine-readable schema](/docs/assets/files/hyperliquid_schema-5be777728d2e05cb4a864eb9153f20fe.txt) and include in your agent's context. See the [Schema Reference](/docs/sql-explorer/schema-reference) for full details.

## Why SQL Explorer

SQL Explorer enables flexible querying of indexed blockchain data using standard SQL. Instead of relying on predefined API endpoints, you can write custom queries directly against the underlying datasets.

Key characteristics:

-   **No infrastructure to manage**: Query blockchain data through SQL without running nodes, databases, or indexers
-   **Full query flexibility**: Write SQL queries with standard syntax including functions, subqueries, window functions, and joins
-   **Built for scale**: Queries execute against billions of rows using columnar storage with partition-aware optimization
-   **Fully Integrated**: Available alongside RPC, Streams, and other Quicknode products in the same platform

## Features of SQL Explorer

SQL Explorer includes tools for querying, analyzing, and integrating blockchain data:

  

-   **SQL Editor**: In-browser editor with syntax highlighting and support for standard SQL, including subqueries, window functions, `GROUP BY`, and `JOIN`
-   **Schema Browser**: View table metadata including row counts, column names, data types, sort keys (⚡), and partition strategies. See the [Schema Reference](/docs/sql-explorer/schema-reference) for full documentation
-   **Pre-built Queries**: Ready-to-use queries for common use cases across supported chains
-   **Visualization**: Generate charts with configurable axes, multi-series overlays, and hover tooltips
-   **REST API Access**: Execute queries programmatically via POST to `https://api.quicknode.com/sql/rest/v1/query` with API key authentication
-   **Query Builder**: Generate REST API calls (cURL) from the UI for any query
-   **Saved Query Library**: Save your frequently used queries for quick access
-   **Execution Metrics:**: View query time, rows returned, rows scanned, and bytes processed for each query

## How to Access SQL Explorer

SQL Explorer is available through multiple access methods:

-   **Dashboard**: Interactive queries with visualization in your browser
-   **REST API**: Direct HTTP requests for programmatic access
-   **SDK**: Typed client for Node.js, Python, Rust, and Ruby applications
-   **CLI**: Terminal commands for scripts and quick queries

### Using the Dashboard

The Quicknode Dashboard provides an interactive environment for building, testing, and visualizing SQL queries:

1.  Open [SQL Explorer](https://dashboard.quicknode.com/sql) in your Quicknode dashboard
2.  Browse the **Tables** tab to explore available datasets, view schema details, or select a pre-built query from the **Queries** tab
3.  Write a new query or modify a pre-built query in the editor
4.  Click **Run** to execute your query
5.  View results in the **Results** tab or switch to **Charts** for visualization
6.  Click **Save** to store the query, or **API** to generate the corresponding REST request

### Using the REST API

The REST API allows you to execute SQL queries programmatically.

SQL queries are executed via HTTP POST request to `https://api.quicknode.com/sql/rest/v1/query` using your Quicknode API key. Results are returned as JSON with query execution statistics.

**Get the API Call from Dashboard:**

After running a query in the [SQL Explorer Dashboard](https://dashboard.quicknode.com/sql), click **API** in the top to generate a ready-to-use cURL request with your query included.

**Example Request:**

```bash
curl -X POST 'https://api.quicknode.com/sql/rest/v1/query' \

  -H 'accept: application/json' \

  -H 'Content-Type: application/json' \

  -H 'x-api-key: YOUR_API_KEY' \

  -d '{

    "query": "SELECT time, validator, reward, block_number FROM hyperliquid_validator_rewards ORDER BY block_number DESC LIMIT 100",

    "clusterId": "hyperliquid-core-mainnet"

  }'
```

**Example Response:**

```json
{

    "meta": [

        {

            "name": "time",

            "type": "DateTime64(6, 'UTC')"

        }

    ],

    "data": [

        {

            "time": "2026-03-30 16:24:00.058516",

            "validator": "0xf8efb4cb844a8458114994203d7b0bfe2422a288",

            "reward": 0.18548686,

            "block_number": 940269912

        },

        {

            "time": "2026-03-30 16:24:00.058516",

            "validator": "0xeeee86f718f9da3e7250624a460f6ea710e9c006",

            "reward": 0.50774076,

            "block_number": 940269912

        }

    ],

    "rows": 100,

    "rows_before_limit_at_least": 120,

    "statistics": {

        "elapsed": 0.073805665,

        "rows_read": 71918,

        "bytes_read": 5322148

    }

}
```

**Understanding the Response:**

The API response contains the following fields:

-   **`meta`**: Array of column metadata with `name` and `type` for each column in the result set
-   **`data`**: Array of objects containing the actual query results, with each object representing one row
-   **`rows`**: Number of rows returned in this response
-   **`rows_before_limit_at_least`**: Total number of rows that matched the query before applying LIMIT (useful for pagination)
-   **`statistics`**: Performance metrics for query optimization:
    -   **`elapsed`**: Total query execution time in seconds
    -   **`rows_read`**: Total number of rows scanned during execution (may be more than returned rows due to filtering)
    -   **`bytes_read`**: Total data scanned in bytes (helpful for understanding query cost and optimization opportunities)

Use the `statistics` fields to understand query performance and optimize scans. Lower `rows_read` and `bytes_read` generally indicate more efficient queries.

See the [REST API Overview](/docs/sql-explorer/using-rest-api) guide for detailed instructions, authentication setup, and examples.

### Using the SDK

The [SDK](/docs/sdk) provides typed access to SQL Explorer from Node.js, Python, Rust, and Ruby. Use the `sql` client to run queries and retrieve schemas.

**Example (Node.js):**

```javascript
import { QuicknodeSdk } from "@quicknode/sdk";



const qn = new QuicknodeSdk();



// Run a SQL query

const resp = await qn.sql.query(

  "SELECT action_type, user FROM hyperliquid_system_actions LIMIT 3",

  "hyperliquid-core-mainnet"

);

console.log(`${resp.rows} rows, ${resp.credits} credits`);



// Get the schema for a cluster

const schema = await qn.sql.getSchema("hyperliquid-core-mainnet");
```

See the [SDK documentation](/docs/sdk) for installation and authentication setup.

### Using the CLI

The [CLI](/docs/cli) provides terminal commands for SQL queries and schema retrieval.

**Run a query:**

```bash
qn sql query "SELECT * FROM hyperliquid_trades LIMIT 10" --cluster hyperliquid-core-mainnet
```

**Get the schema:**

```bash
qn sql schema --cluster hyperliquid-core-mainnet
```

See the [CLI documentation](/docs/cli) for installation and authentication setup.

  

Result Limit & Pagination

Query results are limited to **1000 rows per request**. For larger result sets, use `LIMIT` and `OFFSET` clauses to paginate through results. See the [Pagination guide](/docs/sql-explorer/using-rest-api#pagination) for complete examples and best practices.

  

Get Started with Queries

Explore the [SQL Explorer Cookbook](https://quicknode.com/sample-app-library/sql-explorer-cookbook) for 40+ pre-built queries covering wallet activity, validator rewards, liquidations, and more. Each example includes customizable parameters and ready-to-use code in SQL, cURL, TypeScript, and Python.

## Billing

SQL Explorer uses API credits from your existing Quicknode account. Credit usage is calculated server-side based on the resources consumed by each query:

-   **Query execution time**: longer-running queries cost more, with a progressive rate for queries exceeding 250ms and 2 seconds
-   **Data scanned**: queries that scan more bytes from disk are charged accordingly
-   **Base fee**: every query has a minimum credit charge to cover fixed infrastructure costs

Each API response includes the credit cost in the `X-Credits` response header, along with execution statistics (`elapsed`, `rows_read`, `bytes_read`) in the response body so you can monitor and optimize query costs.

**Tips to reduce credit usage:**

-   Filter on `user` when possible - this leverages pre-sorted projections for fast lookups
-   Use `LIMIT` to cap result size
-   Run `EXPLAIN` to preview the query plan before executing expensive queries

You can view your credit usage in the [Quicknode Dashboard](https://dashboard.quicknode.com).

## Supported Networks

SQL Explorer currently supports the following chains with additional chains coming soon:

| Chain | Network | Tables | Total Rows | Coverage |
| --- | --- | --- | --- | --- |
| Hyperliquid | Mainnet | View Schema | Billions+ | Trades, orders, fills, funding, order book diffs, perpetual markets, spot markets, blocks, transactions, system actions, builder activity, staking, ledger, clearinghouse states, oracle prices, sub-accounts, vault equities, agents, bridge events, display names, asset transfers, TWAP statuses, referrals, validator rewards, delegator rewards, summaries, metrics, and more |

## Available Schema

SQL Explorer provides comprehensive coverage of Hyperliquid HyperCore with billions of rows of indexed data across multiple tables including trades, orders, fills, funding, market data, and more.

  

View Complete Schema

Browse the [complete schema reference](/docs/sql-explorer/schema-reference) for column definitions, data types, sort keys, and partitioning details. The schema is continuously updated and optimized for querying.

## Frequently Asked Questions

**What is Quicknode SQL Explorer?**

SQL Explorer provides direct SQL access to indexed blockchain data without requiring any infrastructure. You can query billions of rows of on-chain data using standard SQL syntax and receive results in seconds.

**How do I access SQL Explorer?**

You can access SQL Explorer through the [Quicknode Dashboard](https://dashboard.quicknode.com/sql) for interactive queries, the [REST API](https://www.quicknode.com/docs/sql-explorer/using-rest-api) for programmatic access, the [SDK](https://www.quicknode.com/docs/sdk) for typed client access from Node.js, Python, Rust, and Ruby, or the [CLI](https://www.quicknode.com/docs/cli) for terminal commands.

**Which chains are supported?**

SQL Explorer currently supports Hyperliquid Mainnet with billions of rows of indexed data. Additional chains are coming soon.

**What data tables are available?**

For Hyperliquid, SQL Explorer provides 37 tables covering trading data (trades, orders, fills, order book diffs), market data (perpetual/spot markets, market contexts), funding, infrastructure (blocks, transactions, system actions), builder activity, staking, ledger updates, clearinghouse states, oracle prices, referrals, sub-accounts, vault equities, agents, bridge events, display names, hourly metrics, daily metrics, and more.

**Can I create my own queries?**

Yes. SQL Explorer supports standard SQL syntax including functions, subqueries, window functions, GROUP BY, and JOINs. You can write any SQL query to access the data you need.

**How does programmatic access work?**

SQL queries can be executed programmatically via the REST API (HTTP POST to https://api.quicknode.com/sql/rest/v1/query), the [SDK](https://www.quicknode.com/docs/sdk) (typed clients for Node.js, Python, Rust, Ruby), or the [CLI](https://www.quicknode.com/docs/cli) (qn sql query command). All methods use your Quicknode API key for authentication and return structured results with query statistics.

**How do I retrieve more than 1000 rows?**

Query results are limited to 1000 rows per request. To retrieve larger result sets, use `LIMIT` and `OFFSET` clauses in your SQL queries to paginate through results. For example, use `LIMIT 100 OFFSET 0` for rows 1-100, then `LIMIT 100 OFFSET 100` for rows 101-200. The `rows_before_limit_at_least` field in the response tells you the total number of matching rows. See the [Pagination guide](https://www.quicknode.com/docs/sql-explorer/using-rest-api#pagination) for complete examples and best practices.

**How does billing work?**

SQL Explorer uses API credits from your existing Quicknode account. Credits are calculated server-side based on query execution time, data scanned, and a base fee per query. The exact credit cost is returned in the `X-Credits` response header with each query. The `statistics` object in each API response shows execution time, rows read, and bytes scanned so you can optimize queries and reduce costs. Use time-range filters and user filters to minimize data scanned.

**Is SQL Explorer production ready?**

SQL Explorer is currently in Beta and available to all Quicknode users. We are actively expanding dataset coverage and adding new features based on user feedback.

**How do I optimize my queries?**

Use the schema browser to identify sort keys (marked ⚡) and partition strategies. Write partition-aware queries that filter on time ranges to skip irrelevant partitions. Hyperliquid tables partition monthly by toYYYYMM(block_time). Every query returns execution stats (query time, result rows, rows read, bytes read) so you can optimize iteratively.

---

---
title: Stacks REST API
description: Get started with Stacks REST API on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Stacks REST API

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Stacks REST API](https://www.quicknode.com/chains/stx) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=stacks)

## What is Stacks?

Stacks is a Bitcoin Layer 2 for smart contracts and decentralized applications. It uses the Clarity smart contract language and the Proof of Transfer (PoX) mechanism to anchor security to the Bitcoin network. Developers build on Stacks to create applications that leverage Bitcoin’s security and finality while enabling expressive on-chain logic with Clarity.

## Interacting with Stacks APIs

Stacks exposes both REST and WebSocket interfaces for programmatic access to the chain. You can query blocks, transactions, and accounts, read contract interfaces and call read‑only functions, inspect mempool and fees, and broadcast signed transactions.

Connect by [running your own Stacks node](https://www.quicknode.com/guides/infrastructure/node-setup/how-to-install-and-run-a-stacks-node) with the API service enabled, or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

The Quicknode Stacks documentation is continuously updated, but we recommend cross-referencing with the [official Stacks documentation](https://docs.stacks.co/reference/api) for the latest API details.

* * *

## Make Stacks API Calls

The quickest way to start building on Stacks is to create a Quicknode endpoint and send your first request. Quicknode provides managed Stacks endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/stacks/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Stacks networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✓ | Yes | None |
| Testnet | Testnet | ✓ | ✓ | Yes | None |

Complete reference for developers building on Stacks with Quicknode:

-   [QuickStart](/docs/stacks/quickstart): Get started with Stacks quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/stacks/endpoints): Learn how to configure and manage your Stacks endpoints for optimal performance and reliability.
-   [API Overview](/docs/stacks/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/stacks/add-ons): Discover endpoint add-ons that extend your Stacks development workflow.
-   [Endpoint Security](/docs/stacks/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/stacks/error-references): Understand common error codes and troubleshooting steps for Stacks API requests.

---

---
title: Starknet RPC
description: Get started with Starknet RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Starknet RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Starknet](https://www.quicknode.com/chains/strk) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=starknet)

## Starknet Overview

Starknet is a Layer 2 zero-knowledge rollup (zkRollup) built on Ethereum. It uses **zk-STARKs** to generate and verify proofs, enabling efficient transaction settlement on Ethereum with lower gas costs compared to **zk-SNARKs**.

Starknet runs on **CairoVM**, a custom virtual machine, and uses the **Cairo** programming language for smart contracts. Cairo is designed to produce proofs efficiently while offering developers a Solidity-like experience with stronger security guarantees, influenced by Rust.

Transactions on Starknet can be paid in **STRK (its native token), ETH, or USDC**.

## Interacting with Starknet’s APIs

Starknet exposes a JSON-RPC interface that enables programmatic access to incoming block and transaction data. Use this interface to read chain state, submit transactions, and interact with contracts. The Quicknode Starknet documentation is continuously evolving as the chain undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Starknet documentation](https://docs.starknet.io/) for the latest updates on its RPC methods.

## Make Starknet API Calls

The quickest way to start building on Starknet is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed Starknet endpoints, giving you immediate access to the Starknet Mainnet and Sepolia Testnet without the overhead of running infrastructure. These endpoints offer:

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Archive data** – full historical state for in-depth queries
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons

> Visit the [QuickStart](/docs/starknet/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Starknet networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | ✓ | ✓ | Yes | None |

Complete reference for developers building on Starknet with Quicknode:

-   [QuickStart](/docs/starknet/quickstart): Get started with Starknet quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/starknet/endpoints): Learn how to configure and manage your Starknet endpoints for optimal performance and reliability.
-   [API Overview](/docs/starknet/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/starknet/add-ons): Discover endpoint add-ons that extend your Starknet development workflow.
-   [Endpoint Security](/docs/starknet/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/starknet/error-references): Understand common error codes and troubleshooting steps for Starknet API requests.

---

---
title: Stellar RPC
description: Get started with Stellar RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Stellar RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Stellar](https://www.quicknode.com/chains/stellar) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=stellar)

Beta

Beta

## Stellar Overview

Stellar is a **decentralized payment network** and blockchain platform designed for fast, low-cost cross-border transactions and asset transfers. The network uses the **Stellar Consensus Protocol (SCP)**, a federated Byzantine agreement protocol that enables rapid transaction finality without traditional mining. Stellar facilitates **multi-currency transactions** and **asset tokenization** through built-in decentralized exchange functionality.

## Interacting with Stellar's APIs

Stellar supports REST API methods through Horizon for querying ledger data, account information, and transaction history, plus the Stellar RPC API for smart contract deployment and invocation. Developers can use the Stellar SDK libraries (available in JavaScript, Python, Java, Go, and other languages) or standard HTTP clients to communicate with Stellar nodes.

The Quicknode Stellar documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official [Stellar documentation](https://developers.stellar.org/) for the latest updates and features.

## Make Stellar API Calls

The quickest way to start building on Stellar is to create a Quicknode endpoint and send your first API request.

**Quicknode** provides managed Stellar endpoints, giving you immediate access to Stellar Mainnet and Testnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/stellar/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Stellar networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | No | Horizon: ~1.5M ledgers (~90 days) & Stellar RPC: 120,960 ledgers (~7 days) |
| Testnet | Testnet | ✓ | ✗ | No | Horizon: ~1.43M ledgers (~90 days) & Stellar RPC: 17280 ledgers (~1 days) |

Complete reference for developers building on Stellar with Quicknode:

-   [QuickStart](/docs/stellar/quickstart): Get started with Stellar quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/stellar/endpoints): Learn how to configure and manage your Stellar endpoints for optimal performance and reliability.
-   [API Overview](/docs/stellar/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/stellar/add-ons): Discover endpoint add-ons that extend your Stellar development workflow.
-   [Endpoint Security](/docs/stellar/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/stellar/error-references): Understand common error codes and troubleshooting steps for Stellar API requests.

---

> For the complete documentation index, see [llms.txt](/docs/llms.txt)

---
title: Streams – Real-Time Blockchain Data
description: Stream real-time and historical blockchain data to webhooks, S3, PostgreSQL, Kafka, and more. Filter with Go or JavaScript. 60+ chains supported.
tags: []
---

Streams is a powerful data streaming solution designed for web3 applications. It enables you to efficiently collect, process, and store both raw and filtered blockchain data in real-time and historically. Whether you're building indexers, analytics platforms, or real-time dashboards, Streams provides the infrastructure to create robust data pipelines with features like batching, backfill, compression and continuous streaming.

Get Started

[

QuickStart

Set up your first stream via the UI or REST API

](/docs/streams/quickstart)[

Supported Chains

All blockchain networks available in Streams

](/docs/streams/supported-chains)

Build Your Pipeline

[

Data Sources

Block, receipt, trace, log, and chain-specific datasets

](/docs/streams/data-sources)[

Destinations

Webhook, S3, PostgreSQL, Azure Blob, Kafka

](/docs/streams/destinations)[

Filters

Server-side Go or JavaScript functions to transform data before delivery

](/docs/streams/filters)[

Backfilling & Reorgs

Historical data backfill and reorg handling guarantees

](/docs/streams/backfilling)

API Reference & Billing

[

REST API

Create, update, pause, and delete streams programmatically

](/docs/streams/rest-api)[

Billing

How consumption is measured and billed

](/docs/streams/billing)

FAQ & Resources

[

Resources

Frequently asked questions, guides, and how to get help

](/docs/streams/faq)

---

---
title: Sui RPC
description: Get started with Sui RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Sui RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Sui](https://www.quicknode.com/chains/sui) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=sui)

## What is Sui?

Sui is a high-performance layer-1 blockchain focused on low-latency transaction processing and horizontal scalability. Built around the Move programming language, it enables fast finality and high throughput for on-chain applications like gaming, finance, and real-time experiences. Developers write smart contracts in Move, a Rust-based language designed for secure and efficient execution.

## Interacting With Sui APIs

Sui provides multiple API interfaces for blockchain interaction:

-   **GraphQL** - Flexible queries with precise field selection and nested data access for efficient retrieval (Beta)
-   **JSON-RPC** - Traditional RPC methods for querying objects, executing transactions, and interacting with Move contracts (Deprecated, deactivating July 2026)
-   **gRPC** - High-performance protocol for efficient queries and transaction submissions. Includes archive support for historical data beyond 14 epochs

You can connect by running your own Sui node with the appropriate interfaces enabled, or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

* * *

## Make Sui API Calls

The quickest way to start building on Sui is to create a Quicknode endpoint and send your first request. Quicknode provides managed Sui endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/sui/quickstart) page to create your endpoint and send your first request.

* * *

## Supported Networks

Quicknode provides access to Sui Mainnet and Testnet.

**Network Availability:**

-   **Mainnet**: All APIs (GraphQL, JSON-RPC, gRPC) + Archive support (gRPC only)
-   **Testnet**: gRPC and JSON-RPC only (GraphQL and Archive not available)

**Infrastructure Regions:**

Quicknode's Sui infrastructure is deployed across the following regions:

| API | Mainnet | Testnet |
| --- | --- | --- |
| JSON-RPC / gRPC | EU, US | EU |
| GraphQL | EU, US | — |
| Archive (gRPC) | US | — |

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | Yes (gRPC only) | Full nodes: 14 epochs. Older data automatically routed to archive nodes |
| Testnet | Testnet | ✓ | ✗ | No | Full nodes: 14 epochs |

Complete reference for developers building on Sui with Quicknode:

-   [QuickStart](/docs/sui/quickstart): Get started with Sui quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/sui/endpoints): Learn how to configure and manage your Sui endpoints for optimal performance and reliability.
-   [API Overview](/docs/sui/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/sui/add-ons): Discover endpoint add-ons that extend your Sui development workflow.
-   [Endpoint Security](/docs/sui/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/sui/error-references): Understand common error codes and troubleshooting steps for Sui API requests.

---

---
title: Tempo RPC
description: Get started with Tempo RPC on Quicknode. Access reliable, low-latency infrastructure for Tempo with globally distributed endpoints.
---

# Tempo RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Tempo](https://www.quicknode.com/chains/tempo) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=tempo)

Beta

Beta

## Tempo Overview

Tempo is a purpose-built Layer 1 blockchain designed specifically for payments. The EVM-compatible network achieves over 100,000 transactions per second with sub-second finality and near-zero transaction fees.

The blockchain supports all major stablecoins with native interoperability and offers payment-specific features like batch transfers, memo fields, and compliance tools including blocklists and allowlists. Transaction fees can be paid in any supported stablecoin.

## Interacting with Tempo

Tempo implements the standard Ethereum JSON-RPC interface. Developers can use familiar Ethereum tools and libraries to query balances, transactions, and contract state, send transactions, and deploy smart contracts.

As an EVM-compatible Layer 1 blockchain, Tempo supports standard Ethereum JSON-RPC methods. Some endpoints or behaviors may differ from standard Ethereum implementations due to Tempo's payment-focused architecture. Refer to the [official Tempo documentation](https://tempo.xyz/) for specific API details.

## Make Tempo API Calls

Create a Quicknode endpoint to start building on Tempo and send JSON-RPC requests.

**Quicknode managed Tempo endpoints provide:**

-   **High reliability** — globally distributed infrastructure with minimal downtime
-   **Archive data** — complete historical state for comprehensive queries
-   **Optimized performance** — low latency request handling for production applications

> Visit the [QuickStart](/docs/tempo/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Tempo networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 4217 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 42429 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Tempo with Quicknode:

-   [QuickStart](/docs/tempo/quickstart): Get started with Tempo quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/tempo/endpoints): Learn how to configure and manage your Tempo endpoints for optimal performance and reliability.
-   [API Overview](/docs/tempo/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/tempo/add-ons): Discover endpoint add-ons that extend your Tempo development workflow.
-   [Endpoint Security](/docs/tempo/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/tempo/error-references): Understand common error codes and troubleshooting steps for Tempo API requests.

---

---
title: TON RPC
description: Get started with TON RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# TON RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [TON](https://www.quicknode.com/chains/ton) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=ton)

Beta

Beta

## TON Overview

TON (The Open Network) is designed for mass adoption with millions of transactions per second capability. The network uses **proof-of-stake consensus** and **dynamic sharding** to achieve high throughput and low transaction costs. TON facilitates **instant payments**, **smart contracts**, and **decentralized applications** with its unique multi-blockchain architecture.

## Interacting with TON's APIs

TON supports HTTP API methods for querying blockchain data, account information, transaction history, and smart contract interactions. Developers can use the TON SDK libraries (available in JavaScript, Python, and other languages) or standard HTTP clients to communicate with TON nodes and access the network's capabilities.

The Quicknode TON documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official [TON documentation](https://docs.ton.org/) for the latest updates and features.

## Make TON API Calls

The quickest way to start building on TON is to create a Quicknode endpoint and send your first API request.

**Quicknode** provides managed TON endpoints, giving you immediate access to TON Mainnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/ton/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following TON networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | Yes | None |

Complete reference for developers building on TON with Quicknode:

-   [QuickStart](/docs/ton/quickstart): Get started with TON quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/ton/endpoints): Learn how to configure and manage your TON endpoints for optimal performance and reliability.
-   [API Overview](/docs/ton/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/ton/add-ons): Discover endpoint add-ons that extend your TON development workflow.
-   [Endpoint Security](/docs/ton/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.

---

---
title: Tron RPC
description: Get started with Tron RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Tron RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Tron](https://www.quicknode.com/chains/tron) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=tron)

## What is Tron?

Tron is a high-throughput, low-cost blockchain platform that uses Delegated Proof of Stake (DPoS) for fast block production and scalability. It offers EVM-compatible JSON-RPC endpoints and native Tron-specific APIs for account management, transactions, and smart contract interactions.

## Interacting With Tron APIs

Tron exposes multiple interfaces for programmatic access. You can use:

-   Ethereum-compatible JSON-RPC methods for contract and chain interactions
-   Tron HTTP APIs under `/wallet` for account and transaction operations
-   Tron Solidity HTTP APIs under `/walletsolidity` for contract/state queries
-   gRPC for high-performance access to node services

You can connect by running your own Tron node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

* * *

## Make Tron API Calls

The quickest way to start building on Tron is to create a Quicknode endpoint and send your first request. Quicknode provides managed Tron endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/tron/quickstart) page to create your endpoint and send your first request.

* * *

## Supported Networks

Quicknode provides access to Tron Mainnet and Nile Testnet.

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 728126428 | ✓ | ✗ | Yes | None |
| Nile Testnet | Testnet | 3448148188 | ✓ | ✗ | Yes | None |

Complete reference for developers building on TRON with Quicknode:

-   [QuickStart](/docs/tron/quickstart): Get started with TRON quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/tron/endpoints): Learn how to configure and manage your TRON endpoints for optimal performance and reliability.
-   [API Overview](/docs/tron/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/tron/add-ons): Discover endpoint add-ons that extend your TRON development workflow.
-   [Endpoint Security](/docs/tron/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/tron/error-references): Understand common error codes and troubleshooting steps for TRON API requests.

---

---
title: Unichain RPC
description: Get started with Unichain RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Unichain RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Unichain](https://www.quicknode.com/chains/unichain) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=unichain)

Beta

Beta

## What is Unichain?

Unichain is an Ethereum Layer 2 network built on the [Superchain](https://www.superchain.eco/) (an Optimism-led network of OP Stack chains that share security, standards, and tooling). It’s an EVM-compatible rollup designed for fast, low-cost transactions and seamless Ethereum interoperability, intended to be a faster and cheaper L2 and a home of DeFi and liquidity across chains. It supports standard Ethereum JSON-RPC methods along with OP-Node–specific endpoints for rollup state and synchronization.

## Interacting With Unichain APIs

Unichain exposes Ethereum-compatible JSON-RPC and rollup-specific methods that allow developers to interact with the network programmatically. You can query blocks and transactions, deploy and interact with smart contracts, and access rollup status and configuration.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

* * *

## Make Unichain API Calls

The quickest way to start building on Unichain is to create a Quicknode endpoint and send your first request. Quicknode provides managed Unichain endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/unichain/quickstart) page to create your endpoint and send your first request.

* * *

## Supported Networks

Quicknode provides access to Unichain Mainnet and Testnet.

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 130 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 1301 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Unichain with Quicknode:

-   [QuickStart](/docs/unichain/quickstart): Get started with Unichain quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/unichain/endpoints): Learn how to configure and manage your Unichain endpoints for optimal performance and reliability.
-   [API Overview](/docs/unichain/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/unichain/add-ons): Discover endpoint add-ons that extend your Unichain development workflow.
-   [Endpoint Security](/docs/unichain/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/unichain/error-references): Understand common error codes and troubleshooting steps for Unichain API requests.

---

---
title: Vana RPC
description: Get started with Vana RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Vana RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Vana](https://www.quicknode.com/chains/vana) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=vana)

Beta

Beta

## Vana Overview

Vana is a network for user-owned data. Through the Vana L1, users can pool their data in Data Liquidity Pools (DLPs) with control and privacy. Developers can access decentralized datasets to build applications like AI models and data-driven dApps. The Vana network is EVM-compatible and supports Ethereum JSON-RPC methods.

## Interacting With Vana APIs

Vana exposes Ethereum-compatible JSON-RPC methods that allow developers to interact with the network programmatically. You can query blockchain state, send transactions, deploy and interact with smart contracts, and subscribe to real-time events via WebSocket.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

The Quicknode Vana documentation is continuously updated, but we recommend cross-referencing with the [official Vana documentation](https://docs.vana.org/docs/home) for the latest API details.

## Make Vana API Calls

The quickest way to start building on Vana is to create a Quicknode endpoint and send your first request. Quicknode provides managed Vana endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/vana/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Vana networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 1480 | ✓ | ✓ | Yes | None |
| Moksha | Testnet | 14800 | ✓ | ✓ | Yes | None |

Complete reference for developers building on Vana with Quicknode:

-   [QuickStart](/docs/vana/quickstart): Get started with Vana quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/vana/endpoints): Learn how to configure and manage your Vana endpoints for optimal performance and reliability.
-   [API Overview](/docs/vana/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/vana/add-ons): Discover endpoint add-ons that extend your Vana development workflow.
-   [Endpoint Security](/docs/vana/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/vana/error-references): Understand common error codes and troubleshooting steps for Vana API requests.

---

---
title: Getting Started with Webhooks
description: Quicknode Webhooks is a lightweight streaming service that delivers real‑time blockchain notifications to any HTTP endpoint for Ethereum, Solana, and more.
---

## Overview

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


[Quicknode Webhooks](https://dashboard.quicknode.com/webhooks?utm_source=internal&utm_campaign=docs&utm_content=webhooks-getting-started) is a real-time blockchain event delivery service that sends filtered on-chain data directly to your HTTP endpoints. It makes it easy to get the data you need like token transfers or contract events, without constantly polling or building complex infrastructure.

> Watch this video to learn about Quicknode Webhooks and see how it delivers real-time blockchain events to your Webhooks servers.

Subscribe to our YouTube channel for more videos![Subscribe](https://www.youtube.com/@Quicknode?sub_confirmation=1)

### Common Use Cases

Webhooks is ideal for building:

-   **Trading Bots**: Monitor DEX swaps and liquidity changes in real-time
-   **Analytics Dashboards**: Track token movements, whale activity, and protocol metrics
-   **Notification Systems**: Alert users about on-chain activity
-   **Wallet Tracking**: Follow specific wallet activity such as token transfers
-   **Contract Event Tracking**: Monitor specific events emitted by smart contracts, such as new mints, approvals, or function calls
-   **DeFi Monitoring**: Watch lending positions, yield farming rewards, and liquidation events
-   **NFT Trackers**: Follow mints, transfers, and marketplace activity for collections

### Key Capabilities

  

-   **Real‑time delivery**: Receive events just after they land on‑chain
-   **Guided wizard**: Pick a chain, select a no-code template or write your own filter, set your URL, and that's it
-   **Templates**: One‑click no-code forms support common patterns such as token transfers, contract events, and more
-   **Retry logic**: Automatic retries for non‑200 responses
-   **Compression**: Compress payloads with gzip to reduce payload size
-   **Reorg handling**: Automatically handle blockchain reorganizations to ensure data consistency
-   **Upgrade to Streams**: Do you need historical backfilling, batching, or different destinations? Check out [Streams](/docs/streams?utm_source=internal&utm_campaign=docs&utm_content=webhooks-getting-started)

### Pricing

Webhooks are priced at a flat rate of **30 API credits** for every payload delivered. For example, if you get 100 payloads delivered, it will be charged at **3000 API credits**. For more details on the pricing model, check out our [Pricing](https://www.quicknode.com/pricing?utm_source=internal&utm_campaign=docs&utm_content=webhooks-getting-started) page.

## Getting Started with Quicknode Webhooks

Setting up a webhook is a straightforward process. Here's how you can get started:

### Step 1: Access the Webhooks Dashboard

Log in to your [Quicknode account](http://dashboard.quicknode.com/?utm_source=internal&utm_campaign=docs&utm_content=webhooks-getting-started) and navigate to the [Webhooks](https://dashboard.quicknode.com/webhooks?utm_source=internal&utm_campaign=docs&utm_content=webhooks-getting-started) section in your dashboard.

### Step 2: Create Your First Webhook

Click **Create Webhook** to launch the guided wizard to get started right away. This wizard will guide you through the process of setting up your webhook, from selecting your network to defining your filters and target URL.

### Step 3: Configure Your Webhook

#### Chain Selection

Select the blockchain network you want to monitor. This is the first step in telling Webhooks where to listen for events.

#### Filter Selection

Next, you'll define what kind of events you want to receive. Webhooks provides one-click templates for common patterns like "Wallet transfers" or "Contract events." These templates pre-configure the necessary filters and just require you to specify the relevant parameters, such as wallet addresses or contract addresses.

You can use the **Wallet transfers** template on **Ethereum Mainnet** to get alerted when new activity across ETH, ERC-20, and ERC-721 transfers occurs for a specific wallet address.

  

Need a specific filter?

If none of the available templates meet your needs, you can request a new template by contacting our support team. For more advanced filtering capabilities, consider upgrading to [Streams](/docs/streams?utm_source=internal&utm_campaign=docs&utm_content=webhooks-getting-started), which supports custom JavaScript-based filters.

### Step 4: Test Your Filter

Before activating your webhook, it's crucial to test your filter to ensure it's working correctly and capturing the events you intend. To test your filter:

-   Select a block number for testing
-   Click **Run** next to the test block number input field
-   Review example payload to test everything is working as expected

### Step 5: Set Up Your Webhook URL

Enter the URL where you want to receive the payloads. Quicknode will send POST requests to this URL. The payload format will be the same as the one you see in the test payload, so you can easily parse it on your server.

You can use services like [TypedWebhook](https://typedwebhook.tools/), [Webhook.site](https://webhook.site/), or [ngrok](https://ngrok.com/) to test your webhook configuration before implementing your own endpoint.

Before creating your webhook, let's explore some additional options you can configure.

#### Validation Token

Each webhook has a validation token that you can use to verify the authenticity of the webhook. This token is generated automatically and can be found in the **Webhooks** dashboard. By using the validation token, you can validate incoming webhook messages and ensure they originate from your webhook.

#### Compression

Quicknode Webhooks provides a compression option to optimize your data delivery. You can choose to compress payloads with gzip to reduce their size.

While the cost for Webhooks is based on the number of payloads delivered, using compression can still offer benefits for your infrastructure. Smaller payload sizes lead to:

-   **Reduced Bandwidth Usage**: This can lower your data transfer costs if you're charged based on the amount of data transferred.
-   **Faster Processing**: Smaller payloads transmit quicker and may be processed more efficiently by your receiving server, reducing server load.

Learn more about compression

For detailed strategies on reducing costs with data compression, check out our [Reduce Streams Costs with Data Compression](https://www.quicknode.com/guides/quicknode-products/streams/reduce-streams-costs-with-data-compression) guide.

### Step 6: Create Your Webhook

Finally, give your webhook a descriptive name to recognize it later, and click the button to create your webhook. Your webhook will now be live and streaming real-time data to your specified URL whenever your conditional filter is met.

## Security

### HMAC Verification (Recommended)

The recommended way to secure your Webhook's destination endpoint is by implementing HMAC verification. This cryptographic method ensures that the incoming messages are coming from Webhooks and haven't been tampered with. For detailed information on implementing HMAC verification, see our guide on [Validating Incoming Streams Webhook Messages](https://www.quicknode.com/guides/quicknode-products/streams/validating-incoming-streams-webhook-messages).

### IP Allowlisting (Additional Security)

As an additional security measure, you can restrict access to your destination endpoint to specific IP addresses. Webhooks delivers data from the following IP address:

```text
141.148.40.227
```

By adding this IP to your allowlist, you can add an extra layer of security to ensure that only legitimate Webhooks traffic is accepted by your webhook server.

## Frequently Asked Questions

**What are Quicknode Webhooks?**

Quicknode Webhooks is a real-time blockchain event delivery service that sends filtered on-chain data directly to your HTTP endpoints, eliminating the need for constant polling or complex infrastructure.

**How do I create a Webhook?**

Log in to your Quicknode account, navigate to the Webhooks section, click "Create Webhook" to launch the guided wizard, select your blockchain network, define your filters using templates or custom code, enter your target URL, name your webhook, and click create.

**What can I use Webhooks for?**

Webhooks are ideal for building trading bots, analytics dashboards, notification systems, wallet tracking, contract event monitoring, DeFi monitoring, and NFT trackers.

**How do I secure my Webhook endpoint?**

Implement HMAC verification to cryptographically validate incoming messages, and optionally add IP allowlisting by restricting access to Quicknode's delivery IP address (141.148.40.227).

**Does Quicknode retry failed webhook deliveries?**

Yes, Quicknode Webhooks includes automatic retry logic for non-200 responses to ensure reliable delivery.

**Can I compress Webhook payloads?**

Yes, you can enable gzip compression to reduce payload size, which decreases bandwidth usage and speeds up processing on your server.

### Additional Resources

-   [Quicknode Webhooks](https://dashboard.quicknode.com/webhooks?utm_source=internal&utm_campaign=docs&utm_content=webhooks-getting-started)
-   [Quicknode Filters Documentation](/docs/streams/filters#example-filter-functions)
-   [Quicknode Webhooks Guides](https://www.quicknode.com/guides/tags/webhooks?utm_source=internal&utm_campaign=docs&utm_content=webhooks-getting-started)

---

---
title: World Chain RPC
description: Get started with World Chain RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# World Chain RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [World Chain](https://www.quicknode.com/chains/worldchain) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=worldchain)

Beta

Beta

## World Chain Overview

World Chain is an EVM Layer 2 built on the OP Stack for human-first applications. It integrates World ID to prioritize real people over bots, offers gas credits to verified users, and reaches users through World App. As an EVM L2, it’s compatible with standard Ethereum tooling and exposes OP-Stack rollup APIs.

## Interacting with World Chain APIs

World Chain exposes Ethereum-compatible JSON-RPC and rollup-specific methods that allow developers to interact with the network programmatically. You can query blocks and transactions, deploy and interact with smart contracts, and access rollup status and configuration.

You can connect by running your own node or by using a hosted provider such as Quicknode, which offers reliable, low-latency access without the need to manage infrastructure.

The Quicknode World Chain documentation is continuously updated, but we recommend cross-referencing with the [official World Chain documentation](https://docs.world.org/world-chain) for the latest API details.

## Make World Chain API Calls

The quickest way to start building on World Chain is to create a Quicknode endpoint and send your first request. Quicknode provides managed World Chain endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Enhanced performance — optimized latency and request handling for production-grade apps

Visit the [QuickStart](/docs/worldchain/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following World Chain networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 480 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 4801 | ✓ | ✓ | Yes | None |

Complete reference for developers building on World Chain with Quicknode:

-   [QuickStart](/docs/worldchain/quickstart): Get started with World Chain quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/worldchain/endpoints): Learn how to configure and manage your World Chain endpoints for optimal performance and reliability.
-   [API Overview](/docs/worldchain/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/worldchain/add-ons): Discover endpoint add-ons that extend your World Chain development workflow.
-   [Endpoint Security](/docs/worldchain/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/worldchain/error-references): Understand common error codes and troubleshooting steps for World Chain API requests.

---

---
title: X Layer RPC
description: Get started with X Layer RPC on Quicknode. Access reliable, low-latency infrastructure for X Layer with globally distributed endpoints.
---

# X Layer RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [X Layer](https://www.quicknode.com/chains/xlayer) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=xlayer)

Beta

Beta

## What is X Layer?

X Layer is a zero-knowledge rollup (zkRollup) Layer 2 solution for Ethereum, built on zkEVM technology. It uses a hybrid proof approach — generating STARK proofs for execution and then recursively wrapping them into a SNARK for efficient on-chain verification. This ensures transactions are mathematically valid while inheriting Ethereum’s security.

Unlike optimistic rollups, X Layer does not require challenge periods for withdrawals because validity proofs provide cryptographic certainty once submitted. Finality depends on proof submission intervals — typically minutes rather than days — but is still faster than optimistic rollups. Transaction costs are significantly reduced compared to Ethereum mainnet, with savings coming from transaction batching and calldata compression.

X Layer achieves bytecode-level compatibility with the Ethereum Virtual Machine (EVM). This zkEVM architecture supports nearly all EVM opcodes and precompiles, with only minor differences in edge cases such as gas costs. This ensures that most existing Ethereum smart contracts and applications can be deployed without modification, preserving broad compatibility with Ethereum's execution environment, tooling, and developer ecosystem while providing zero-knowledge security guarantees.

## Interacting with X Layer

X Layer fully supports the standard Ethereum JSON-RPC interface while also providing additional Layer 2–specific functionality. This ensures complete compatibility with existing Ethereum tooling, so developers can use X Layer seamlessly with tools such as MetaMask, Hardhat, Foundry, and Web3 libraries **without code changes**.

With the X Layer API, you can:

-   Execute all standard Ethereum JSON-RPC methods (`eth_call`, `eth_sendTransaction`, `eth_getBalance`)
-   Access X Layer–specific methods for rollup operations (e.g., querying proof status and bridge interactions)
-   Query bridge activity, batch submissions, and proof verification status
-   Subscribe to real-time L2 events via WebSocket connections
-   Use available tracing and inspection utilities for deeper blockchain debugging

You can connect to the API by:

-   Running a local X Layer node
-   Using a hosted provider such as a Quicknode X Layer endpoint, which provides access to X Layer Mainnet with high reliability, archive data, and enhanced performance

## Supported Networks

Quicknode provides access to the following X Layer networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 196 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 1952 | ✓ | ✓ | Yes | None |

Note:

XLayer uses a re-genesis at block **42,810,021**. Historical data before this block is available but stored on legacy nodes and automatically routed when you provide a specific block number for methods like `eth_getBlockByNumber`, `eth_getBalance`, and `debug_trace*`.

Block 42,810,021 itself is untraceable and may return `{"code":4444,"message":"pruned history unavailable"}`.

Transaction Node Requirements

X Layer uses two different node clients split at the re-genesis boundary (block **42,810,021**):

-   **Block `42,810,021` and earlier** — Requires a **cdk-Erigon** node. Geth nodes return `null` for these historical transactions.
-   **After block `42,810,021`** — Requires a **Geth** node. Erigon nodes return `null` for these current transactions.

To query pre-regenesis data, include the `x-qn-height` header with the target block number in your request to route it to the **cdk-Erigon** node. Without this header, requests default to the **Geth** node, so the header is not required for post-regenesis blocks.

**Pre-Regenesis Example (cdk-Erigon, block ≤ 42,810,021):**

```bash
curl --location 'https://docs-demo.xlayer-mainnet.quiknode.pro/' \

--header 'Content-Type: application/json' \

--header 'x-qn-height: 42810020' \

--data '{"method":"eth_getBlockByNumber","params":["0x28D3AA4",false],"id":1,"jsonrpc":"2.0"}'
```

**Post-Regenesis Example (Geth, block > 42,810,021):**

```bash
curl --location 'https://docs-demo.xlayer-mainnet.quiknode.pro/' \

--header 'Content-Type: application/json' \

--data '{"method":"eth_getBlockByNumber","params":["0x28D3AA6",false],"id":1,"jsonrpc":"2.0"}'
```

Complete reference for developers building on X Layer with Quicknode:

-   [QuickStart](/docs/xlayer/quickstart): Get started with X Layer quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/xlayer/endpoints): Learn how to configure and manage your X Layer endpoints for optimal performance and reliability.
-   [API Overview](/docs/xlayer/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/xlayer/add-ons): Discover endpoint add-ons that extend your X Layer development workflow.
-   [Endpoint Security](/docs/xlayer/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/xlayer/error-references): Understand common error codes and troubleshooting steps for X Layer API requests.

---

---
title: XRP Ledger RPC
description: Get started with XRP Ledger RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# XRP Ledger RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [XRP Ledger](https://www.quicknode.com/chains/xrp) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=xrpl)

## XRP Ledger Overview

The XRP Ledger is a **decentralized, public blockchain** built for payments and financial applications. It uses a unique **consensus protocol** that doesn't rely on mining or proof-of-work, enabling fast transaction settlement typically within **3-5 seconds** with minimal energy consumption. The network facilitates **cross-currency payments**, **decentralized exchange functionality**, and **tokenization** through its native DEX and token issuance features.

## Interacting with XRP Ledger's APIs

XRP Ledger supports JSON-RPC API methods for querying ledger state, account information, transaction history, and submitting transactions. Developers can use XRPL libraries (available in JavaScript, Python, Java, and other languages) or standard HTTP/WebSocket clients to communicate with XRPL nodes and access the network's payment and exchange capabilities.

The Quicknode XRP Ledger documentation is continuously evolving as the network undergoes upgrades and changes, so we highly recommend cross-referencing with the official [XRPL documentation](https://xrpl.org/docs.html) for the latest updates and features.

## Make XRP Ledger API Calls

The quickest way to start building on XRP Ledger is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed XRP Ledger endpoints, giving you immediate access to XRPL Mainnet and Testnet without the overhead of running infrastructure. These endpoints offer:

  

-   **High reliability** – globally distributed infrastructure designed to minimize downtime
-   **Enhanced performance** – optimized latency and request handling for production-grade apps
-   **Integrated ecosystem** – additional functionality through Quicknode add-ons and products like Streams

> Visit the [QuickStart](/docs/xrpl/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following XRPL networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✓ | Yes | Starts from ledger 32570 (Genesis) |
| Testnet | Testnet | ✓ | ✓ | Yes | Full history after recent network reset |

Complete reference for developers building on XRPL with Quicknode:

-   [QuickStart](/docs/xrpl/quickstart): Get started with XRPL quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/xrpl/endpoints): Learn how to configure and manage your XRPL endpoints for optimal performance and reliability.
-   [API Overview](/docs/xrpl/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/xrpl/add-ons): Discover endpoint add-ons that extend your XRPL development workflow.
-   [Endpoint Security](/docs/xrpl/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/xrpl/error-references): Understand common error codes and troubleshooting steps for XRPL API requests.

---

---
title: XRPL EVM RPC
description: Get started with XRPL EVM RPC on Quicknode. Access reliable, low-latency infrastructure for XRPL EVM with globally distributed endpoints.
---

# XRPL EVM RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [XRPL EVM](https://www.quicknode.com/chains/xrplevm) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=xrplevm)

Beta

Beta

## XRPL EVM Overview

XRPL EVM is an Ethereum Virtual Machine-compatible sidechain that extends the XRP Ledger ecosystem by enabling Ethereum smart contract capabilities. Built on the Cosmos SDK with a Proof-of-Authority consensus model, it uses XRP as the native gas token, providing ultra-low transaction fees and fast block finalization in 3-5 seconds. The sidechain supports full Ethereum compatibility, allowing developers to deploy Solidity smart contracts, use MetaMask, and leverage existing Ethereum tooling while benefiting from XRPL's speed and cost-efficiency. With Inter-Blockchain Communication (IBC) support and Axelar Network integration, XRPL EVM enables seamless interoperability across 120+ Cosmos ecosystem blockchains and cross-chain asset transfers.

## Interacting with XRPL EVM

XRPL EVM exposes a standard Ethereum JSON-RPC interface, allowing developers to interact with the network using familiar Ethereum tools and libraries. You can query balances, transactions, and contract state; send transactions; and deploy or interact with smart contracts directly.

Because XRPL EVM is an **EVM-compatible sidechain** built with the **Cosmos SDK** and powered by **CometBFT consensus**, most Ethereum JSON-RPC methods are supported, though some endpoints or behaviors may differ. For the latest API details, refer to the [official XRPL EVM documentation](https://docs.xrplevm.org/).

## Make XRPL EVM API Calls

The quickest way to start building on XRPL EVM is to create a Quicknode endpoint and send your first JSON-RPC request.

Quicknode provides managed XRPL EVM endpoints, offering:

-   High reliability — globally distributed infrastructure designed to minimize downtime
-   Archive data — full historical state for in-depth queries
-   Enhanced performance — optimized latency and request handling for production-grade apps

> Visit the [QuickStart](/docs/xrplevm/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following XRPL EVM networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 1440000 | ✓ | ✓ | Yes | None |
| Testnet | Testnet | 1449000 | ✓ | ✓ | Yes | None |

Complete reference for developers building on XRPL EVM with Quicknode:

-   [QuickStart](/docs/xrplevm/quickstart): Get started with XRPL EVM quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/xrplevm/endpoints): Learn how to configure and manage your XRPL EVM endpoints for optimal performance and reliability.
-   [API Overview](/docs/xrplevm/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/xrplevm/add-ons): Discover endpoint add-ons that extend your XRPL EVM development workflow.
-   [Endpoint Security](/docs/xrplevm/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/xrplevm/error-references): Understand common error codes and troubleshooting steps for XRPL EVM API requests.

---

---
title: Zcash RPC
description: Get started with Zcash RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for Zcash development and integration.
---

# Zcash RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Zcash](https://www.quicknode.com/chains/zcash) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=zcash)

## Zcash Overview

Zcash is a privacy-focused cryptocurrency that extends the Bitcoin protocol with advanced cryptographic techniques. Built on zero-knowledge proofs (zk-SNARKs), Zcash provides:

  

-   **Shielded Transactions**: Optional privacy through zero-knowledge proofs for confidential transfers
-   **Selective Disclosure**: Users can choose between transparent and shielded addresses
-   **Decentralized Network**: Proof-of-work consensus securing the blockchain
-   **Bitcoin Foundation**: Based on Bitcoin's codebase with enhanced privacy features

Zcash offers the choice between transparent transactions (similar to Bitcoin) and shielded transactions that hide the sender, receiver, and amount. This dual-address system allows users to comply with regulations while maintaining privacy when needed.

## Interacting with Zcash's APIs

Zcash provides a comprehensive JSON-RPC API that enables developers to interact with the Zcash network programmatically. The API supports operations including transaction management, blockchain queries, and network monitoring.

Zcash's RPC interface follows standard JSON-RPC 2.0 protocols, making it compatible with most programming languages and development frameworks. Like Bitcoin, Zcash uses a UTXO model, but extends it with shielded transaction pools (Sprout, Sapling, and Orchard) for privacy-preserving transfers.

## Make Zcash API Calls

The quickest way to start building on Zcash is to create a Quicknode endpoint and send your first JSON-RPC request.

**Quicknode** provides managed Zcash endpoints, giving you immediate access to Zcash without the complexity of running your own Zcash node. These endpoints offer:

-   **High reliability** – globally distributed infrastructure with 99.9% uptime SLA
-   **Enhanced performance** – optimized for low latency with advanced caching layers
-   **Enterprise features** – advanced analytics, debugging tools, and dedicated support

> Visit the [QuickStart](/docs/zcash/quickstart) page to create your endpoint and send your first request.

## Supported Networks

Quicknode provides access to the following Zcash networks:

| Network | Type | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- |
| Mainnet | Production | ✓ | ✗ | No | Pruning disabled |
| Testnet | Testnet | ✓ | ✗ | No | Pruning disabled |

Complete reference for developers building on Zcash with Quicknode:

-   [QuickStart](/docs/zcash/quickstart): Get started with Zcash quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/zcash/endpoints): Learn how to configure and manage your Zcash endpoints for optimal performance and reliability.
-   [API Overview](/docs/zcash/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/zcash/add-ons): Discover endpoint add-ons that extend your Zcash development workflow.
-   [Endpoint Security](/docs/zcash/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/zcash/error-references): Understand common error codes and troubleshooting steps for Zcash API requests.

---

---
title: zkSync RPC
description: Get started with zkSync RPC on Quicknode. Access reliable, low-latency infrastructure for zkSync Era with globally distributed endpoints for zero-knowledge Layer 2 scaling.
---

# zkSync RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [zkSync](https://www.quicknode.com/chains/zksync) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Try free](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=zksync)

## What is zkSync?

zkSync Era is a zero-knowledge rollup (zkRollup) Layer 2 solution for Ethereum developed by Matter Labs. It uses SNARK-based cryptographic proofs to batch transactions off-chain and verify them on Ethereum mainnet, ensuring all transactions are mathematically valid while inheriting Ethereum's security.

Unlike optimistic rollups, zkSync does not require challenge periods for withdrawals because validity proofs provide immediate cryptographic certainty. This enables faster finality compared to optimistic rollups and significantly reduces transaction costs relative to Ethereum mainnet.

zkSync Era uses a zkEVM architecture, allowing Solidity smart contracts to be compiled into zkSync-compatible bytecode. The system was designed to eventually support zkPorter, a hybrid data-availability solution that could lower costs further by storing some data off-chain. However, zkPorter is not currently available on mainnet.

## Interacting with zkSync

zkSync extends the standard Ethereum JSON-RPC interface with Layer 2–specific functionality, while maintaining broad compatibility with Ethereum tooling. Developers can use zkSync Era with common tools like MetaMask, Hardhat, Foundry, and Web3 libraries with minimal changes.

With this API, you can:

-   Execute standard Ethereum JSON-RPC methods (eth_call, eth_sendTransaction, eth_getBalance)
-   Access zkSync-specific methods for Layer 2 operations (e.g., zks_estimateFee, zks_getMainContract)
-   Query bridge operations and batch information
-   Subscribe to real-time events via WebSocket connections

You can connect to the API by:

-   Running a local zkSync Era node
-   Using a hosted provider such as a Quicknode zkSync endpoint, which provides access to zkSync Era Mainnet and Sepolia testnet with high reliability, archive data, and enhanced performance

## Supported Networks

Quicknode provides access to the following zkSync networks:

| Network | Type | Chain ID | HTTP | WSS | Archive | Pruning |
| --- | --- | --- | --- | --- | --- | --- |
| Mainnet | Production | 324 | ✓ | ✓ | Yes | None |
| Sepolia | Testnet | 300 | ✓ | ✓ | Yes | None |

Complete reference for developers building on zkSync with Quicknode:

-   [QuickStart](/docs/zksync/quickstart): Get started with zkSync quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
-   [Provider Endpoints](/docs/zksync/endpoints): Learn how to configure and manage your zkSync endpoints for optimal performance and reliability.
-   [API Overview](/docs/zksync/api-overview): Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
-   [Add-ons](/docs/zksync/add-ons): Discover endpoint add-ons that extend your zkSync development workflow.
-   [Endpoint Security](/docs/zksync/endpoint-security): Secure your endpoints with authentication, whitelisting, and best security practices.
-   [Error Codes](/docs/zksync/error-references): Understand common error codes and troubleshooting steps for zkSync API requests.

---

---
title: Zora RPC
description: Get started with Zora RPC on Quicknode. Access reliable, low-latency blockchain infrastructure with globally distributed endpoints for development.
---

# Zora RPC

> For the complete documentation index, see [llms.txt](/docs/llms.txt)


With Quicknode, you get access to our global [Zora](https://www.quicknode.com/chains/zora) network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

[Start building](https://www.quicknode.com/signup?utm_source=internal&utm_campaign=docs&utm_content=zora)[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

[

Select Access

](https://blog.quicknode.com/introducing-select-access-chains/)

## Overview

At Quicknode, we’re committed to helping developers and enterprises explore and build on the latest and most innovative blockchain networks. [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains) offer a flexible, on-demand infrastructure that supports emerging chains, enabling users to access a broader range of networks with high potential.

With [Select Access Chains](https://blog.quicknode.com/introducing-select-access-chains), developers can:

-   Build and innovate on cutting-edge, high-potential chains.
-   Unlock new opportunities within Web3 ecosystems.
-   Leverage Quicknode’s industry-leading reliability and performance without waiting for full infrastructure deployment.

[**Zora**](https://zora.co/) is a fast, scalable Layer 2 network designed to bring media, especially NFTs, on-chain. Unlike DeFi-focused L2 solutions, Zora prioritizes NFT creation with quick transaction times and low minting costs. It is secured by Ethereum and powered by the OP stack, aiming to expand creative possibilities on-chain.

  

Info

To learn more about Select Access Chains, check out this blog on [Introducing Select Access Chains: Your Chain, Your Choice](https://blog.quicknode.com/introducing-select-access-chains/)

## Access

You can access Zora through the [Quicknode Developer Portal](https://dashboard.quicknode.com).

For enterprises with unique needs or large-scale projects, Quicknode offers custom solutions tailored to specific requirements. Our team is ready to collaborate with you to ensure you have the infrastructure, support, and resources necessary for success in the expanding blockchain ecosystem. Talk with our team to [create a custom plan today](https://www.quicknode.com/contact-us).

## Zora Network Support

| Network | WSS | HTTPS |
| --- | --- | --- |
| MAINNET | ✅ | ✅ |

## Zora JSON-RPC API Documentation

For detailed API documentation and usage guides, please refer to the [official Zora documentation](https://docs.zora.co/zora-network/ethvszora).

## Zora Tools and Resources

| **Resource** | **Description** | **Link/Details** |
| --- | --- | --- |
| **Chain ID** | The unique identifier for the Zora network. | Mainnet: 7777777, Sepolia: 999999999 |
| **Currency Symbol** | The symbol representing the native currency for transactions on Zora. | ETH |
| **Zora Explorer** | A blockchain explorer to view transactions, blocks, and network activity on Zora. | Mainnet: [https://explorer.zora.energy](https://explorer.zora.energy) Sepolia: [https://sepolia.explorer.zora.energy](https://sepolia.explorer.zora.energy) |
| **Zora Status Page** | Provides real-time updates on Zora’s network status, uptime, and incidents. | [https://status.zora.energy/](https://status.zora.energy/) |

## API Credits

Usage in our pricing plans is measured in API Credits. To learn more about the API Credits for Zora, please visit [this page](https://www.quicknode.com/api-credits/zora).

## WebSocket Limits

WebSocket responses are capped at a certain limit, which is subject to change. In cases where responses are potentially large, it is recommended to use a **POST** request. If the response size exceeds the limit, the associated error code will be **\-32616**.

## Endpoint Authentication Options

  

Note:

Please note that setting JWT (JSON Web Tokens), configuring all whitelist options, and changing any rate limits beyond credits per second are only available to users on the **Build plan and higher**. Users on the **Free Trial** plan can only change their requests per second rate limit or add, use, and delete an authentication token. Visit [our pricing](https://www.quicknode.com/pricing) page for more information.

### Token Authentication

By default, all endpoints created on Quicknode are protected by a token in the URL which looks something like this:

  

```
http://sample-endpoint-name.network.quiknode.pro/token-goes-here/
```

### Approved Referrer List

For endpoints on the shared network, you are able to add a list of approved referrers. This requires any HTTP request to send a **REFERRER** header or any WebSocket request to send an **ORIGIN** header populated with one of the referrers you entered into our user panel.

### Disabling Token Authentication

You can also disable the token authentication completely in your security settings for a given endpoint. This will allow anyone to make requests to the endpoint without the token.

### JWT (JSON Web Tokens)

For additional security, you can also enable JWT for each of your deployed endpoints. JWT allows for stateless authentication between you and your endpoint. Learn how to use JWT with Quicknode in [this step-by-step guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-implement-json-web-tokens-jwt-authorization-with-quicknode).

### Multiple Authentication Tokens

Create multiple authentication tokens for each of your deployed endpoints. This allows you to revoke any tokens that may be comprised, without needing to restart your non-compromised endpoint.

To roll an individual authentication token, create an additional token and then delete the previous token. Learn more about multiple authentication tokens in [this Quicknode guide](https://www.quicknode.com/guides/quicknode-products/endpoint-security/how-to-set-up-multi-token-authentication-on-quicknode).