Market Data API Reference

Market data packages provide real-time and historical pricing, analytics, and on-chain data.

Packages

Package	Description
@uniswap/mcp-coingecko	CoinGecko price feeds
@uniswap/mcp-dexscreener	DEXScreener analytics
@nirholas/market-data-analytics	Advanced analytics
@nirholas/market-data-sentiment	Social sentiment analysis
@nirholas/market-data-fear-greed	Fear & Greed index

---

CoinGecko Integration

Installation

pnpm add @uniswap/mcp-coingecko

Configuration

import { CoinGeckoClient } from '@uniswap/mcp-coingecko'

const coingecko = new CoinGeckoClient({
  apiKey: process.env.COINGECKO_API_KEY, // Optional for free tier
  rateLimit: 50, // Requests per minute
})

Price Functions

getPrice

Get current price for tokens.

async function getPrice(params: PriceParams): Promise<PriceData>

interface PriceParams {
  ids: string[]              // CoinGecko IDs: ['bitcoin', 'ethereum']
  vs_currencies: string[]    // ['usd', 'eur', 'btc']
  include_market_cap?: boolean
  include_24hr_vol?: boolean
  include_24hr_change?: boolean
  include_last_updated_at?: boolean
}

interface PriceData {
  [coinId: string]: {
    [currency: string]: number
    [currency_market_cap: string]: number
    [currency_24h_vol: string]: number
    [currency_24h_change: string]: number
    last_updated_at?: number
  }
}

Example:

const prices = await coingecko.getPrice({
  ids: ['bitcoin', 'ethereum', 'solana'],
  vs_currencies: ['usd'],
  include_24hr_change: true,
})

console.log(`BTC: $${prices.bitcoin.usd}`)
console.log(`ETH: $${prices.ethereum.usd} (${prices.ethereum.usd_24h_change}%)`)

getPriceByContract

Get price by contract address.

async function getPriceByContract(params: ContractPriceParams): Promise<PriceData>

interface ContractPriceParams {
  platform: 'ethereum' | 'binance-smart-chain' | 'polygon-pos' | 'arbitrum-one' | 'base'
  contract_addresses: string[]
  vs_currencies: string[]
}

getHistoricalPrice

Get historical price at a specific date.

async function getHistoricalPrice(
  id: string,
  date: string  // DD-MM-YYYY format
): Promise<HistoricalData>

---

Market Data

getCoinMarkets

Get market data for multiple coins.

async function getCoinMarkets(params: MarketsParams): Promise<CoinMarket[]>

interface MarketsParams {
  vs_currency: string
  order?: 'market_cap_desc' | 'volume_desc' | 'gecko_desc'
  per_page?: number
  page?: number
  sparkline?: boolean
  price_change_percentage?: '1h' | '24h' | '7d' | '14d' | '30d'
  category?: string
}

interface CoinMarket {
  id: string
  symbol: string
  name: string
  image: string
  current_price: number
  market_cap: number
  market_cap_rank: number
  fully_diluted_valuation: number
  total_volume: number
  high_24h: number
  low_24h: number
  price_change_24h: number
  price_change_percentage_24h: number
  circulating_supply: number
  total_supply: number
  max_supply: number | null
  ath: number
  ath_change_percentage: number
  ath_date: string
  atl: number
  atl_change_percentage: number
  atl_date: string
  last_updated: string
  sparkline_in_7d?: { price: number[] }
}

getTrending

Get trending coins.

async function getTrending(): Promise<TrendingCoins>

interface TrendingCoins {
  coins: Array<{
    item: {
      id: string
      coin_id: number
      name: string
      symbol: string
      market_cap_rank: number
      thumb: string
      score: number
      price_btc: number
    }
  }>
  categories: Array<{
    id: number
    name: string
    market_cap_1h_change: number
  }>
}

---

OHLC & Charts

getOHLC

Get OHLC (candlestick) data.

async function getOHLC(params: OHLCParams): Promise<OHLC[]>

interface OHLCParams {
  id: string
  vs_currency: string
  days: 1 | 7 | 14 | 30 | 90 | 180 | 365 | 'max'
}

// Returns [timestamp, open, high, low, close]
type OHLC = [number, number, number, number, number]

getMarketChart

Get price chart data.

async function getMarketChart(params: ChartParams): Promise<MarketChart>

interface ChartParams {
  id: string
  vs_currency: string
  days: number | 'max'
  interval?: 'daily' | 'hourly' | '5min'
}

interface MarketChart {
  prices: [number, number][]       // [timestamp, price]
  market_caps: [number, number][]  // [timestamp, market_cap]
  total_volumes: [number, number][]// [timestamp, volume]
}

---

DEXScreener Integration

Installation

pnpm add @uniswap/mcp-dexscreener

Configuration

import { DexScreenerClient } from '@uniswap/mcp-dexscreener'

const dexscreener = new DexScreenerClient({
  rateLimit: 300, // Requests per minute
})

Token Lookup

getTokenByAddress

Get token information by contract address.

async function getTokenByAddress(
  chain: string,
  address: string
): Promise<TokenProfile>

interface TokenProfile {
  url: string
  chainId: string
  tokenAddress: string
  icon?: string
  header?: string
  description?: string
  links?: {
    type: string
    label: string
    url: string
  }[]
}

searchTokens

