mcp-crypto-price 2.6.0 → 3.0.0

package/README.md

@@ -9,6 +9,7 @@ A Model Context Protocol (MCP) server that provides comprehensive cryptocurrency
 
 ## What's New
 
+- **BREAKING**: CoinCap v2 API removed. Now uses v3 API exclusively. A `COINCAP_API_KEY` is required (free tier available at [pro.coincap.io/dashboard](https://pro.coincap.io/dashboard))
 - Streamable HTTP transport added (while keeping STDIO compatibility)
 - Release workflow signs commits via SSH for Verified releases
 - Smithery CLI scripts to build and run the HTTP server
@@ -25,7 +26,10 @@ Add this configuration to your Claude Desktop config file:
   "mcpServers": {
     "mcp-crypto-price": {
       "command": "npx",
-      "args": ["-y", "mcp-crypto-price"]
+      "args": ["-y", "mcp-crypto-price"],
+      "env": {
+        "COINCAP_API_KEY": "YOUR_API_KEY_HERE"
+      }
     }
   }
 }
@@ -38,7 +42,10 @@ If your MCP client requires launching via `cmd.exe` on Windows:
   "mcpServers": {
     "mcp-crypto-price": {
       "command": "cmd",
-      "args": ["/c", "npx", "-y", "mcp-crypto-price"]
+      "args": ["/c", "npx", "-y", "mcp-crypto-price"],
+      "env": {
+        "COINCAP_API_KEY": "YOUR_API_KEY_HERE"
+      }
     }
   }
 }
