What is the peaq network RPC and how do I connect to it?

The peaq network RPC is the endpoint that applications use to read and write data on the peaq blockchain, an EVM-compatible Layer-1 for decentralized physical infrastructure networks (DePIN) and the machine economy. If you are connecting a wallet, running an indexer, or building an automation service on peaq, the RPC endpoint is where that integration starts. This reference covers peaq chain settings, JSON-RPC basics, provider evaluation criteria, common failure modes, and how to move from a public test endpoint to production-grade access.

peaq network RPC decision checklist

Before you connect your app to a peaq RPC endpoint, work through this checklist.

• Confirm the peaq chain details: chain ID 3338, network name peaq, symbol PEAQ, and 18 decimals.
• Choose an endpoint for each environment: public endpoints for staging, managed or dedicated RPC for production.
• Verify the JSON-RPC methods you rely on exist on your selected endpoint, including eth_getLogs, eth_sendRawTransaction, and WebSocket subscriptions.
• Check WebSocket support if your dApp needs real-time block or log updates.
• Test rate limits with representative workloads instead of a single eth_blockNumber call.
• Decide whether you need archive data, trace methods, or peaq-specific pallet RPCs.
• Plan failover: keep at least two endpoints or use a provider that routes across multiple regions.

What is the peaq network RPC?

The peaq network RPC (Remote Procedure Call) is the API gateway between your application and the peaq blockchain. It lets you query chain state, estimate gas, submit transactions, and subscribe to events. Because peaq is an EVM-compatible network built on a Substrate runtime, it exposes standard Ethereum JSON-RPC methods alongside its own machine-economy features. Most Web3 tools can connect to peaq the same way they connect to any EVM chain, as long as they have the correct chain configuration.

peaq describes itself as the economic infrastructure for machines. The chain supports machine identities, reputation, payments, and tokenized ownership for robots, vehicles, sensors, and AI agents. For developers, that means RPC traffic on peaq can look different from a typical DeFi chain. You might see high-frequency telemetry writes, autonomous agent transactions, or large log queries from DePIN sensors. Those workloads make RPC selection and capacity planning more important than on chains with simple read-heavy usage.

Under the hood, peaq uses a Substrate-based runtime with an EVM compatibility layer. RPC requests can be sent through standard Ethereum JSON-RPC interfaces, while peaq-specific modules for identity, credit, and machine earnings remain available at the Substrate level. For most app developers, the EVM interface is enough. You add the peaq network configuration to your tooling and start calling methods.

peaq network chain settings

When you add the peaq network to a wallet or configure a Web3 library, use the following values.

These public endpoints are convenient for prototyping but can be rate-limited or change over time. Check ChainList or the peaq documentation for the current list. For production applications, use a managed RPC provider with an endpoint that supports scaling, WebSockets, and failover. OnFinality's peaq network page shows the managed options available.

Here is an example configuration object you can use in a wallet or in a library like viem:

const peaqNetwork = {
  id: 3338,
  name: 'peaq',
  nativeCurrency: {
    name: 'peaq',
    symbol: 'PEAQ',
    decimals: 18,
  },
  rpcUrls: {
    default: { http: ['https://quicknode1.peaq.xyz'] },
    public: { http: ['https://quicknode1.peaq.xyz'] },
  },
  blockExplorers: {
    default: { name: 'Subscan', url: 'https://peaq.subscan.io' },
  },
}

How to test a peaq RPC endpoint

You can test any peaq RPC endpoint with a simple JSON-RPC request. The following curl command returns the chain ID. If the endpoint returns 0xd0a (3338), your connection is working.

curl -X POST <YOUR_PEAQ_RPC_URL> \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'

Replace <YOUR_PEAQ_RPC_URL> with an endpoint from the table above or the one provided by your RPC provider. To check the latest block number, use:

curl -X POST <YOUR_PEAQ_RPC_URL> \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

If you are using a JavaScript client, the same calls look like this:

import { createPublicClient, http } from 'viem'

const client = createPublicClient({
  chain: peaqNetwork,
  transport: http(),
})

const blockNumber = await client.getBlockNumber()
console.log('Latest peaq block:', blockNumber)

Key JSON-RPC methods for peaq developers

Because peaq is EVM-compatible, you can use standard Ethereum JSON-RPC methods:

• eth_chainId — verify you are connected to chain 3338.
• eth_blockNumber — get the latest finalized block.
• eth_getBalance — read account balances.
• eth_call — execute read-only contract calls.
• eth_sendRawTransaction — broadcast signed transactions.
• eth_getTransactionReceipt — confirm transaction results.
• eth_getLogs — query event logs for indexing or monitoring.
• eth_subscribe — subscribe to new heads, logs, or pending transactions over WebSocket.

