Monad (MON) tokens price API - How to fetch DEX data for Monad (MON) blockchain

24 Nov 2025 (11 days ago)

13 min read

Learn how to fetch real-time Monad (MON) token prices, liquidity pools, and DEX data using the free DexPaprika API. Complete JavaScript and Python tutorial with practical examples.

Monad (MON) tokens price API - How to fetch DEX data for Monad (MON) blockchain

Introduction

Monad is a high-performance, EVM-compatible Layer 1 blockchain that brings unprecedented scalability to decentralized finance. With its mainnet now live, Monad is processing transactions at remarkable speeds - achieving 10,000 transactions per second while maintaining full compatibility with Ethereum's development ecosystem.

For developers, traders, and analytics platforms building on Monad, access to real-time token pricing and liquidity pool data is essential. The DexPaprika API provides a powerful, free, and keyless interface to fetch comprehensive DEX data for Monad tokens, including live prices, liquidity metrics, transaction data, and historical OHLCV candles.

This guide will walk you through everything you need to know about fetching Monad (MON) token data using the DexPaprika API - from basic price queries to advanced liquidity pool tracking.

Getting started: DexPaprika API fundamentals

What is DexPaprika?

DexPaprika is a decentralized exchange data API developed by CoinPaprika, providing free, public access to token and DEX data across multiple blockchain networks. No API key is required - you can start making requests immediately.

Base URL:
https://api.dexpaprika.com

Key features

✅ Free & Keyless - No authentication required
✅ Public API - Simple GET requests
✅ Multi-Chain Support - Works across 30+ blockchains including Monad
✅ Real-Time Data - Live prices, volumes, and transaction data
✅ Liquidity Tracking - Pool-level data with buy/sell metrics
✅ Historical Data - OHLCV candles for technical analysis

Finding available networks

Before querying Monad data, you can discover all supported networks:

Endpoint:
GET /networks

This endpoint returns a list of all available blockchains supported by DexPaprika, including Monad (monad network ID).

Endpoint examples: fetching Monad MON data

1. Get MON token price & summary metrics

Retrieve the current price, market data, and volume metrics for the MON token on Monad.

Endpoint:
GET /networks/{network}/tokens/{token_address}

Parameters:

network = monad
token_address = 0x3bd359c1119da7da1d913d1c4d2b7c461115433a

JavaScript example

const fetch = require('node-fetch');

async function getMonadTokenPrice() {
  const url = 'https://api.dexpaprika.com/networks/monad/tokens/0x3bd359c1119da7da1d913d1c4d2b7c461115433a';

  try {
    const response = await fetch(url);
    const data = await response.json();

    console.log('MON Token Price:', data.summary.price_usd);
    console.log('24h Volume (USD):', data.summary['24h'].volume_usd);
    console.log('24h Transactions:', data.summary['24h'].txns);
    console.log('Total Liquidity (USD):', data.summary.liquidity_usd);
  } catch (error) {
    console.error('Error:', error);
  }
}

getMonadTokenPrice();

Python example

import requests

def get_monad_token_price():
    url = 'https://api.dexpaprika.com/networks/monad/tokens/0x3bd359c1119da7da1d913d1c4d2b7c461115433a'

    try:
        response = requests.get(url)
        data = response.json()

        print(f"MON Token Price: ${data['summary']['price_usd']}")
        print(f"24h Volume (USD): ${data['summary']['24h']['volume_usd']}")
        print(f"24h Transactions: {data['summary']['24h']['txns']}")
        print(f"Total Liquidity (USD): ${data['summary']['liquidity_usd']}")
    except Exception as error:
        print(f"Error: {error}")

get_monad_token_price()

Sample response

{
  "id": "0x3bd359c1119da7da1d913d1c4d2b7c461115433a",
  "name": "Wrapped MON",
  "symbol": "WMON",
  "chain": "monad",
  "summary": {
    "price_usd": 0.0263393446944259,
    "liquidity_usd": 68664.7488462056,
    "pools": 55,
    "24h": {
      "volume_usd": 12012285.351939747,
      "buys": 21689,
      "sells": 24168,
      "txns": 45857
    }
  }
}

2. Fetch MON liquidity pools & DEX data

Discover all liquidity pools containing MON tokens across different DEXes on Monad (PancakeSwap, Uniswap, etc.).

Endpoint:
GET /networks/{network}/tokens/{token_address}

Parameters:

network = monad
token_address = 0x3bd359c1119da7da1d913d1c4d2b7c461115433a
limit = 10 (number of pools to return)
sort = desc (descending order)
order_by = volume_usd (sort by volume)

