Acala RPC: How to Connect to Acala Network Endpoints

Quick Decision Guide: Which Acala RPC Setup Should You Use?

Before diving into endpoint lists, decide what your workload actually needs. The right Acala RPC setup depends on your stage and traffic pattern:

• Prototyping or light testing: Use the public Acala RPC endpoint for quick checks, script debugging, and initial integration tests. It is fine for low-volume requests and does not require an API key.
• Production dApp or backend service: Move to an authenticated endpoint. You get clearer rate limits, analytics, and operational visibility, which helps you plan capacity and avoid surprise throttling.
• High-throughput, archive, or custom node needs: Consider a dedicated Acala node. This gives you isolated resources, the ability to run archive nodes, and control over node configuration—important for collators, indexers, or applications that need consistent performance.

If you are unsure, start with the public endpoint, measure your request volume, and then upgrade to authenticated or dedicated infrastructure as your traffic grows. For a deeper comparison of RPC providers, see our guide on choosing an RPC provider.

Acala at a Glance: Substrate and EVM+ in One Network

Acala is a Polkadot parachain built for DeFi. It provides a full Substrate runtime with pallets for stablecoins, liquid staking, and DEX functionality. On top of that, Acala offers an EVM+ environment, which is compatible with Ethereum tooling while still allowing access to Substrate-specific features.

This dual nature means that when you search for "Acala RPC", you are likely looking for one of two things:

1. Substrate RPC endpoints for querying chain state, submitting transactions, or interacting with Acala's custom pallets.
2. EVM RPC endpoints for deploying and interacting with Solidity smart contracts using tools like MetaMask, ethers.js, or viem.

Both are important, and the endpoint you choose depends on the type of application you are building.

Acala Chain Settings at a Glance

If you are connecting a wallet or an EVM-based tool, you need the correct chain configuration. Here are the key settings for Acala Mainnet:

These settings are commonly listed on chain registries like ChainList. Always verify the chain ID and RPC URL with the official Acala documentation before connecting your wallet.

Acala RPC Endpoint Options

Acala offers several public RPC endpoints, each with different characteristics. Here is a summary of what you will commonly find:

Note: Public endpoints are shared and can be rate-limited or experience downtime. For production applications, you should use an authenticated endpoint or a dedicated node.

Connecting to Acala EVM+ with MetaMask

If you are building a dApp that uses the EVM+ side of Acala, you can add Acala as a custom network in MetaMask. Here is a sample configuration:

{
  "chainId": "0x313",
  "chainName": "Acala",
  "nativeCurrency": {
    "name": "Acala",
    "symbol": "ACA",
    "decimals": 18
  },
  "rpcUrls": ["https://eth-rpc-acala.aca-api.network"],
  "blockExplorerUrls": ["https://blockscout.acala.network"]
}

You can also use the window.ethereum.request method to programmatically add the network:

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [{
    chainId: '0x313',
    chainName: 'Acala',
    nativeCurrency: {
      name: 'Acala',
      symbol: 'ACA',
      decimals: 18
    },
    rpcUrls: ['https://eth-rpc-acala.aca-api.network'],
    blockExplorerUrls: ['https://blockscout.acala.network']
  }]
});

Using Acala RPC with ethers.js or viem

For EVM+ development, you can use standard Ethereum libraries. Here is an example using ethers.js:

import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://eth-rpc-acala.aca-api.network');

const blockNumber = await provider.getBlockNumber();
console.log('Acala block number:', blockNumber);

And with viem:

import { createPublicClient, http } from 'viem';

const client = createPublicClient({
  chain: {
    id: 787,
    name: 'Acala',
    network: 'acala',
    nativeCurrency: { name: 'Acala', symbol: 'ACA', decimals: 18 },
    rpcUrls: {
      default: { http: ['https://eth-rpc-acala.aca-api.network'] },
    },
  },
  transport: http(),
});

const blockNumber = await client.getBlockNumber();
console.log('Acala block number:', blockNumber);

Substrate RPC: Querying Chain State

For Substrate-specific operations, you can use the JSON-RPC interface directly. Here is a curl example to get the latest finalized head:

curl -H "Content-Type: application/json" \
  -d '{"id":1,"jsonrpc":"2.0","method":"chain_getFinalizedHead","params":[]}' \
  https://acala-polkadot.api.onfinality.io/public

You can also subscribe to new blocks using WebSocket:

const WebSocket = require('ws');
const ws = new WebSocket('wss://acala-polkadot.api.onfinality.io/public-ws');

ws.on('open', () => {
  ws.send(JSON.stringify({
    id: 1,
    jsonrpc: '2.0',
    method: 'chain_subscribeNewHeads',
    params: []
  }));
});

ws.on('message', (data) => {
  console.log('New head:', data.toString());
});

Acala RPC Methods and Limits

Acala RPC endpoints support standard Substrate and Ethereum JSON-RPC methods. Common methods include:

• chain_getBlock
• chain_getFinalizedHead
• state_getStorage
• eth_blockNumber
• eth_getBalance
• eth_call

Public endpoints often have rate limits to protect the infrastructure. If you need higher throughput or more consistent performance, consider an authenticated endpoint or a dedicated node. OnFinality's RPC pricing page provides details on plans and limits.

Troubleshooting Common Acala RPC Issues

Here are some common issues you might encounter when using Acala RPC:

• Connection timeouts: Public endpoints can be slow or overloaded. Try a different endpoint or use a WebSocket connection for real-time data.
• Rate limiting: If you receive HTTP 429 responses, you are hitting rate limits. Reduce request frequency or upgrade to an authenticated endpoint.
• Wrong chain ID: Ensure your wallet or dApp is configured with chain ID 787. Using the wrong chain ID can cause transaction failures.
• EVM vs Substrate confusion: If you are trying to call an EVM method on a Substrate endpoint, it will fail. Use the appropriate endpoint for your use case.

When to Consider a Dedicated Acala Node

A dedicated Acala node gives you full control over the node environment. This is useful for:

• High-traffic applications that need consistent performance and clear rate limits.
• Archive nodes that need to query historical state.
• Collators who need to run a node for block production.
• Custom node configurations that require specific flags or patches.

OnFinality offers dedicated Acala nodes with managed operations, monitoring, and isolated resources. You can also explore our supported networks to see other chains we support.

Key Takeaways

• Acala is a Polkadot parachain with both Substrate and EVM+ interfaces.
• Use the public RPC endpoint for testing, but switch to authenticated or dedicated infrastructure for production.
• Configure your wallet with the correct chain ID (787) and RPC URL.
• Use standard Ethereum libraries like ethers.js or viem for EVM+ development.
• For Substrate-specific queries, use the JSON-RPC interface directly.
• Monitor your usage and plan for scaling to avoid rate limits and downtime.

Frequently Asked Questions

What is the Acala RPC endpoint?

Acala provides several public RPC endpoints, including https://acala-rpc.aca-api.network and https://acala-polkadot.api.onfinality.io/public. For production, use an authenticated endpoint or a dedicated node.

What is the Acala chain ID?

The Acala chain ID is 787 (0x313).

Can I use MetaMask with Acala?

Yes, you can add Acala as a custom network in MetaMask using the chain ID 787 and the EVM RPC URL.

What is the difference between Substrate and EVM RPC on Acala?

Substrate RPC is used for chain state and transactions, while EVM RPC is used for smart contract interactions. Use the appropriate endpoint for your use case.

How do I get a dedicated Acala node?

You can get a dedicated Acala node through OnFinality's dedicated node service.