trackmcp
Back to directory
crazyrabbitLTC

mcp-coingecko-server

View on GitHub

An Anthropic MCP server (with OpenAI Function calling compatibility) for the Coingecko Pro API

9 stars JavaScriptAI & Machine Learning Updated Jul 2, 2025

Documentation

Update: CoinGecko now has an official MCP server:

https://docs.coingecko.com/reference/mcp-server

I recomend you use that one, as I probably won't update or keep this one current.

CoinGecko Server

A Model Context Protocol (MCP) server and OpenAI function calling service for interacting with the CoinGecko Pro API.

Features

  • Paginated list of supported cryptocurrencies
  • Coin ID lookup by name or symbol
  • Historical price, market cap, and volume data
  • OHLC (Open, High, Low, Close) candlestick data
  • Local coin cache with refresh capability

Installation

bash
npm install coingecko-server

Environment Setup

Create a `.env` file in your project root:

env
COINGECKO_API_KEY=your_api_key_here

Usage with Claude Desktop

Claude Desktop provides full support for MCP features. To use this server:

1. Install Claude Desktop

2. Add to your Claude Desktop configuration:

    json
    {
      "mcpServers": {
        "coingecko": {
          "command": "node",
          "args": ["/path/to/coingecko-server/build/index.js"],
          "env": {
            "COINGECKO_API_KEY": "your-api-key-here"
          }
        }
      }
    }

    3. Restart Claude Desktop

    The server provides the following tools:

    • `get-coins`: Get a paginated list of supported coins
    • `find-coin-ids`: Look up CoinGecko IDs for coin names/symbols
    • `get-historical-data`: Get historical price, market cap, and volume data
    • `get-ohlc-data`: Get OHLC candlestick data
    • `refresh-cache`: Refresh the local coin list cache

    Usage with OpenAI Function Calling

    typescript
    import { CoinGeckoService } from 'coingecko-server';
    import OpenAI from 'openai';
    
    const openai = new OpenAI();
    const coinGeckoService = new CoinGeckoService(process.env.COINGECKO_API_KEY);
    
    // Get function definitions
    const functions = CoinGeckoService.getOpenAIFunctionDefinitions();
    
    // Example: Get historical data
    const response = await openai.chat.completions.create({
      model: "gpt-4-turbo-preview",
      messages: [{ role: "user", content: "Get Bitcoin's price history for the last week" }],
      functions: [functions[2]], // get_historical_data function
      function_call: "auto",
    });
    
    if (response.choices[0].message.function_call) {
      const args = JSON.parse(response.choices[0].message.function_call.arguments);
      const history = await coinGeckoService.getHistoricalData(
        args.id,
        args.vs_currency,
        args.from,
        args.to,
        args.interval
      );
    }

    Data Types

    OHLCData

    typescript
    interface OHLCData {
      timestamp: number;
      open: number;
      high: number;
      low: number;
      close: number;
    }

    HistoricalData

    typescript
    interface HistoricalData {
      prices: [number, number][];
      market_caps: [number, number][];
      total_volumes: [number, number][];
    }

    CoinInfo

    typescript
    interface CoinInfo {
      id: string;
      symbol: string;
      name: string;
      platforms?: Record;
    }

    Rate Limits

    Please refer to the CoinGecko Pro API documentation for current rate limits and usage guidelines.

    License

    MIT

    Frequently asked questions

    What is mcp-coingecko-server?

    mcp-coingecko-server is An Anthropic MCP server (with OpenAI Function calling compatibility) for the Coingecko Pro API

    How do I install mcp-coingecko-server?

    Open the GitHub repository and follow its README. Most MCP servers are added to your client's MCP config, then called by your agent.

    Is mcp-coingecko-server open source?

    Yes — it is hosted on GitHub at https://github.com/crazyrabbitLTC/mcp-coingecko-server and has 9 stars.

    Related MCP tools

    Run your own MCP server? See who uses it and what to fix.

    Measure it with TrackMCP