JavaScript example

async function getMonadPools() {
  const url = new URL('https://api.dexpaprika.com/networks/monad/tokens/0x3bd359c1119da7da1d913d1c4d2b7c461115433a/pools');
  url.searchParams.append('limit', '10');
  url.searchParams.append('sort', 'desc');
  url.searchParams.append('order_by', 'volume_usd');

  try {
    const response = await fetch(url);
    const data = await response.json();

    data.pools.forEach(pool => {
      console.log(`DEX: ${pool.dex_name}`);
      console.log(`Pool Address: ${pool.id}`);
      console.log(`24h Volume (USD): $${pool.volume_usd}`);
      console.log(`Transactions: ${pool.transactions}`);
      console.log(`Current Price: $${pool.price_usd}`);
      console.log('---');
    });
  } catch (error) {
    console.error('Error:', error);
  }
}

getMonadPools();

Python example

import requests

def get_monad_pools():
    url = 'https://api.dexpaprika.com/networks/monad/tokens/0x3bd359c1119da7da1d913d1c4d2b7c461115433a/pools'
    params = {
        'limit': 10,
        'sort': 'desc',
        'order_by': 'volume_usd'
    }

    try:
        response = requests.get(url, params=params)
        data = response.json()

        for pool in data['pools']:
            print(f"DEX: {pool['dex_name']}")
            print(f"Pool Address: {pool['id']}")
            print(f"24h Volume (USD): ${pool['volume_usd']}")
            print(f"Transactions: {pool['transactions']}")
            print(f"Current Price: ${pool['price_usd']}")
            print('---')
    except Exception as error:
        print(f"Error: {error}")

get_monad_pools()

Currently supported DEXes on Monad

PancakeSwap V2
PancakeSwap V3
Uniswap V2
Uniswap V3
Additional DEXes (queryable via API)

3. Track pool-level transactions in real-time

Monitor individual transactions within a specific MON liquidity pool to track buy/sell activity and liquidity changes.

Endpoint:
GET /networks/{network}/pools/{pool_address}/transactions

Parameters:

network = monad
pool_address = 0xb9897986847472cd08b9a0e7bcd31ea4f1322361 (example MON/USDC pool)
limit = 10 (transactions per page)
page = 1

JavaScript example

async function getPoolTransactions(poolAddress) {
  const url = new URL(`https://api.dexpaprika.com/networks/monad/pools/${poolAddress}/transactions`);
  url.searchParams.append('limit', '10');
  url.searchParams.append('page', '1');

  try {
    const response = await fetch(url);
    const data = await response.json();

    data.transactions.forEach(tx => {
      console.log(`Transaction ID: ${tx.id}`);
      console.log(`From: ${tx.sender}`);
      console.log(`Token 0 Amount: ${tx.amount_0} ${tx.token_0_symbol}`);
      console.log(`Token 1 Amount: ${tx.amount_1} ${tx.token_1_symbol}`);
      console.log(`Price (Token 0): $${tx.price_0_usd}`);
      console.log(`Timestamp: ${tx.created_at}`);
      console.log('---');
    });

    console.log(`Total Transactions: ${data.page_info.total_items}`);
  } catch (error) {
    console.error('Error:', error);
  }
}

getPoolTransactions('0xb9897986847472cd08b9a0e7bcd31ea4f1322361');

Python example

import requests

def get_pool_transactions(pool_address):
    url = f'https://api.dexpaprika.com/networks/monad/pools/{pool_address}/transactions'
    params = {
        'limit': 10,
        'page': 1
    }

    try:
        response = requests.get(url, params=params)
        data = response.json()

        for tx in data['transactions']:
            print(f"Transaction ID: {tx['id']}")
            print(f"From: {tx['sender']}")
            print(f"Token 0 Amount: {tx['amount_0']} {tx['token_0_symbol']}")
            print(f"Token 1 Amount: {tx['amount_1']} {tx['token_1_symbol']}")
            print(f"Price (Token 0): ${tx['price_0_usd']}")
            print(f"Timestamp: {tx['created_at']}")
            print('---')

        print(f"Total Transactions: {data['page_info']['total_items']}")
    except Exception as error:
        print(f"Error: {error}")

get_pool_transactions('0xb9897986847472cd08b9a0e7bcd31ea4f1322361')

Key data points

amount_0 / amount_1 - Token amounts swapped
price_0_usd / price_1_usd - Real-time swap prices
sender / recipient - Transaction addresses
token_0_symbol / token_1_symbol - Asset symbols

