Skip to main content

Arbitrum - Leading Ethereum Layer 2 Scaling Solution

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

Try Free →

Why Build on Arbitrum?​

Arbitrum is the leading Ethereum Layer 2 scaling solution, processing more transactions than Ethereum mainnet itself. Built with Optimistic Rollup technology, Arbitrum offers:

🚀 Lightning Fast Performance​

  • Sub-second block times - Ultra-fast L2 transaction confirmations
  • 10-50x lower costs than Ethereum mainnet
  • 40,000 TPS capacity - Massive throughput for any scale

🛡️ Enterprise Security​

  • $15B+ secured - Largest L2 by Total Value Locked
  • Ethereum security - Full fraud proof protection
  • Battle-tested - Processing 1M+ transactions daily since 2021

🌍 Massive Ecosystem​

  • 3M+ unique addresses - Largest L2 user base
  • 600+ protocols - Complete DeFi, Gaming, and NFT ecosystem
  • Native integrations - GMX, Uniswap V3, Aave, Curve

Quick Start with Arbitrum​

Connect to Arbitrum One in seconds with Dwellir's optimized endpoints:

🔗 RPC Endpoints

Arbitrum One (Chain ID: 42161)Live
https://api-arbitrum-mainnet-archive.n.dwellir.com/YOUR_API_KEY
✓ Archive Node✓ Trace API✓ Debug API✓ WebSocket

Quick Connect:

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

Installation & Setup​

import { JsonRpcProvider } from 'ethers';

// Connect to Arbitrum One mainnet
const provider = new JsonRpcProvider(
  'https://api-arbitrum-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

// 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

42161

Mainnet

Block Time

2 seconds

Average

Gas Token

ETH

Native token

RPC Standard

Ethereum

JSON-RPC 2.0

JSON-RPC API Reference​

Arbitrum supports the full Ethereum JSON-RPC API specification. Access all standard methods plus L2-specific optimizations.

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

+

🎯 Arbitrum L2 Specific

Methods specific to Arbitrum Layer 2

+

Ready to integrate Arbitrum into your dApp?

Get Your Free 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);
  
  // L2 specific: Check L1 data availability
  if (receipt.l1Fee) {
    console.log('L1 data cost:', receipt.l1Fee);
  }
  
  return receipt;
}

💰 Gas Optimization​

Optimize gas costs on Arbitrum One:

// Estimate L2 execution gas
const l2Gas = await provider.estimateGas(tx);

// Get current L1 data fee (Arbitrum specific)
const l1DataFee = await provider.send('eth_estimateL1Fee', [tx]);

// Total cost = L2 execution + L1 data posting
const totalCost = l2Gas + BigInt(l1DataFee);

🔍 Event Filtering​

Efficiently query contract events:

// Query events with automatic retry and pagination
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 2000; // Arbitrum 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 ArbitrumProvider {
  static instance = null;
  
  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-arbitrum-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
      );
    }
    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: "Insufficient funds for L1 fee"​

Arbitrum transactions require ETH for both L2 execution and L1 data availability:

// Always account for L1 fees in balance checks
const balance = await provider.getBalance(address);
const l1Fee = await provider.send('eth_estimateL1Fee', [tx]);
const l2Gas = await provider.estimateGas(tx);
const totalRequired = l2Gas + BigInt(l1Fee) + tx.value;

if (balance < totalRequired) {
  throw new Error(`Need ${totalRequired - balance} more ETH`);
}

Error: "Transaction underpriced"​

Arbitrum uses EIP-1559 pricing. Always use dynamic gas pricing:

// Get current fee data
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 Arbitrum One requires minimal changes:

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

// After (Arbitrum)
const provider = new JsonRpcProvider(
  'https://api-arbitrum-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

// ✅ Smart contracts work identically
// ✅ Same tooling and libraries
// ⚠️ Different chain ID (42161)
// ⚠️ Separate block numbers
// ⚠️ L1 data fees apply

Resources & Tools​

Official Resources​

Developer Tools​

Need Help?​

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