Read contract state, follow market activity, and send transactions with reliable, high-performance Monad RPC infrastructure.
Connect to Monad mainnet or testnet through one geo-balanced endpoint. Use Ethereum-compatible APIs to read MON balances, call Solidity contracts, and submit signed transactions.
Scale Monad applications with predictable RPC capacity, historical transaction data, and native debug APIs.
Scale high-volume RPC workloads with consistent performance, unlimited requests within your RPS tier, and predictable monthly costs.
Backfill blocks, transactions, receipts, and logs. Historical balances and contract state are available only within the node’s rolling state window.
Inspect transaction execution with debug_traceTransaction and debug_traceBlockByNumber. Use callTracer or prestateTracer to investigate failures and internal calls.
Read liquidity-pool state, simulate contract calls, estimate fees, and submit signed transactions. Connect Solidity applications to Monad using ethers.js or viem.
Explore Monad APIs
Track proposed blocks and commit-state updates with monadNewHeads. Follow finalized activity and contract logs for application updates, and backfill gaps after reconnecting.
Explore block subscriptions
Read MON and token balances, estimate transaction costs, and track receipts. Connect wallet interfaces and payment backends with standard EVM tools.
Explore Monad tooling
Inspect transaction call trees and state changes with supported debug methods. Diagnose failed swaps and contract calls before shipping application changes.
Explore Monad debug APIs
Retrieve blocks, receipts, and event logs for dashboards and reconciliation. Build your own index of application state when you need history beyond the node’s rolling state window.
Get a Monad RPC endpointRun trading backends, DeFi applications, and indexers on isolated compute and storage. Deploy managed Monad mainnet or testnet nodes with infrastructure capacity tailored to your workload.
Select Monad mainnet or testnet to see currently available node modes and monthly infrastructure pricing.
Feedback from teams building wallets, security tools, analytics, and trading applications with Chainstack across supported networks.
Chainstack’s robust infrastructure has significantly enhanced our ability to secure Web3 environments effectively.Chainstack has been crucial in enhancing Brave Wallet’s multi-chain functionality and UX.The Unlimited Node flat-fee model gives us cost predictability, and the performance is rock-solidChainstack’s custom gateway and Global Nodes have made a stellar impact on our operational efficiencyWe’ve gone from weekly incidents to zero incidents.
Build DeFi and trading applications on geo-balanced Monad endpoints. Scale sustained RPC workloads with flat-fee Unlimited Node capacity, or choose Dedicated Nodes for isolated infrastructure.
Get a Monad endpointGet free testnet MON from the Chainstack Monad faucet. Deploy Solidity contracts, test wallet flows, and run application integrations before moving to mainnet.
Top up an eligible wallet to 0.5 testnet MON, with a claim available every 24 hours. Use Monad testnet chain ID 10143. Test tokens have no monetary value.
Get testnet MON (opens in a new tab)
Read a wallet’s MON balance with eth_getBalance, using familiar Ethereum-compatible JSON-RPC.
AI-ready infrastructure
Refer and earn
Ethereum
Hyperliquid
Solana
Arbitrum
BNB Smart Chain
Base
Polygon
TRON
Sui
Robinhood
SOC 2 Type II
ISO 27001
99.99%+ uptime
Learn more
https://monad-mainnet.core.chainstack.com/YOUR_ENDPOINT_IDwss://monad-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID143Create a Monad node and copy your endpoint from Access and credentials. Replace YOUR_ENDPOINT_ID with your endpoint ID. Both networks use MON for gas.
curl --request POST \
--url https://monad-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID \
--header 'Content-Type: application/json' \
--data '{
"jsonrpc": "2.0",
"id": 1,
"method": "eth_getBalance",
"params": [
"0x0000000000000000000000000000000000001000",
"latest"
]
}'The result is a hexadecimal balance in wei. One MON equals 10^18 wei. This read-only request does not spend MON.
Start with free Monad RPC for mainnet or testnet. Scale EVM applications with higher throughput, debug APIs, and dedicated infrastructure.
Includes:
All Developer features, plus:
Add-ons and Dedicated Node infrastructure are billed separately.
Exceptional support on every paid planSave over 50% on our elite Pay-as-you-go plan
Chat on Telegram (opens in a new tab)Explore Monad RPC setup, EVM development, trading integrations, and testnet tools.
Connect mainnet or testnet RPC to your application.
Read article
Explore practical patterns for EVM applications on Monad.
Read article
Follow a Monad trading integration built around Kuru DEX.
Read article
Fund your test wallet with the Chainstack faucet.
Read articleExplore open-source projects from our developer experience team. Follow practical guides, watch walkthroughs, and adapt the code for your application.
Python · Monad trading
Listen for Kuru DEX limit-order events on Monad and mirror order placement and cancellation. Explore direct interaction with Kuru markets and margin accounts.
Python · On-chain listeners
Trace FOMO’s on-chain trade flow with working Python listeners. Follow smart-wallet activity, settlement contracts, and swap events through RPC and WebSocket connections.
Monad RPC is the Ethereum-compatible JSON-RPC interface applications use to read Monad blockchain data, call smart contracts, and submit signed transactions. Monad is a Layer 1 blockchain that uses parallel execution while preserving EVM bytecode compatibility. See the Monad API reference.
Create a free Chainstack account, create a project, and deploy a Monad Global Node on mainnet or testnet. Open Access and credentials to copy your HTTPS and WebSocket URLs. The Developer plan includes 3 million request units per month, up to 25 requests per second, and one node. No credit card is required.
Your authenticated HTTPS URLs follow https://monad-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID and https://monad-testnet.core.chainstack.com/YOUR_ENDPOINT_ID. Use the complete endpoint from your node’s Access and credentials. Your endpoint ID authenticates requests, so keep it out of public repositories. Follow the Monad endpoint setup guide.
Monad mainnet uses chain ID 143 (0x8f), and Monad testnet uses 10143 (0x279f). Both networks use MON for gas, but testnet MON cannot pay mainnet fees. Query eth_chainId to verify your endpoint’s network before signing transactions. Check the Monad network information.
Yes. Monad supports EVM bytecode and standard Ethereum JSON-RPC methods, so you can use Solidity contracts and familiar tools such as MetaMask, ethers.js, viem, web3.py, Hardhat, and Foundry. Configure the correct RPC URL, chain ID, and MON gas balance. Check Monad-specific behavior when porting an application. See Monad tooling and differences from Ethereum.
Call eth_getBalance with a wallet address and the latest block tag. The result is a hexadecimal amount in wei, with 10^18 wei per MON. This reads the native balance; ERC-20 token balances require a contract call such as balanceOf. See the Monad eth_getBalance reference.
Yes. Chainstack Monad Global Nodes support standard block and log subscriptions, plus monadNewHeads for Monad-specific block lifecycle updates. That stream includes blockId and commitState; a proposed block is not yet finalized. Copy the WSS URL from Access and credentials and add reconnection and backfilling logic. See Monad block subscriptions.
No. Historical blocks, transactions, receipts, and logs are different from historical state. Chainstack Monad nodes retain account balances and contract state for a rolling window of recent blocks, several days long. Older state queries can return Block requested not found. Do not assume Ethereum-style state history back to genesis. See Monad state limitations and Monad’s historical-data explanation.
On paid plans, Monad Global Nodes expose debug_* methods such as debug_traceTransaction and debug_traceBlockByNumber. Monad does not serve the trace_* namespace. Supported native tracers include callTracer and prestateTracer; 4byteTracer and noopTracer are rejected. See Monad debug API availability.
Start with the free Developer plan. Paid plans start at $40 per month with annual billing. Standard full requests consume 1 request unit, while archive and debug or trace requests consume 2. Unlimited Node offers flat-fee capacity from the Growth plan; Dedicated Nodes start from Pro, with infrastructure billed separately. See plan features and request-unit rules.
Use a Global Node for geo-balanced RPC without managing node infrastructure. Choose a Dedicated Node when you need isolated compute and storage for sustained production workloads. Unlimited Node is an additional option for predictable billing within a selected RPS tier. Check current Monad node pricing for available networks and configurations.
Use the Chainstack Monad faucet to fund an eligible test wallet. The faucet currently tops balances up to 0.5 testnet MON, with a claim available every 24 hours. Testnet MON has no monetary value and cannot pay mainnet fees. Use chain ID 10143 for Monad testnet.
Connect to Chainstack’s Monad mainnet or testnet HTTPS endpoint using Ethereum-compatible JSON-RPC. Read MON balances with eth_getBalance, query contract state with eth_call, retrieve logs with eth_getLogs, and submit signed transactions with eth_sendRawTransaction. Use ethers.js, viem, or web3.py, and subscribe to new blocks or logs through your WSS endpoint. Mainnet uses chain ID 143; testnet uses 10143. See the Monad API reference and tooling guide.
Monad historical transaction data and historical state have different retention rules. Blocks, transactions, receipts, and logs can be queried historically, while account balances and contract state are limited to the node’s rolling state window. On paid Global Nodes, use debug_traceTransaction and debug_traceBlockByNumber for execution analysis. Monad does not implement the trace_* namespace or eth_getProof. Check state-history limitations and supported debug methods before designing backfills.