4. Get OHLCV data for technical analysis (secondary)

Retrieve historical Open-High-Low-Close-Volume (OHLCV) candlestick data for MON pools - useful for charting and technical analysis.

Endpoint:
GET /networks/{network}/pools/{pool_address}/ohlcv

Parameters:

network = monad
pool_address = pool address
start = start date/timestamp (required)
interval = 1h, 4h, 1d, etc. (default: 24h)
limit = number of candles to return

JavaScript Example

async function getPoolOHLCV(poolAddress, startDate) {
  const url = new URL(`https://api.dexpaprika.com/networks/monad/pools/${poolAddress}/ohlcv`);
  url.searchParams.append('start', startDate);
  url.searchParams.append('interval', '1h');
  url.searchParams.append('limit', '24');

  try {
    const response = await fetch(url);
    const data = await response.json();

    data.forEach(candle => {
      console.log(`Time: ${candle.time_open}`);
      console.log(`Open: $${candle.open}`);
      console.log(`High: $${candle.high}`);
      console.log(`Low: $${candle.low}`);
      console.log(`Close: $${candle.close}`);
      console.log(`Volume: ${candle.volume}`);
      console.log('---');
    });
  } catch (error) {
    console.error('Error:', error);
  }
}

// Example: Get last 24 hours of hourly candles
const yesterday = new Date();
yesterday.setDate(yesterday.getDate() - 1);
getPoolOHLCV('0xb9897986847472cd08b9a0e7bcd31ea4f1322361', yesterday.toISOString().split('T')[0]);

Python Example

import requests
from datetime import datetime, timedelta

def get_pool_ohlcv(pool_address, start_date):
    url = f'https://api.dexpaprika.com/networks/monad/pools/{pool_address}/ohlcv'
    params = {
        'start': start_date,
        'interval': '1h',
        'limit': 24
    }

    try:
        response = requests.get(url, params=params)
        data = response.json()

        for candle in data:
            print(f"Time: {candle['time_open']}")
            print(f"Open: ${candle['open']}")
            print(f"High: ${candle['high']}")
            print(f"Low: ${candle['low']}")
            print(f"Close: ${candle['close']}")
            print(f"Volume: {candle['volume']}")
            print('---')
    except Exception as error:
        print(f"Error: {error}")

# Example: Get last 24 hours of hourly candles
yesterday = (datetime.now() - timedelta(days=1)).date()
get_pool_ohlcv('0xb9897986847472cd08b9a0e7bcd31ea4f1322361', str(yesterday))

What can you build with this data?

The DexPaprika Monad API opens up powerful possibilities for developers and traders:

Real-time price dashboards

Monitor MON token prices across multiple DEXes in real-time, displaying price discrepancies and arbitrage opportunities.

Liquidity analytics tools

Track liquidity pool metrics, identify high-volume pools, and analyze liquidity provider (LP) risks.

Transaction monitoring bots

Create bots that detect large buy/sell orders, whale movements, or unusual trading patterns on Monad.

DEX aggregators

Build smart order routing that finds the best prices across PancakeSwap, Uniswap, and other DEXes on Monad.

Technical analysis platforms

Generate trading signals using OHLCV data for charting applications or automated trading strategies.

On-chain analytics

Track token holder behavior, trading volume trends, and DEX performance metrics across Monad.

Practical use case: building a MON price alert system

Let's build a simple but practical application that monitors MON token price across Monad and sends alerts when the price crosses a threshold.

How it works:

Track MON/USDC price on major pools
Alert when price moves 5% in either direction
Log all price changes to a file

JavaScript implementation:

const fetch = require('node-fetch');
const fs = require('fs');

class MonadPriceMonitor {
  constructor(checkInterval = 60000) {
    this.checkInterval = checkInterval;
    this.lastPrice = null;
    this.priceThreshold = 0.05;
    this.logFile = 'monad_price_log.txt';
  }