Search for tokens.

async function searchTokens(query: string): Promise<SearchResult>

interface SearchResult {
  pairs: DexPair[]
}

---

Pair Data

getPairsByToken

Get trading pairs for a token.

async function getPairsByToken(
  chain: string,
  address: string
): Promise<DexPair[]>

interface DexPair {
  chainId: string
  dexId: string
  url: string
  pairAddress: string
  baseToken: {
    address: string
    name: string
    symbol: string
  }
  quoteToken: {
    address: string
    name: string
    symbol: string
  }
  priceNative: string
  priceUsd: string
  txns: {
    m5: { buys: number; sells: number }
    h1: { buys: number; sells: number }
    h6: { buys: number; sells: number }
    h24: { buys: number; sells: number }
  }
  volume: {
    m5: number
    h1: number
    h6: number
    h24: number
  }
  priceChange: {
    m5: number
    h1: number
    h6: number
    h24: number
  }
  liquidity: {
    usd: number
    base: number
    quote: number
  }
  fdv: number
  marketCap: number
  pairCreatedAt: number
  info?: {
    imageUrl?: string
    websites?: { url: string }[]
    socials?: { platform: string; handle: string }[]
  }
  boosts?: {
    active: number
  }
}

getLatestPairs

Get newly created trading pairs.

async function getLatestPairs(chain?: string): Promise<DexPair[]>

getTopPairs

Get top trading pairs by volume.

async function getTopPairs(chain: string): Promise<DexPair[]>

---

Analytics Package

Installation

pnpm add @nirholas/market-data-analytics

Technical Indicators

calculateRSI

Calculate Relative Strength Index.

function calculateRSI(prices: number[], period?: number): number

// Example
const rsi = calculateRSI(closingPrices, 14)
if (rsi > 70) console.log('Overbought')
if (rsi < 30) console.log('Oversold')

calculateMACD

Calculate MACD indicator.

function calculateMACD(params: MACDParams): MACDResult

interface MACDParams {
  prices: number[]
  fastPeriod?: number   // Default: 12
  slowPeriod?: number   // Default: 26
  signalPeriod?: number // Default: 9
}

interface MACDResult {
  macd: number
  signal: number
  histogram: number
}

calculateBollingerBands

Calculate Bollinger Bands.

function calculateBollingerBands(params: BBParams): BollingerBands

interface BBParams {
  prices: number[]
  period?: number        // Default: 20
  stdDevMultiplier?: number // Default: 2
}

interface BollingerBands {
  upper: number
  middle: number
  lower: number
  bandwidth: number
  percentB: number
}

calculateSMA / calculateEMA

Calculate moving averages.

function calculateSMA(prices: number[], period: number): number
function calculateEMA(prices: number[], period: number): number

const sma50 = calculateSMA(prices, 50)
const ema20 = calculateEMA(prices, 20)

---

Portfolio Analytics

calculateSharpeRatio

Calculate risk-adjusted returns.

function calculateSharpeRatio(params: SharpeParams): number

interface SharpeParams {
  returns: number[]
  riskFreeRate?: number // Default: 0.02 (2%)
  annualize?: boolean
}

calculateMaxDrawdown

Calculate maximum drawdown.

function calculateMaxDrawdown(prices: number[]): DrawdownResult

interface DrawdownResult {
  maxDrawdown: number      // Percentage
  drawdownStart: number    // Index
  drawdownEnd: number      // Index
  recoveryEnd: number      // Index or -1 if not recovered
}

calculateVolatility

Calculate price volatility.

function calculateVolatility(
  returns: number[],
  annualize?: boolean
): number

---

Sentiment Analysis

Installation

pnpm add @nirholas/market-data-sentiment

Social Sentiment

import { SentimentAnalyzer } from '@nirholas/market-data-sentiment'

const sentiment = new SentimentAnalyzer({
  twitterApiKey: process.env.TWITTER_API_KEY,
  redditClientId: process.env.REDDIT_CLIENT_ID,
  redditSecret: process.env.REDDIT_SECRET,
})

// Analyze sentiment for a token
const analysis = await sentiment.analyze('bitcoin')

interface SentimentResult {
  overall: number        // -1 to 1
  twitter: number
  reddit: number
  trending: boolean
  mentionCount: number
  sentiment24hChange: number
  topKeywords: string[]
}

---

Fear & Greed Index

Installation

pnpm add @nirholas/market-data-fear-greed

Usage

import { getFearGreedIndex } from '@nirholas/market-data-fear-greed'

const index = await getFearGreedIndex()

interface FearGreedIndex {
  value: number           // 0-100
  classification: 'Extreme Fear' | 'Fear' | 'Neutral' | 'Greed' | 'Extreme Greed'
  timestamp: number
  components: {
    volatility: number
    marketMomentum: number
    socialMedia: number
    surveys: number
    dominance: number
    trends: number
  }
}

// Historical data
const history = await getFearGreedHistory({ limit: 30 })

---

Error Types

class MarketDataError extends Error {
  code: string
}

class RateLimitError extends MarketDataError {
  retryAfter: number
}

class APIError extends MarketDataError {
  status: number
}

class TokenNotFoundError extends MarketDataError {
  address: string
  chain: string
}

class PairNotFoundError extends MarketDataError {}

class DataUnavailableError extends MarketDataError {}