What is the peaq network blockchain, and how do you connect to it?

peaq is a Layer-1 blockchain designed for machines rather than people. It targets vehicles, robots, sensors, and other devices that need a verifiable identity, a way to pay, and a place to publish data. If you searched for the peaq network blockchain, you probably want one of three things: a plain explanation of what it is, the chain settings to connect a wallet or app, or an RPC endpoint you can call from code. This page covers all three, then helps you decide what to do next.

Start here: what do you actually need from peaq?

Before you copy any endpoint, work out which of these matches your situation. It saves you from configuring a wallet when you really needed a backend node, or renting infrastructure before you have written a single request.

If you are still exploring, keep reading. If you already know you need an endpoint, jump to the chain settings section and come back for the operational guidance later.

What the peaq network blockchain is built for

Most Layer-1 chains optimise for human users: wallets, DeFi, NFTs, social apps. peaq flips that. Its core primitives are aimed at machines that act on their own behalf. That means identity (a machine can hold an address and prove it is itself), payments (machine-to-machine value transfer without a human in the loop), and data (sensor readings and device events recorded on-chain).

Two design choices matter for developers. First, peaq is EVM-compatible, so Solidity contracts, ethers, viem, Hardhat, and Foundry all work with a network change rather than a rewrite. Second, it is built on Substrate, which is why you will see both EVM-style tooling and Substrate-style tooling in the same ecosystem. In practice, most application developers stay on the EVM side and never touch the Substrate layer directly.

The native token is used for gas and for staking, and the chain exposes the usual EVM JSON-RPC surface: block queries, balances, contract calls, logs, and transaction submission. That is the surface your RPC provider has to serve well.

peaq chain settings at a glance

Use these values when adding peaq to a wallet such as MetaMask, or when configuring a client library. Always confirm the current values against the peaq network page before you ship, because chain metadata can change.

A wallet network configuration entry looks like this:

{
  "chainId": "0xCFA",
  "chainName": "peaq",
  "nativeCurrency": {
    "name": "PEAQ",
    "symbol": "PEAQ",
    "decimals": 18
  },
  "rpcUrls": ["<your peaq RPC endpoint>"],
  "blockExplorerUrls": ["<peaq explorer URL>"]
}

Note that 0xCFA is the hexadecimal form of chain ID 3338. If a wallet rejects the decimal value, use the hex form. For the exact RPC URL to place in rpcUrls, use the endpoint published on the peaq network page rather than a hard-coded value from a tutorial, since endpoints rotate.

Making your first JSON-RPC calls

Once you have an endpoint, the fastest sanity check is a raw HTTP call. This confirms the endpoint is reachable and that you are talking to the right chain before you debug any application code.

curl -s <your peaq RPC endpoint> \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_chainId",
    "params": []
  }'

A correct response returns the chain ID in hex. If you get 0xCFA, you are on peaq mainnet. If you get something else, you are pointed at the wrong network, which is the single most common cause of confusing balance and contract errors.

From JavaScript, the same check with ethers looks like this:

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("<your peaq RPC endpoint>");

const network = await provider.getNetwork();
console.log("chainId:", network.chainId.toString());

const block = await provider.getBlockNumber();
console.log("latest block:", block);

const balance = await provider.getBalance("0xYourAddress");
console.log("balance:", balance.toString());

If getBlockNumber advances between calls, the node is synced and following the chain head. If it is frozen, you are either on a stale node or a testnet that has stopped producing blocks.

Shared RPC API or dedicated peaq node?

This is the decision most teams get wrong, usually by over-buying too early or under-buying right before launch. The right answer depends on your request pattern, not on your project size.

OnFinality offers both: a managed RPC API service for teams that want to start quickly, and dedicated nodes for workloads that need isolated capacity, custom limits, or archive and trace access. You can review RPC pricing to compare the two models against your expected request volume, and browse supported RPC networks if peaq is one of several chains you operate.

A practical rule: start on a shared endpoint, instrument your request volume and error rate, and move to a dedicated node when you can point at a specific metric that shared capacity is hurting. That metric is usually log-query latency, WebSocket stability, or write throughput during peak hours.

Debugging common peaq connection problems

Most peaq issues are not chain issues. They are configuration issues. Work through this list in order.

For any of these, the first diagnostic step is always the same: run eth_chainId and eth_blockNumber against the endpoint and confirm both look correct. That single check eliminates the majority of false alarms.

Testnet work on peaq agung

If you are building before mainnet deployment, peaq agung is the testnet environment. It has its own chain ID and its own endpoint, and it is a separate network from mainnet. Do not mix the two in a single configuration file, and do not reuse mainnet keys on testnet or vice versa.

Testnet tokens come from a faucet rather than a purchase. Faucet availability and rate limits change over time, so check the current faucet link on the peaq network page rather than relying on a cached URL. When your testnet integration passes, switch the endpoint and chain ID to mainnet values and re-run your smoke tests before you point real traffic at it.

Operational checklist before you go live

Before you ship a peaq integration, confirm each of these:

• Chain ID and endpoint are pinned in configuration, not scattered through the codebase.
• You have a fallback endpoint or provider so a single outage does not take your app down.
• WebSocket clients reconnect with exponential backoff and re-subscribe after reconnect.
• Log queries are paginated by block range rather than requested in one large span.
• You monitor request success rate, latency, and error codes, not just whether the app loads.
• Testnet and mainnet configuration are clearly separated.
• You know your expected peak requests per second and have matched it to a plan.

That last point is where provider choice becomes concrete. If you cannot state your peak RPS, you are not ready to size infrastructure, and you will either overpay or hit limits at the worst moment.

Key Takeaways

• peaq is an EVM-compatible Layer-1 aimed at machines, devices, and autonomous systems, with identity, payments, and data as core primitives.
• Because it is EVM-compatible, standard Ethereum tooling works with a network change.
• The first thing to verify on any endpoint is eth_chainId; it should return the peaq chain ID.
• Shared RPC APIs suit prototyping and most frontend traffic; dedicated nodes suit indexers, heavy log queries, and predictable high-throughput backends.
• OnFinality provides both managed RPC API access and dedicated node infrastructure, with details on the peaq network page.
• Testnet (peaq agung) and mainnet are separate networks with separate settings.

Frequently Asked Questions

Is peaq EVM-compatible?

Yes. peaq exposes an EVM-compatible execution environment, so Solidity contracts and standard Ethereum libraries such as ethers and viem work with a network configuration change.

What is the peaq chain ID?

peaq mainnet uses chain ID 3338, which is 0xCFA in hexadecimal. Confirm the current value on the peaq network page before shipping, since chain metadata can be updated.

How do I add peaq to MetaMask?

Add a custom network with the network name, chain ID, currency symbol, RPC URL, and block explorer URL from the chain settings table above. Use the hex chain ID if the wallet requires it.

Do I need a dedicated node to build on peaq?

No. A shared RPC API is enough for most development, testing, and frontend traffic. Consider a dedicated node when you run indexers, need large log queries, or require predictable throughput for backend writes.

How do I get testnet tokens on peaq?

Use the faucet linked from the peaq network page. Faucet limits and availability change, so always check the current link rather than a cached one.

What should I check first when peaq calls fail?

Run eth_chainId and eth_blockNumber. If the chain ID is wrong you are on the wrong network; if the block number is frozen your node is not synced. Both checks take seconds and rule out most configuration errors.