تابعنا
© CoinPaprika 2026 آخر التحديثات : 2026-10-07 09:41:54 UTC

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

By Mateusz Sroka

نُشر (11 months ago)

14 دقيقة للقراءة

بروتوكولات وسلاسلEnglishمتقدم

مشاركة:

اجعلنا مصدرك المفضل على Google

Learn how to fetch Monad (MON) token prices, liquidity pools, and DEX data with the DexPaprika API, with no key needed to start. Complete JavaScript and Python examples included.

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 free interface, with no key needed to start, to fetch DEX data for Monad tokens: live prices, liquidity metrics and historical OHLCV candles, plus pool transactions on the Dev and Pro plans.

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, with a free tier and public access to token and DEX data across multiple blockchain networks. No API key is needed to start: you can make requests immediately. Pool transactions are the exception and need a Dev or Pro plan.

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

Key features

  • Free to start - no key needed for most endpoints
  • Public API - Simple GET requests
  • Multi-Chain Support - Works across 35 blockchains including Monad
  • Live data - prices and volumes, up to 60 seconds behind on the free tier and real-time on the paid plans
  • 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/pools/search');
  url.searchParams.append('token_address', '0x3bd359c1119da7da1d913d1c4d2b7c461115433a');
  url.searchParams.append('limit', '10');
  url.searchParams.append('sort', 'desc');
  url.searchParams.append('order_by', 'volume_usd_24h');

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

    data.results.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/pools/search'
    params = {
        'token_address': '0x3bd359c1119da7da1d913d1c4d2b7c461115433a',
        'limit': 10,
        'sort': 'desc',
        'order_by': 'volume_usd_24h'
    }

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

        for pool in data['results']:
            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
  • Uniswap V4
  • DyorSwap
  • Additional DEXes as they launch (queryable via API)

3. Track pool-level transactions

Monitor individual transactions within a specific MON liquidity pool to track buy/sell activity and liquidity changes. Since 30 September 2026 this endpoint needs a Dev or Pro plan: call it on api-pro.dexpaprika.com with your key on its own in the Authorization header.

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-pro.dexpaprika.com/networks/monad/pools/${poolAddress}/transactions`);
  url.searchParams.append('limit', '10');
  url.searchParams.append('page', '1');

  try {
    const response = await fetch(url, { headers: { Authorization: process.env.DEXPAPRIKA_API_KEY } });
    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 os
import requests

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

    try:
        response = requests.get(url, params=params, headers={'Authorization': os.environ['DEXPAPRIKA_API_KEY']})
        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 - USD prices at the time of the swap
  • 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 or relative time such as -24h (required; without a key it must fall within the last 24 hours)
  • interval = 1h, 6h, 24h, 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:

Live price dashboards

Monitor MON token prices across multiple DEXes, 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

The DexPaprika API has a free tier with public endpoints, but practice good API citizenship:

  • Stay within the per-minute limit of your tier; current numbers are on the pricing page
  • 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

On the free tier, data can be up to 60 seconds behind; real-time data is on the paid plans, listed on the pricing page. For price-sensitive applications, push updates through a queue, or use the SSE streams instead of polling.

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 market data, and the first call needs no key at all. A free API key raises the rate and the monthly allowance when you outgrow that; see the pricing page.

Key Takeaways

  • No API key needed to start - just make GET requests
  • Price and liquidity data for MON, plus pool transactions on Dev and Pro
  • Support for PancakeSwap V2/V3 and Uniswap V2/V3 (plus additional DEXes)
  • Historical OHLCV data for technical analysis
  • Built for dashboards, trading tools and analytics

FAQ - DexPaprika API & Monad MON

General questions

Do I need an API key to use DexPaprika API?

No key is needed to start. Make GET requests to https://api.dexpaprika.com and you get data straight away. A free API key raises the per-minute rate and the monthly allowance and still needs no card; current limits are on the DexPaprika pricing page.

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?

Keyless requests and free keys have per-minute and monthly limits, and paid plans raise both. Current numbers are on the pricing page.

Can I use the API for real-time data?

Yes, on the paid plans. On the free tier, data can be up to 60 seconds behind, which suits dashboards and monitoring; trading logic that needs real-time prices belongs on a paid plan. Details are on the pricing page.

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/pools/search?token_address={token_address}. It returns the liquidity pools containing that token under a results array, with cursor paging, and sorts 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. It needs a Dev or Pro plan.

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. Without a key you get hourly and longer intervals over the last 24 hours; a free key opens the finer intervals and more history.

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

مقالات ذات صلة

أحدث المقالات

تعليم Coinpaprika

اكتشف أدلة عملية وتعريفات ودراسات متعمقة لتنمية معرفتك بالعملات المشفرة.

تعتبر العملات المشفرة متقلبة للغاية وتنطوي على مخاطر كبيرة. قد تخسر جزءًا أو كل استثمارك.

جميع المعلومات على Coinpaprika مقدمة لأغراض معلوماتية فقط ولا تشكل نصيحة مالية أو استثمارية. قم دائمًا بإجراء بحثك الخاص (DYOR) واستشر مستشارًا ماليًا مؤهلاً قبل اتخاذ قرارات الاستثمار.

لا تتحمل Coinpaprika أي مسؤولية عن أي خسائر ناتجة عن استخدام هذه المعلومات.

العودة إلى التعليم