Monad - Build Without Limits on High-Performance EVM

Monad RPC
With Dwellir, you get access to our global Monad 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 Monad?

Monad is a high-performance EVM Layer 1 blockchain designed to deliver exceptional throughput without sacrificing decentralization. Built from the ground up for speed and scalability:

🚀 Extreme Performance

• 10,000+ TPS - Handle massive transaction volumes with ease
• 1-second block times - Near-instant finality for your users
• Parallel execution - Advanced transaction processing architecture

🛡️ EVM Compatible

• Full Ethereum compatibility - Deploy existing contracts without changes
• Proven tooling - Works with MetaMask, Hardhat, Foundry, and more
• Familiar development - Same APIs and libraries you already know

🌍 Growing Ecosystem

• Active community - Rapidly expanding developer base
• Testnet live - Build and test today on the Monad testnet
• Mainnet launched - Production-ready network live since November 2025

Quick Start with Monad

Connect to Monad in seconds with Dwellir's optimized endpoints:

🔗 RPC Endpoints

Monad MainnetChain ID: 143

Mainnet

HTTPS

https://api-monad-mainnet-full.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>

✓ Trace API✓ Debug API✓ WebSocket

Quick Connect:

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

Installation & Setup

Ethers.js v6

import { JsonRpcProvider } from 'ethers';

// Connect to Monad mainnet
const provider = new JsonRpcProvider(
  'https://api-monad-mainnet-full.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());

Web3.js

const Web3 = require('web3');

// Connect to Monad mainnet
const web3 = new Web3(
  'https://api-monad-mainnet-full.n.dwellir.com/YOUR_API_KEY'
);

// Get chain ID to verify connection
const chainId = await web3.eth.getChainId();
console.log('Connected to Monad:', chainId === 143);

// Get gas price for optimal transaction pricing
const gasPrice = await web3.eth.getGasPrice();
console.log('Current gas price:', gasPrice);

Viem

import { createPublicClient, http } from 'viem';
import { defineChain } from 'viem';

// Define Monad chain
const monad = defineChain({
  id: 143,
  name: 'Monad',
  network: 'monad',
  nativeCurrency: {
    decimals: 18,
    name: 'MON',
    symbol: 'MON',
  },
  rpcUrls: {
    default: {
      http: ['https://api-monad-mainnet-full.n.dwellir.com/YOUR_API_KEY'],
    },
    public: {
      http: ['https://api-monad-mainnet-full.n.dwellir.com/YOUR_API_KEY'],
    },
  },
});

// Create Monad client
const client = createPublicClient({
  chain: monad,
  transport: http(),
});

// Read contract data
const data = await client.readContract({
  address: '0x...',
  abi: contractAbi,
  functionName: 'balanceOf',
  args: ['0x...'],
});

Network Information

Chain ID

143

Mainnet

Block Time

1 second

Average

Gas Token

MON

Native token

RPC Standard

Ethereum

JSON-RPC 2.0

JSON-RPC API Reference

Monad supports the full Ethereum JSON-RPC API specification, plus additional methods for debugging, tracing, and transaction pool management.

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);

  console.log('Transaction confirmed in block:', receipt.blockNumber);
  console.log('Gas used:', receipt.gasUsed.toString());

  return receipt;
}

// Monitor transaction status
const tx = await wallet.sendTransaction({
  to: recipient,
  value: amount,
});

console.log('Transaction sent:', tx.hash);
const receipt = await waitForTransaction(tx.hash);

💰 Gas Optimization

Optimize gas costs on Monad:

// Estimate gas for a transaction
const gasEstimate = await provider.estimateGas({
  to: recipient,
  value: amount,
  data: '0x...',
});

console.log('Estimated gas:', gasEstimate.toString());

// Get current gas price
const gasPrice = await provider.getGasPrice();
console.log('Current gas price:', gasPrice.toString());

// Use EIP-1559 pricing
const feeData = await provider.getFeeData();
const tx = {
  to: recipient,
  value: amount,
  maxFeePerGas: feeData.maxFeePerGas,
  maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
};

🔍 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 currentBlock = await provider.getBlockNumber();
  const events = [];
  const batchSize = 5000; // Monad's high throughput supports larger batches

  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'] }
];

// Send batch request
const results = await Promise.all(
  batch.map(req => provider.send(req.method, req.params))
);

2. Connection Pooling

Reuse provider instances to minimize connection overhead:

// Singleton pattern for provider
class MonadProvider {
  static instance = null;

  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-monad-mainnet-full.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);
}

Monad-Specific Features

Local Mempool Design

Monad does not have a global mempool. Each RPC node maintains its own local mempool, which affects transaction visibility:

// Query transaction pool status by address
const statusByAddress = await provider.send('txpool_statusByAddress', [address]);
console.log('Pending transactions:', statusByAddress);

// Query transaction pool status by hash
const statusByHash = await provider.send('txpool_statusByHash', [txHash]);
console.log('Transaction status:', statusByHash);

Transaction Pool Management

Use these Monad-specific methods for mempool operations:

// Get pending transaction count for an address
const pendingCount = await provider.getTransactionCount(address, 'pending');

// Check transaction pool statistics (admin endpoint)
const txPoolStats = await provider.send('admin_ethCallStatistics', []);
console.log('TxPool stats:', txPoolStats);

Troubleshooting Common Issues

Error: "Insufficient funds"

Ensure your account has enough MON for gas:

// Check balance before sending transaction
const balance = await provider.getBalance(address);
const gasEstimate = await provider.estimateGas(tx);
const gasPrice = await provider.getGasPrice();
const totalRequired = gasEstimate * gasPrice + tx.value;

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

Error: "Transaction underpriced"

Monad 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 Monad requires minimal changes:

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

// After (Monad)
const provider = new JsonRpcProvider(
  'https://api-monad-mainnet-full.n.dwellir.com/YOUR_API_KEY'
);

// ✅ Smart contracts work identically
// ✅ Same tooling and libraries
// ✅ Higher throughput and faster finality
// ⚠️ Different chain ID (143)
// ⚠️ Different native token (MON instead of ETH)
// ⚠️ Local mempool design (no global mempool)

Resources & Tools

Official Resources

• Monad Documentation
• Monad Explorer
• Monad Testnet Explorer

Developer Tools

• Hardhat Setup
• Foundry Integration
• Add Monad to MetaMask

Need Help?

• 📧 Email: support@dwellir.com
• 📚 Docs: You're here!
• 🎯 Dashboard: dashboard.dwellir.com

---

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