  async checkPrice() {
    try {
      const url = 'https://api.dexpaprika.com/networks/monad/tokens/0x3bd359c1119da7da1d913d1c4d2b7c461115433a';
      const response = await fetch(url);
      const data = await response.json();

      const currentPrice = data.summary.price_usd;
      const timestamp = new Date().toISOString();
      const logEntry = `${timestamp} | Price: $${currentPrice} | 24h Volume: $${data.summary['24h'].volume_usd}\n`;
      fs.appendFileSync(this.logFile, logEntry);

      if (this.lastPrice === null) {
        this.lastPrice = currentPrice;
        console.log(`Initial price recorded: $${currentPrice}`);
        return;
      }

      const percentChange = (currentPrice - this.lastPrice) / this.lastPrice;

      if (Math.abs(percentChange) > this.priceThreshold) {
        const direction = percentChange > 0 ? 'UP' : 'DOWN';
        const alertMsg = `${direction} | Price changed ${(percentChange * 100).toFixed(2)}% | $${this.lastPrice} → $${currentPrice}`;
        console.log(alertMsg);
        fs.appendFileSync(this.logFile, `ALERT: ${alertMsg}\n`);
        this.lastPrice = currentPrice;
      }
    } catch (error) {
      console.error('Error checking price:', error);
    }
  }

  start() {
    console.log('MON Price Monitor started...');
    this.checkPrice();
    setInterval(() => this.checkPrice(), this.checkInterval);
  }
}

const monitor = new MonadPriceMonitor(60000);
monitor.start();

Python implementation:

import requests
import time
from datetime import datetime

class MonadPriceMonitor:
    def __init__(self, check_interval=60):
        self.check_interval = check_interval
        self.last_price = None
        self.price_threshold = 0.05
        self.log_file = 'monad_price_log.txt'
        self.token_url = 'https://api.dexpaprika.com/networks/monad/tokens/0x3bd359c1119da7da1d913d1c4d2b7c461115433a'

    def check_price(self):
        try:
            response = requests.get(self.token_url)
            data = response.json()

            current_price = data['summary']['price_usd']
            timestamp = datetime.now().isoformat()

            log_entry = f"{timestamp} | Price: ${current_price} | 24h Volume: ${data['summary']['24h']['volume_usd']}\n"
            with open(self.log_file, 'a') as f:
                f.write(log_entry)

            if self.last_price is None:
                self.last_price = current_price
                print(f"Initial price recorded: ${current_price}")
                return

            percent_change = (current_price - self.last_price) / self.last_price

            if abs(percent_change) > self.price_threshold:
                direction = 'UP' if percent_change > 0 else 'DOWN'
                alert_msg = f"{direction} | Price changed {percent_change*100:.2f}% | ${self.last_price} → ${current_price}"
                print(alert_msg)
                with open(self.log_file, 'a') as f:
                    f.write(f"ALERT: {alert_msg}\n")
                self.last_price = current_price

        except Exception as error:
            print(f"Error checking price: {error}")

    def start(self):
        print("MON Price Monitor started...")
        self.check_price()
        while True:
            time.sleep(self.check_interval)
            self.check_price()

if __name__ == '__main__':
    monitor = MonadPriceMonitor(check_interval=60)
    monitor.start()

Best practices & tips

1. Rate limiting

DexPaprika API is free and public, but practice good API citizenship:

Don't exceed 100 requests per minute per IP
Implement exponential backoff for retries
Cache responses when possible

2. Error handling

Always wrap API calls in try-catch blocks:

try {
  const response = await fetch(url);
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  const data = await response.json();
  // Process data
} catch (error) {
  console.error('API Error:', error);
}

3. Data freshness

Real-time data updates every 1-5 seconds. For price-sensitive applications, implement update queues or WebSocket connections (if available).

4. Network discovery

Always query /networks endpoint to discover all available blockchains and dynamically detect Monad:

async function findMonadNetwork() {
  const response = await fetch('https://api.dexpaprika.com/networks');
  const networks = await response.json();
  return networks.find(n => n.id === 'monad');
}

Conclusion

The DexPaprika API makes it incredibly simple to integrate Monad (MON) token data into your applications. Whether you're building price trackers, liquidity analytics, trading bots, or DEX aggregators, you now have access to comprehensive, real-time data - completely free and without authentication.

Key Takeaways

✅ No API key required - just make GET requests
✅ Real-time price, liquidity, and transaction data for MON
✅ Support for PancakeSwap V2/V3 and Uniswap V2/V3 (plus additional DEXes)
✅ Historical OHLCV data for technical analysis
✅ Production-ready for trading platforms and analytics tools

FAQ - DexPaprika API & Monad MON

General questions

Do I need an API key to use DexPaprika API?

No! DexPaprika API is completely free and requires no authentication. Simply make GET requests to the base URL https://api.dexpaprika.com.

Is DexPaprika API suitable for production applications?

Yes, the API is designed for production use. However, it's still in beta, so monitor the CoinPaprika status page for any planned maintenance.

What are the rate limits?

No strict rate limits are enforced, but we recommend staying under 100 requests per minute to ensure stability.

Can I use the API for real-time data?

