Monad RPC Documentation

Complete guide to Monad L1 integration with Dwellir RPC. Learn how to build on Monad, access JSON-RPC methods, and leverage ultra-high throughput for your dApp.

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:

Monad RPC Endpoints

HTTPS

curl -sS -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}'

import { JsonRpcProvider } from 'ethers';const provider = new JsonRpcProvider(  'https://api-monad-mainnet-full.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>');const latest = await provider.getBlockNumber();console.log('block', latest);

import requestsurl = 'https://api-monad-mainnet-full.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>'payload = {  'jsonrpc': '2.0', 'id': 1,  'method': 'eth_blockNumber', 'params': []}resp = requests.post(url, json=payload)print(resp.json())

package mainimport (  "bytes"  "fmt"  "io"  "net/http")func main() {  url := "https://api-monad-mainnet-full.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>"  payload := []byte(`{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`)  resp, err := http.Post(url, "application/json",    bytes.NewBuffer(payload))  if err != nil { panic(err) }  defer resp.Body.Close()  body, _ := io.ReadAll(resp.Body)  fmt.Println(string(body))}

Installation & Setup

Network Information

Parameter	Value	Details
Chain ID	143	Mainnet
Block Time	1 second	Average
Gas Token	MON	Native token
RPC Standard	Ethereum	JSON-RPC 2.0

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

JavaScript

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

JavaScript

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

JavaScript

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:

JavaScript

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

JavaScript

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:

JavaScript

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

JavaScript

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

Troubleshooting Common Issues

Error: "Insufficient funds"

Ensure your account has enough MON for gas:

JavaScript

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

JavaScript

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

JavaScript

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:

JavaScript

// 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
// Note: Different chain ID (143)
// Note: Different native token (MON instead of ETH)
// Note: Local mempool design (no global mempool)

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

Monad - High-Performance EVM Layer 1 Documentation

Why Build on Monad?

Extreme Performance

EVM Compatible

Growing Ecosystem

Quick Start with Monad

Installation & Setup

Network Information

API Reference

Common Integration Patterns

Transaction Monitoring

Gas Optimization

Event Filtering

Performance Best Practices

1. Batch Requests

2. Connection Pooling

3. Smart Caching

Monad-Specific Features

Local Mempool Design

Transaction Pool Management

Troubleshooting Common Issues

Error: "Insufficient funds"

Error: "Transaction underpriced"

Error: "Rate limit exceeded"

Migration Guide

From Ethereum Mainnet

Resources & Tools

Official Resources

Developer Tools

Need Help?

On this page