How to get Monad RPC endpoint

Monad Mainnet and Testnet are now available on Chainstack! You can spin up Monad RPC endpoints in seconds and start building on one of the fastest EVM-compatible chains out there.

Monad processes 10,000 transactions per second through parallel execution while staying fully compatible with Ethereum tooling. That means you get the performance boost without rewriting your contracts or switching frameworks. Your Solidity code, your deployment scripts, your ethers.js setup, everything just works.

In this guide, we’ll show you exactly how to get a Monad RPC endpoint on Chainstack, connect it to your project, and start making calls. No fluff, just the practical steps you need.

What you get with Monad RPC on Chainstack

Before we jump into setup, here’s what you’re getting:

High throughput without the wait. Monad handles 10,000 TPS through parallel transaction execution. If your app needs to process heavy transaction volumes—DeFi protocols, gaming applications, NFT platforms—Monad gives you room to scale without hitting congestion.

Global infrastructure that actually performs. Chainstack routes your requests through the nearest data center. Whether your users are in New York, London, or Singapore, they get low-latency responses from nodes optimized for high traffic.

Standard Ethereum RPC. Every eth_ method you’re used to works here. eth_sendRawTransaction, eth_call, eth_getBalance, eth_getLogs—they all work exactly as expected. Use Hardhat, Foundry, Remix, or any Ethereum dev tool without modifications.

Create your Monad RPC endpoint

Log into your Chainstack account. If you don’t have one yet, sign up—it takes about 30 seconds.

Once you’re in:

1. Click Create project or select an existing project
2. Click Join network
3. Select Monad from the protocol list
4. Choose Mainnet or Testnet depending on where you’re building
5. Click Deploy node

Your endpoint will be ready in seconds!
Copy that URL. You’ll need it for everything else.

Connect to Monad in your code

Now let’s actually use that Monad endpoint. Here are the most common ways to connect:

Using curl (quick test)

bash

curl -X POST https://monad-mainnet.core.chainstack.com/auth-key \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_blockNumber",
    "params": []
  }'

Using ethers.js

javascript

import { ethers } from 'ethers';
const provider = new ethers.JsonRpcProvider(
  'https://monad-mainnet.core.chainstack.com/auth-key'
);
// Get latest block number
const blockNumber = await provider.getBlockNumber();
console.log('Latest block:', blockNumber);
// Get account balance
const balance = await provider.getBalance('0xYourAddress');
console.log('Balance:', ethers.formatEther(balance));

Using web3.js

javascript

import Web3 from 'web3';
const web3 = new Web3('https://monad-testnet.core.chainstack.com/auth-key');
const block = await web3.eth.getBlock('latest');
console.log('Latest block:', block.number);

Using Hardhat

Update your hardhat.config.js:

javascript

module.exports = {
  networks: {
    monad: {
      url: 'https://monad-mainnet.core.chainstack.com/auth-key',
      accounts: [process.env.PRIVATE_KEY]
    },
    monadTestnet: {
      url: 'https://monad-testnet.core.chainstack.com/auth-key',
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

Deploy with:

bash

npx hardhat run scripts/deploy.js --network monad

Using Foundry

Update your foundry.toml:

toml

[rpc_endpoints]
monad = "https://monad-mainnet.core.chainstack.com/auth-key"
monad_testnet = "https://monad-testnet.core.chainstack.com/auth-key"

Deploy with:

bash

forge create src/MyContract.sol:MyContract \
  --rpc-url monad \
  --auth-key $AUTH_KEY

What makes Monad different (and why it matters)

Monad executes transactions in parallel instead of one at a time. On a standard EVM chain, if you send 100 transactions, they process sequentially. On Monad, transactions that don’t conflict with each other run simultaneously across multiple threads.

This matters when you’re building apps that need high throughput: DEXs processing thousands of swaps, games with intensive onchain activity, NFT platforms handling heavy minting, or any application where transaction volume creates bottlenecks.

You also get single-slot finality and sub-second block times. That means faster confirmations and better UX for your users.

The best part? You don’t need to change anything about how you build. Monad is fully EVM bytecode compatible. Your existing Solidity contracts deploy without modification. Your testing suites work. Your monitoring tools work. Everything you’ve built on Ethereum or other EVM chains ports over directly.

Troubleshooting common issues

Rate limits: If you’re hitting rate limits, upgrade your Chainstack plan or add more endpoints to distribute load.

Connection timeouts: Check that you’re using the correct RPC URL and that your API key is included. Also verify your network configuration if you’re behind a firewall.

Transaction failures: Make sure you have enough native tokens for gas. Check that your nonce is correct and that you’re not sending transactions too quickly.

Contract deployment issues: Verify your compiler version matches what the network expects. Double-check that your constructor parameters are correct.

Next steps

You’re now connected to Monad through Chainstack. Your geo-balanced RPC endpoint is live and you can start building.

If you need higher throughput or dedicated resources, check out Chainstack’s enterprise plan. For support or questions about your infrastructure setup, reach out to the Chainstack team through the console.