Yes! Data updates frequently (1-5 seconds), making it suitable for real-time trading dashboards and monitoring tools.

Monad-specific questions

What is Monad (MON)?

Monad is a high-performance, EVM-compatible Layer 1 blockchain now live on mainnet. It achieves 10,000 TPS with 400ms block times while maintaining full Ethereum bytecode compatibility—allowing developers to deploy Ethereum applications without modifications.

Where can I find the MON token address on Monad?

The MON token contract address on Monad is 0x3bd359c1119da7da1d913d1c4d2b7c461115433a. Use this address when querying token-specific endpoints.

Which DEXes support MON trading on Monad?

Currently, PancakeSwap V2 & V3 and Uniswap V2 & V3 officially support MON. However, you can query all available pools and DEXes via the API to discover additional trading venues.

How do I find all pools for a specific token?

Use the endpoint
GET /networks/monad/tokens/{token_address}/pools. This returns all liquidity pools containing that token, sorted by volume, liquidity, or creation date.

API integration questions

What's the difference between token price and pool price?

Token price (from /tokens endpoint) is an aggregate price across all pools. Pool price (from /pools endpoint) is the specific price within that liquidity pool, which may vary slightly due to different token pairs and AMM mechanics.

How do I track liquidity changes in a pool?

Monitor the liquidity_usd field in pool data, or track transaction amounts over time. The /pools/{pool_address}/transactions endpoint shows all swaps and liquidity changes.

Can I get historical price data for backtesting?

Yes! Use the /pools/{pool_address}/ohlcv endpoint to fetch candlestick data at intervals of 1m, 5m, 10m, 15m, 30m, 1h, 6h, 12h, or 24h.

How do I implement price alerts?

Poll the token or pool endpoint at regular intervals, compare prices, and trigger alerts when thresholds are crossed. See the practical use case section for a complete example.

Troubleshooting

Why am I getting a 404 error for the Monad network?

Ensure you're using the network ID monad (lowercase) in your endpoint path. Network IDs can be discovered via GET /networks.

OHLCV endpoint returns empty results - why?

OHLCV data availability depends on pool age and historical data collection. Newer pools may have limited historical data. Ensure your timestamp format is valid (Unix timestamp, RFC3339, or YYYY-MM-DD).

Pool volume seems incorrect - which volume metric should I use?

Use volume_usd for USD-denominated volume across all time periods. The 24h field specifically contains the last 24 hours of activity. Check last_price_change_usd_24h for percentage changes.

How do I handle CORS issues when calling the API from a browser?

DexPaprika API supports CORS, but if you encounter issues, call the API from your backend server instead. Browser environments should use server-side proxies for production applications.

Start building today by making your first API call:

curl https://api.dexpaprika.com/networks/monad/tokens/0x3bd359c1119da7da1d913d1c4d2b7c461115433a

For more information and to explore other endpoints, visit the full DexPaprika API documentation.

Additional Resources

DexPaprika Main Site:https://dexpaprika.com
API Documentation:https://docs.dexpaprika.com
CoinPaprika Support: support@coinpaprika.com
Monad Ecosystem:https://monad.xyz
Developer Questions: msroka@coinpaprika.com

Latest articles

Go back to Education

Monad (MON) tokens price API - How to fetch DEX data for Monad (MON) blockchain

Learn how to fetch real-time Monad (MON) token prices, liquidity pools, and DEX data using the free DexPaprika API. Complete JavaScript and Python tutorial with practical examples.

Introduction

Getting started: DexPaprika API fundamentals

What is DexPaprika?

Key features

Finding available networks

Endpoint examples: fetching Monad MON data

1. Get MON token price & summary metrics

JavaScript example

Python example

Sample response

2. Fetch MON liquidity pools & DEX data

JavaScript example

Python example

Currently supported DEXes on Monad

3. Track pool-level transactions in real-time

JavaScript example

Python example

Key data points

4. Get OHLCV data for technical analysis (secondary)

JavaScript Example

Python Example

What can you build with this data?

Real-time price dashboards

Liquidity analytics tools

Transaction monitoring bots

DEX aggregators

Technical analysis platforms

On-chain analytics

Practical use case: building a MON price alert system

How it works:

JavaScript implementation:

Python implementation:

Best practices & tips

1. Rate limiting

2. Error handling

3. Data freshness

4. Network discovery

Conclusion

Key Takeaways

FAQ - DexPaprika API & Monad MON

General questions

Monad-specific questions

API integration questions

Troubleshooting

Additional Resources

Related articles

Latest articles

Coinpaprika education