DePIN projects on peaq often depend on eth_getLogs for telemetry indexing. Querying very large log ranges can cause timeouts on shared endpoints. Split the range into smaller chunks or use a dedicated node if your workloads are heavy.

For Substrate-level access, peaq also exposes RPC methods for its chain-specific pallets. Most peaqOS features are available through contracts, so EVM tooling is sufficient for most builds.

How to choose a peaq RPC provider

Public peaq RPC endpoints work for development, but production dApps need an infrastructure plan. The table below summarizes what to evaluate when comparing RPC providers for the peaq network.

A peaq-specific consideration is workload shape. DePIN applications often send many small writes from many devices. A shared public endpoint may treat that as abusive traffic. A managed provider with explicit throughput limits or a dedicated node gives you predictable headroom. You should also check whether the provider's endpoint policies handle WebSocket connection limits, because autonomous machines may keep long-lived subscriptions open.

If you are evaluating providers, start with the RPC provider selection guide to formalize your criteria. The supported networks page lists the chains OnFinality manages, including peaq, and the RPC pricing page explains the difference between public, paid, and dedicated tiers.

Common peaq RPC errors and how to fix them

Even with the correct chain settings, you will run into errors. Here are the most common ones.

Chain ID mismatch

If a wallet or dApp says the chain ID is wrong, you likely entered 3338 as a decimal but the provider expects a hex value or vice versa. The hex value for peaq is 0xd0a.

Rate limit exceeded

Public peaq endpoints often return 429 Too Many Requests or empty responses under load. Mitigation: cache reads, batch requests, use a managed endpoint, or switch to a dedicated node.

eth_getLogs timeout

Scanning a wide block range in one request can exceed a gateway's response time limit. Mitigation: query smaller ranges, paginate, or run an indexer with a dedicated RPC.

Nonce too low

This happens when a wallet retries a transaction with a stale nonce. On peaq, as on other EVM chains, track the pending nonce per address and retry with eth_getTransactionCount(address, 'pending').

RPC response is empty or null

If eth_call returns null on a contract that should have a value, confirm you are using the correct block tag and that the address exists on chain 3338.

Pending transaction stuck

If a transaction is pending for a long time, the endpoint may not have propagated the submission or the gas price may be below the current minimum. Monitor the mempool and resubmit with an updated fee if necessary.

Use OnFinality for peaq network RPC

OnFinality provides peaq RPC API endpoints as part of its managed infrastructure service. The network is listed in the supported networks directory, and you can get connection details from the peaq network page. OnFinality also offers dedicated node infrastructure for teams that need isolated capacity, custom method coverage, or archive data. For teams that are still estimating traffic, the API service provides shared and scalable RPC access without running node hardware.

When you compare OnFinality with running your own peaq node, consider the operational cost. A peaq node must be kept synced, monitored, and upgraded after network releases. A managed RPC removes that workload so your team can focus on the machine-economy application layer.

Key Takeaways

• The peaq network uses chain ID 3338, native token PEAQ, and the Subscan explorer at https://peaq.subscan.io.
• peaq exposes standard EVM JSON-RPC methods, so most Ethereum tooling works with a simple network configuration.
• Public peaq RPC endpoints are fine for prototyping but can rate-limit your traffic; production apps should use managed or dedicated infrastructure.
• Verify WebSocket support, eth_getLogs behavior, and dedicated capacity before choosing a provider.
• OnFinality offers peaq RPC API and dedicated node options. See the peaq network page for details and the RPC pricing page for tier comparisons.

Frequently Asked Questions

What is the peaq network RPC?

The peaq network RPC is the API endpoint that lets applications query chain state and submit transactions on the peaq blockchain. It supports standard Ethereum JSON-RPC methods because peaq is EVM-compatible.

What is the peaq chain ID?

The peaq chain ID is 3338. In hex, that is 0xd0a.

What is the official peaq RPC URL?

There is no single official public RPC URL. The community-maintained public endpoints are currently https://quicknode1.peaq.xyz, https://quicknode2.peaq.xyz, and https://quicknode3.peaq.xyz. For production, use a managed provider and check the peaq network page for endpoint configuration.

Does peaq RPC support WebSocket subscriptions?

Peaq exposes WebSocket endpoints through managed providers and through some public endpoints. If your dApp relies on eth_subscribe, confirm websocket support with your provider before production.

Do I need a dedicated node for peaq?

That depends on your workload. A dedicated peaq node helps if you index large amounts of eth_getLogs data, send high-frequency machine transactions, or need consistent latency. Start with a shared RPC for development and upgrade when you see rate limits or performance degradation.