⚠️Blast API (blastapi.io) ends Oct 31. Migrate to Dwellir and skip Alchemy's expensive compute units.
Switch Today →
Skip to main content

Avalanche - High-Performance Blockchain Platform

Avalanche RPC
With Dwellir, you get access to our global Avalanche network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Get your API key →

Why Build on Avalanche?​

Avalanche is a high-performance blockchain platform that delivers sub-second finality and supports custom blockchain networks. Built on the innovative Avalanche consensus mechanism, it offers:

⚡ Lightning Fast Performance​

  • Sub-second finality - Transactions confirm in under 1 second
  • 4,500+ TPS - Industry-leading throughput capacity
  • Low fees - Cost-effective transactions with predictable pricing

🏗️ Unique Three-Chain Architecture​

  • X-Chain - Exchange Chain for asset creation and trading
  • P-Chain - Platform Chain for validator coordination and subnets
  • C-Chain - Contract Chain for Ethereum-compatible smart contracts

🛡️ Enterprise Security​

  • Avalanche Consensus - Novel consensus protocol with strong safety guarantees
  • Validator Network - Decentralized network of validators securing the platform
  • Battle-tested - Processing millions of transactions since mainnet launch

🌍 Thriving Ecosystem​

  • 400+ projects - Growing DeFi, Gaming, and NFT ecosystem
  • EVM Compatible - Full Ethereum compatibility on C-Chain
  • Subnet Support - Create custom blockchain networks

Quick Start with Avalanche C-Chain​

Connect to Avalanche C-Chain in seconds with Dwellir's optimized endpoints:

🔗 RPC Endpoints

Avalanche Mainnet (Chain ID: 43114)Live
https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc
✓ Archive Node✓ Trace API✓ Debug API✓ WebSocket

Quick Connect:

curl -X POST https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Installation & Setup​

import { JsonRpcProvider } from 'ethers';

// Connect to Avalanche C-Chain mainnet
const provider = new JsonRpcProvider(
  'https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc'
);

// Get the latest block
const block = await provider.getBlock('latest');
console.log('Latest block:', block.number);

// Query account balance
const balance = await provider.getBalance('0x...');
console.log('Balance:', balance.toString());

Network Information​

Chain ID

43114

Mainnet

Block Time

2 seconds

Average

Gas Token

AVAX

Native token

RPC Standard

Ethereum

JSON-RPC 2.0

JSON-RPC API Reference​

Avalanche C-Chain supports the full Ethereum JSON-RPC API specification with sub-second finality and high throughput.

Available JSON-RPC Methods

📊 Reading Blockchain Data

Query blocks, transactions, and account states

+

📤 Sending Transactions

Submit and manage transactions

+

📝 Smart Contract Interaction

Call and interact with smart contracts

+

🔧 Node & Network Info

Query node status and network information

+

Ready to integrate Base into your dApp?

Get your API key →

Common Integration Patterns​

🔄 Transaction Monitoring​

Monitor pending and confirmed transactions efficiently:

// Watch for transaction confirmation
async function waitForTransaction(txHash) {
  const receipt = await provider.waitForTransaction(txHash, 1);
  
  // Avalanche specific: Fast finality means quick confirmations
  console.log('Transaction confirmed in block:', receipt.blockNumber);
  
  return receipt;
}

⚡ Fast Finality Optimization​

Leverage Avalanche's sub-second finality:

// Avalanche transactions finalize quickly
async function fastConfirmation(txHash) {
  const receipt = await provider.waitForTransaction(txHash, 1);
  
  // On Avalanche, 1 confirmation is typically sufficient
  if (receipt.blockNumber) {
    console.log('Transaction finalized with 1 confirmation');
    return receipt;
  }
}

🔍 Event Filtering​

Efficiently query contract events:

// Query events with optimal batch size for Avalanche
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 5000; // Avalanche recommended batch size
  
  for (let i = fromBlock; i <= currentBlock; i += batchSize) {
    const batch = await contract.queryFilter(
      filter, 
      i, 
      Math.min(i + batchSize - 1, currentBlock)
    );
    events.push(...batch);
  }
  
  return events;
}

Performance Best Practices​

1. Batch Requests​

Combine multiple RPC calls for optimal performance:

const batch = [
  { method: 'eth_blockNumber', params: [] },
  { method: 'eth_gasPrice', params: [] },
  { method: 'eth_getBalance', params: [address, 'latest'] }
];

const results = await provider.send(batch);

2. Connection Pooling​

Reuse provider instances to minimize connection overhead:

// Singleton pattern for provider
class AvalancheProvider {
  static instance = null;
  
  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc'
      );
    }
    return this.instance;
  }
}

3. Smart Caching​

Cache immutable data to reduce API calls:

const cache = new Map();

async function getCachedBlockData(blockNumber) {
  const key = `block_${blockNumber}`;
  
  if (!cache.has(key)) {
    const block = await provider.getBlock(blockNumber);
    cache.set(key, block);
  }
  
  return cache.get(key);
}

Troubleshooting Common Issues​

Error: "Gas required exceeds allowance"​

Avalanche uses dynamic gas pricing. Always estimate gas properly:

// Get current fee data
const feeData = await provider.getFeeData();

const tx = {
  to: recipient,
  value: amount,
  maxFeePerGas: feeData.maxFeePerGas,
  maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
  gasLimit: await provider.estimateGas({
    to: recipient,
    value: amount
  })
};

Error: "Transaction underpriced"​

Avalanche uses EIP-1559 pricing. Use dynamic gas pricing:

// Get current network conditions
const feeData = await provider.getFeeData();

const tx = {
  to: recipient,
  value: amount,
  maxFeePerGas: feeData.maxFeePerGas,
  maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
  gasLimit: 21000n
};

Error: "Rate limit exceeded"​

Implement exponential backoff for resilient applications:

async function callWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 429 && i < maxRetries - 1) {
        await new Promise(r => setTimeout(r, 2 ** i * 1000));
      } else {
        throw error;
      }
    }
  }
}

Migration Guide​

From Ethereum Mainnet​

Moving from L1 to Avalanche C-Chain is seamless:

// Before (Ethereum)
const provider = new JsonRpcProvider('https://eth-rpc.example.com');

// After (Avalanche)
const provider = new JsonRpcProvider(
  'https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc'
);

// ✅ Smart contracts work identically
// ✅ Same tooling and libraries
// ✅ Native token is AVAX instead of ETH
// ⚠️ Different chain ID (43114)
// ⚠️ Much faster finality (~1 second)

From Other EVM Chains​

Avalanche C-Chain is fully EVM compatible:

// Same contract deployment process
const contractFactory = new ContractFactory(abi, bytecode, signer);
const contract = await contractFactory.deploy(...constructorArgs);

// Wait for deployment (much faster on Avalanche)
await contract.waitForDeployment();

Resources & Tools​

Official Resources​

Developer Tools​

Ecosystem​

Need Help?​

Start building on Avalanche with Dwellir's enterprise-grade RPC infrastructure. Get your API key →