@@ -74,25 +81,16 @@ npm run build:stdio
 npm run start:stdio
 ```
 
-The dev/build commands will print the server address to the console. Use that URL in clients that support MCP over HTTP (for example, Smithery). You can optionally provide an API key via `COINCAP_API_KEY` for higher rate limits.
+The dev/build commands will print the server address to the console. Use that URL in clients that support MCP over HTTP (for example, Smithery). You must provide an API key via `COINCAP_API_KEY` (see below).
 
-## Optional: CoinCap API Key
+## Required: CoinCap API Key
 
-For higher rate limits, add an API key to your configuration:
+This server uses the CoinCap v3 API, which requires an API key. A **free tier** is available.
 
-```json
-{
-  "mcpServers": {
-    "mcp-crypto-price": {
-      "command": "npx",
-      "args": ["-y", "mcp-crypto-price"],
-      "env": {
-        "COINCAP_API_KEY": "YOUR_API_KEY_HERE"
-      }
-    }
-  }
-}
-```
+1. Sign up and get your API key at [pro.coincap.io/dashboard](https://pro.coincap.io/dashboard)
+2. Add the key to your MCP client configuration via the `COINCAP_API_KEY` environment variable (see Usage examples above)
+
+Without a valid API key, all tools will return an error with instructions on how to obtain one.
 
 ## Note for Smithery CLI users
 
@@ -100,11 +98,6 @@ This MCP server works directly via `npx` (configs above) and does not require Sm
 
 If you do use the Smithery CLI, authenticate with `smithery auth login` or by setting `SMITHERY_API_KEY` in your environment. Recent versions of the Smithery CLI do not support passing API keys via `--key` (or older `--profile` patterns).
 
-> **Important Note**: CoinCap is sunsetting their v2 API. This MCP supports both v2 and v3 APIs:
-> - If you provide a `COINCAP_API_KEY`, it will attempt to use the v3 API first, falling back to v2 if necessary
-> - Without an API key, it will use the v2 API (which will eventually be discontinued)
-> - It's recommended to obtain an API key from [pro.coincap.io/dashboard](https://pro.coincap.io/dashboard) as the v2 API will be completely deactivated in the future
-
 Launch Claude Desktop to start using the crypto analysis tools.
 
 ## Verified commits & SSH signing

package/dist/config/index.js

@@ -11,8 +11,7 @@ function readVersion() {
         return '0.0.0';
     }
 }
-export const COINCAP_API_V2_BASE = "https://api.coincap.io/v2";
-export const COINCAP_API_V3_BASE = "https://rest.coincap.io/v3";
+export const COINCAP_API_BASE = "https://rest.coincap.io/v3";
 export const SERVER_CONFIG = {
     name: "mcp-crypto-price",
     version: readVersion(),

package/dist/index.js

@@ -10,7 +10,7 @@ export const configSchema = z.object({
     coincapApiKey: z
         .string()
         .optional()
-        .describe("Optional API key for CoinCap to increase rate limits"),
+        .describe("API key for CoinCap v3 API (required). Free tier available at https://pro.coincap.io/dashboard"),
 });
 export function createServer({ config, }) {
     if (config?.coincapApiKey && !process.env.COINCAP_API_KEY) {

package/dist/services/__tests__/coincap.test.js

@@ -1,18 +1,28 @@
 import { jest } from '@jest/globals';
-import { getAssets, getMarkets, getHistoricalData, clearCache } from '../coincap.js';
+import { getAssets, getMarkets, getHistoricalData, clearCache, MissingApiKeyError } from '../coincap.js';
 // Mock global fetch
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
 // Suppress console.error during tests
 console.error = jest.fn();
 describe('CoinCap Service', () => {
+    const originalEnv = process.env;
     beforeEach(() => {
         jest.clearAllMocks();
         mockFetch.mockReset();
         clearCache();
+        process.env = { ...originalEnv, COINCAP_API_KEY: 'test-api-key' };
     });
     afterEach(() => {
         clearCache();
+        process.env = originalEnv;
+    });
+    describe('API key validation', () => {
+        it('should throw MissingApiKeyError when no API key is set', async () => {
+            delete process.env.COINCAP_API_KEY;
+            await expect(getAssets()).rejects.toThrow(MissingApiKeyError);
+            await expect(getAssets()).rejects.toThrow('https://pro.coincap.io/dashboard');
+        });
     });
     describe('getAssets', () => {
         it('should fetch assets successfully', async () => {
@@ -39,7 +49,9 @@ describe('CoinCap Service', () => {
             }));
             const result = await getAssets();
             expect(result).toEqual(mockResponse);
-            expect(mockFetch).toHaveBeenCalledWith('https://api.coincap.io/v2/assets', expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith('https://rest.coincap.io/v3/assets', expect.objectContaining({
+                headers: { Authorization: 'Bearer test-api-key' }
+            }));
         });
         it('should handle fetch errors', async () => {
             mockFetch.mockImplementationOnce(() => Promise.reject(new Error('Network error')));
@@ -78,7 +90,9 @@ describe('CoinCap Service', () => {
             }));
             const result = await getMarkets('bitcoin');
             expect(result).toEqual(mockResponse);
-            expect(mockFetch).toHaveBeenCalledWith('https://api.coincap.io/v2/assets/bitcoin/markets', expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith('https://rest.coincap.io/v3/assets/bitcoin/markets', expect.objectContaining({
+                headers: { Authorization: 'Bearer test-api-key' }
+            }));
         });
         it('should handle fetch errors for markets', async () => {
             mockFetch.mockImplementationOnce(() => Promise.reject(new Error('Network error')));
@@ -104,7 +118,9 @@ describe('CoinCap Service', () => {
             }));
             const result = await getHistoricalData('bitcoin', 'h1', 1609459200000, 1609545600000);
             expect(result).toEqual(mockResponse);
-            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('https://api.coincap.io/v2/assets/bitcoin/history'), expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('https://rest.coincap.io/v3/assets/bitcoin/history'), expect.objectContaining({
+                headers: { Authorization: 'Bearer test-api-key' }
+            }));
         });
         it('should handle fetch errors for historical data', async () => {
             mockFetch.mockImplementationOnce(() => Promise.reject(new Error('Network error')));

package/dist/services/coincap.js

@@ -1,5 +1,14 @@
-import { COINCAP_API_V2_BASE, COINCAP_API_V3_BASE, CACHE_TTL } from '../config/index.js';
+import { COINCAP_API_BASE, CACHE_TTL } from '../config/index.js';
 import { AssetsResponseSchema, HistoricalDataSchema, MarketsResponseSchema } from './schemas.js';
+const API_KEY_ERROR_MESSAGE = 'CoinCap API key is required. The v2 API has been sunset and all requests now use the v3 API, which requires an API key.\n\n' +
+    'A free tier is available! Get your API key at: https://pro.coincap.io/dashboard\n\n' +
+    'Then set the COINCAP_API_KEY environment variable in your MCP client configuration.';
+export class MissingApiKeyError extends Error {
+    constructor() {
+        super(API_KEY_ERROR_MESSAGE);
+        this.name = 'MissingApiKeyError';
+    }
+}
 const cache = new Map();
 // Expose cache clear function for testing
 export function clearCache() {
@@ -22,12 +31,6 @@ function setCacheData(key, data) {
         timestamp: Date.now()
     });
 }
-/**
- * Makes a request to the CoinCap API with fallback logic:
- * 1. If API key is provided, tries v3 API first
- * 2. If v3 fails or no API key is provided, falls back to v2
- * 3. If both fail, throws an error
- */
 async function makeCoinCapRequest(endpoint, schema) {
     // Check cache first
     const cacheKey = endpoint;
@@ -36,65 +39,29 @@ async function makeCoinCapRequest(endpoint, schema) {
         return cachedData;
     }
     const apiKey = process.env.COINCAP_API_KEY;
-    let error = null;
-    // Try v3 API if API key is provided
-    if (apiKey) {
-        try {
-            const v3Response = await fetch(`${COINCAP_API_V3_BASE}${endpoint}`, {
-                headers: {
-                    'Authorization': `Bearer ${apiKey}`
-                }
-            });
-            if (v3Response.ok) {
-                const raw = await v3Response.json();
-                const data = schema ? schema.parse(raw) : raw;
-                setCacheData(cacheKey, data);
-                return data;
-            }
-            else {
-                error = new Error(`V3 API error: ${v3Response.status} - ${v3Response.statusText}`);
-                console.warn("V3 API request failed, falling back to V2:", error.message);
-            }
-        }
-        catch (e) {
-            error = e instanceof Error ? e : new Error(String(e));
-            console.warn("V3 API request failed, falling back to V2:", error.message);
-        }
+    if (!apiKey) {
+        throw new MissingApiKeyError();
     }
-    // Fall back to v2 API
-    try {
-        const headers = {};
-        if (apiKey) {
-            headers['Authorization'] = `Bearer ${apiKey}`;
-        }
-        const v2Response = await fetch(`${COINCAP_API_V2_BASE}${endpoint}`, { headers });
-        if (v2Response.ok) {
-            const raw = await v2Response.json();
-            const data = schema ? schema.parse(raw) : raw;
-            setCacheData(cacheKey, data);
-            return data;
-        }
-        else {
-            throw new Error(`V2 API error: ${v2Response.status} - ${v2Response.statusText}`);
-        }
-    }
-    catch (e) {
-        const v2Error = e instanceof Error ? e : new Error(String(e));
-        console.error("V2 API request failed:", v2Error.message);
-        // If we have both errors, combine them for better debugging
-        if (error) {
-            throw new Error(`API requests failed. V3: ${error.message}, V2: ${v2Error.message}`);
-        }
-        else {
-            throw v2Error;
+    const response = await fetch(`${COINCAP_API_BASE}${endpoint}`, {
+        headers: {
+            'Authorization': `Bearer ${apiKey}`
         }
+    });
+    if (!response.ok) {
+        throw new Error(`CoinCap API error: ${response.status} - ${response.statusText}`);
     }
+    const raw = await response.json();
+    const data = schema ? schema.parse(raw) : raw;
+    setCacheData(cacheKey, data);
+    return data;
 }
 export async function getAssets() {
     try {
         return await makeCoinCapRequest('/assets', AssetsResponseSchema);
     }
     catch (error) {
+        if (error instanceof MissingApiKeyError)
+            throw error;
         console.error("Failed to get assets:", error);
         return null;
     }
@@ -108,6 +75,8 @@ export async function searchAsset(symbol) {
         return asset ?? null;
     }
     catch (error) {
+        if (error instanceof MissingApiKeyError)
+            throw error;
         console.error(`Failed to search for asset ${symbol}:`, error);
         return null;
     }
@@ -117,6 +86,8 @@ export async function getMarkets(assetId) {
         return await makeCoinCapRequest(`/assets/${assetId}/markets`, MarketsResponseSchema);
     }
     catch (error) {
+        if (error instanceof MissingApiKeyError)
+            throw error;
         console.error(`Failed to get markets for asset ${assetId}:`, error);
         return null;
     }
@@ -126,6 +97,8 @@ export async function getHistoricalData(assetId, interval, start, end) {
         return await makeCoinCapRequest(`/assets/${assetId}/history?interval=${interval}&start=${start}&end=${end}`, HistoricalDataSchema);
     }
     catch (error) {
+        if (error instanceof MissingApiKeyError)
+            throw error;
         console.error(`Failed to get historical data for asset ${assetId}:`, error);
         return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-crypto-price",
-  "version": "2.6.0",
+  "version": "3.0.0",
   "description": "A Model Context Protocol (MCP) server that provides real-time cryptocurrency data and analysis through CoinCap's API. Features include price tracking, market analysis, and historical trends.",
   "license": "MIT",
   "author": {