coingecko

CoinGecko Solana API 开发指南

本指南全面介绍如何集成 CoinGecko 的 Solana 链上 API。可获取实时代币价格、DEX 池数据、OHLCV 图表、交易历史和市场分析，覆盖 1,700 多个去中心化交易所。

概述

CoinGecko 的 Solana API 提供：

• 代币价格：通过合约地址获取实时价格（单个或批量）
• 池数据：流动性池信息、热门池、顶级池
• OHLCV 图表：用于技术分析的 K 线数据
• 交易历史：任意池的近期交易
• DEX 发现：列出所有在 Solana 上运行的 DEX
• 搜索：按代币名称、符号或地址查找池
• Megafilter：对池、代币和 DEX 进行高级筛选

主要功能

功能	描述
250 多个网络	支持 Solana 在内的多链
1,700 多个 DEX	Raydium、Orca、Jupiter、Meteora、Pump.fun 等
1,500 多万种代币	全面的代币覆盖
实时数据	每 10–30 秒更新一次
历史数据	OHLCV 图表和交易历史

---

快速开始

获取 API 密钥

1. Demo API（免费）：访问 coingecko.com/en/api
2. Pro API（付费）：访问 coingecko.com/en/api/pricing

环境设置

# .env file
COINGECKO_API_KEY=your_api_key_here
COINGECKO_API_TYPE=demo  # or 'pro'

API 配置

// Configuration for both Demo and Pro APIs
const CONFIG = {
  demo: {
    baseUrl: 'https://api.coingecko.com/api/v3/onchain',
    headerKey: 'x-cg-demo-api-key',
    rateLimit: 30, // calls per minute
  },
  pro: {
    baseUrl: 'https://pro-api.coingecko.com/api/v3/onchain',
    headerKey: 'x-cg-pro-api-key',
    rateLimit: 500, // calls per minute (varies by plan)
  },
};

const apiType = process.env.COINGECKO_API_TYPE || 'demo';
const apiKey = process.env.COINGECKO_API_KEY;

const BASE_URL = CONFIG[apiType].baseUrl;
const HEADER_KEY = CONFIG[apiType].headerKey;

// Solana network identifier
const NETWORK = 'solana';

获取代币价格基础示例

async function getTokenPrice(tokenAddress: string): Promise<number | null> {
  const url = `${BASE_URL}/simple/networks/${NETWORK}/token_price/${tokenAddress}`;

  const response = await fetch(url, {
    headers: {
      [HEADER_KEY]: apiKey,
      'Accept': 'application/json',
    },
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  const data = await response.json();
  return data.data?.attributes?.token_prices?.[tokenAddress] ?? null;
}

// Usage
const USDC = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
const price = await getTokenPrice(USDC);
console.log(`USDC Price: $${price}`);

---

API 端点参考

简单代币价格

通过合约地址获取代币价格。

端点：GET /simple/networks/{network}/token_price/{addresses}

参数：

参数	类型	必填	描述
network	string	是	网络 ID（solana）
addresses	string	是	以逗号分隔的代币地址（Demo 最多 30 个，Pro 最多 100 个）
include_market_cap	boolean	否	包含市值数据
include_24hr_vol	boolean	否	包含 24 小时交易量
include_24hr_price_change	boolean	否	包含 24 小时价格变化百分比

async function getTokenPrices(addresses: string[]): Promise<Record<string, TokenPriceData>> {
  const addressList = addresses.join(',');
  const url = `${BASE_URL}/simple/networks/${NETWORK}/token_price/${addressList}`;

  const params = new URLSearchParams({
    include_market_cap: 'true',
    include_24hr_vol: 'true',
    include_24hr_price_change: 'true',
  });

  const response = await fetch(`${url}?${params}`, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.attributes || {};
}

---

按地址获取代币数据

获取详细的代币信息。

端点：GET /networks/{network}/tokens/{address}

参数：

参数	类型	必填	描述
network	string	是	网络 ID
address	string	是	代币合约地址
include	string	否	包含 top_pools 以获取流动性数据

interface TokenData {
  address: string;
  name: string;
  symbol: string;
  decimals: number;
  image_url: string;
  price_usd: string;
  fdv_usd: string;
  market_cap_usd: string;
  total_supply: string;
  volume_usd: {
    h24: string;
  };
  price_change_percentage: {
    h24: string;
  };
}

async function getTokenData(address: string): Promise<TokenData> {
  const url = `${BASE_URL}/networks/${NETWORK}/tokens/${address}?include=top_pools`;

  const response = await fetch(url, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.attributes;
}

---

多代币数据

批量获取多个代币的数据。

端点：GET /networks/{network}/tokens/multi/{addresses}

async function getMultipleTokens(addresses: string[]): Promise<TokenData[]> {
  const addressList = addresses.join(',');
  const url = `${BASE_URL}/networks/${NETWORK}/tokens/multi/${addressList}`;

  const response = await fetch(url, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.map((item: any) => item.attributes) || [];
}

---

按地址获取池数据

获取详细的池信息。

端点：GET /networks/{network}/pools/{address}

参数：

参数	类型	必填	描述
include	string	否	base_token、quote_token、dex
include_volume_breakdown	boolean	否	按时间范围细分交易量

interface PoolData {
  address: string;
  name: string;
  pool_created_at: string;
  base_token_price_usd: string;
  quote_token_price_usd: string;
  base_token_price_native_currency: string;
  fdv_usd: string;
  market_cap_usd: string;
  reserve_in_usd: string;
  price_change_percentage: {
    m5: string;
    h1: string;
    h6: string;
    h24: string;
  };
  transactions: {
    m5: { buys: number; sells: number };
    h1: { buys: number; sells: number };
    h24: { buys: number; sells: number };
  };
  volume_usd: {
    m5: string;
    h1: string;
    h6: string;
    h24: string;
  };
}

async function getPoolData(poolAddress: string): Promise<PoolData> {
  const url = `${BASE_URL}/networks/${NETWORK}/pools/${poolAddress}`;

  const params = new URLSearchParams({
    include: 'base_token,quote_token,dex',
  });

  const response = await fetch(`${url}?${params}`, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.attributes;
}

---

热门池

获取所有网络的热门池，或按网络筛选。

端点：GET /networks/trending_pools

参数：

参数	类型	默认值	描述
include	string	base_token	要包含的属性
page	integer	1	页码
duration	string	24h	5m、1h、6h、24h

async function getTrendingPools(duration: '5m' | '1h' | '6h' | '24h' = '24h'): Promise<PoolData[]> {
  const url = `${BASE_URL}/networks/trending_pools`;

  const params = new URLSearchParams({
    include: 'base_token,quote_token,dex,network',
    duration,
    page: '1',
  });

  const response = await fetch(`${url}?${params}`, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.map((item: any) => item.attributes) || [];
}

// Filter for Solana pools
async function getSolanaTrendingPools(): Promise<PoolData[]> {
  const allPools = await getTrendingPools();
  return allPools.filter(pool => pool.network === 'solana');
}

---

网络中的顶级池

获取 Solana 上交易量最高的池。

端点：GET /networks/{network}/pools

async function getTopPools(page: number = 1): Promise<PoolData[]> {
  const url = `${BASE_URL}/networks/${NETWORK}/pools`;

  const params = new URLSearchParams({
    include: 'base_token,quote_token,dex',
    page: page.toString(),
  });

  const response = await fetch(`${url}?${params}`, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.map((item: any) => item.attributes) || [];
}

---

搜索池

按代币名称、符号或地址搜索池。

端点：GET /search/pools

参数：

参数	类型	描述
query	string	搜索词（名称、符号、地址）
network	string	按网络筛选
page	integer	页码

async function searchPools(query: string): Promise<PoolData[]> {
  const url = `${BASE_URL}/search/pools`;

  const params = new URLSearchParams({
    query,
    network: NETWORK,
    include: 'base_token,quote_token,dex',
  });

  const response = await fetch(`${url}?${params}`, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.map((item: any) => item.attributes) || [];
}

// Search for SOL pools
const solPools = await searchPools('SOL');

---

池 OHLCV 图表

获取用于技术分析的 K 线数据。

端点：GET /networks/{network}/pools/{pool_address}/ohlcv/{timeframe}

时间范围：day、hour、minute

参数：

参数	类型	描述
aggregate	integer	K 线聚合间隔（分钟级为 1、5、15；小时级为 1、4、12）
before_timestamp	integer	用于分页的 Unix 时间戳
limit	integer	K 线数量（最多 1000）
currency	string	usd 或 token

interface OHLCVData {
  timestamp: number;
  open: number;
  high: number;
  low: number;
  close: number;
  volume: number;
}

async function getPoolOHLCV(
  poolAddress: string,
  timeframe: 'day' | 'hour' | 'minute' = 'hour',
  aggregate: number = 1,
  limit: number = 100
): Promise<OHLCVData[]> {
  const url = `${BASE_URL}/networks/${NETWORK}/pools/${poolAddress}/ohlcv/${timeframe}`;

  const params = new URLSearchParams({
    aggregate: aggregate.toString(),
    limit: limit.toString(),
    currency: 'usd',
  });

  const response = await fetch(`${url}?${params}`, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();

  return data.data?.attributes?.ohlcv_list?.map((candle: number[]) => ({
    timestamp: candle[0],
    open: candle[1],
    high: candle[2],
    low: candle[3],
    close: candle[4],
    volume: candle[5],
  })) || [];
}

// Get hourly candles
const hourlyCandles = await getPoolOHLCV(poolAddress, 'hour', 1, 24);

// Get 5-minute candles
const fiveMinCandles = await getPoolOHLCV(poolAddress, 'minute', 5, 100);

---

最近交易

获取池的最近交易。

端点：GET /networks/{network}/pools/{pool_address}/trades

interface TradeData {
  block_number: number;
  block_timestamp: string;
  tx_hash: string;
  tx_from_address: string;
  from_token_amount: string;
  to_token_amount: string;
  price_from_in_currency_token: string;
  price_to_in_currency_token: string;
  price_from_in_usd: string;
  price_to_in_usd: string;
  kind: 'buy' | 'sell';
  volume_in_usd: string;
}

async function getRecentTrades(poolAddress: string): Promise<TradeData[]> {
  const url = `${BASE_URL}/networks/${NETWORK}/pools/${poolAddress}/trades`;

  const response = await fetch(url, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.map((item: any) => item.attributes) || [];
}

---

列出 Solana 上的 DEX

获取 Solana 上的所有去中心化交易所。

端点：GET /networks/{network}/dexes

interface DexData {
  id: string;
  name: string;
}

async function getSolanaDexes(): Promise<DexData[]> {
  const url = `${BASE_URL}/networks/${NETWORK}/dexes`;

  const response = await fetch(url, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.map((item: any) => ({
    id: item.id,
    name: item.attributes.name,
  })) || [];
}

---

Megafilter（高级）

对跨网络、DEX 和代币的池进行高级筛选。

端点：GET /pools/megafilter

参数：

参数	类型	描述
networks	string	按网络筛选
dexes	string	按 DEX 筛选
sort	string	排序方式（例如，pool_created_at_desc）
min_reserve_in_usd	number	最低流动性
min_h24_volume_usd	number	最低 24 小时交易量

async function getMegafilterPools(options: {
  dexes?: string[];
  minLiquidity?: number;
  minVolume?: number;
  sort?: string;
}): Promise<PoolData[]> {
  const url = `${BASE_URL}/pools/megafilter`;

  const params = new URLSearchParams({
    networks: NETWORK,
    page: '1',
  });

  if (options.dexes) {
    params.set('dexes', options.dexes.join(','));
  }
  if (options.minLiquidity) {
    params.set('min_reserve_in_usd', options.minLiquidity.toString());
  }
  if (options.minVolume) {
    params.set('min_h24_volume_usd', options.minVolume.toString());
  }
  if (options.sort) {
    params.set('sort', options.sort);
  }

  const response = await fetch(`${url}?${params}`, {
    headers: { [HEADER_KEY]: apiKey },
  });

  const data = await response.json();
  return data.data?.map((item: any) => item.attributes) || [];
}

// Get newest Pump.fun pools
const pumpfunPools = await getMegafilterPools({
  dexes: ['pump-fun'],
  sort: 'pool_created_at_desc',
});

// Get high-volume Raydium pools
const raydiumPools = await getMegafilterPools({
  dexes: ['raydium'],
  minVolume: 100000,
  minLiquidity: 50000,
});

---

常见 Solana DEX 标识符

DEX	ID	描述
Raydium	raydium	Solana 上领先的 AMM
Orca	orca	易于使用的 DEX
Jupiter	jupiter	带有池的聚合器
Meteora	meteora	动态 AMM
Pump.fun	pump-fun	Meme 币发行平台
OpenBook	openbook	订单簿 DEX
Lifinity	lifinity	主动型做市商
Phoenix	phoenix	链上订单簿

---

常见代币地址

代币	地址
USDC	EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
USDT	Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB
SOL（Wrapped）	So11111111111111111111111111111111111111112
JUP	JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN
BONK	DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263
WIF	EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm
PYTH	HZ1JovNiVvGrGNiiYvEozEVgZ58xaU3RKwX8eACQBCt3
RAY	4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R
ORCA	orcaEKTdK7LKz57vaAYr9QeNsVEPfiu6QeMU1kektZE

---

速率限制

方案	每分钟调用次数	每个请求的地址数量上限
Demo（免费）	30	30
Analyst	500	50
Lite	500	50
Pro	1,000	100
Enterprise	自定义	自定义

速率限制处理

class RateLimiter {
  private calls: number[] = [];
  private maxCalls: number;
  private windowMs: number = 60000; // 1 minute

  constructor(maxCallsPerMinute: number) {
    this.maxCalls = maxCallsPerMinute;
  }

  async waitForSlot(): Promise<void> {
    const now = Date.now();
    this.calls = this.calls.filter(t => now - t < this.windowMs);

    if (this.calls.length >= this.maxCalls) {
      const oldestCall = this.calls[0];
      const waitTime = this.windowMs - (now - oldestCall);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }

    this.calls.push(Date.now());
  }
}

// Usage
const rateLimiter = new RateLimiter(30); // Demo API

async function fetchWithRateLimit(url: string): Promise<any> {
  await rateLimiter.waitForSlot();
  const response = await fetch(url, {
    headers: { [HEADER_KEY]: apiKey },
  });
  return response.json();
}

---

错误处理

async function safeApiCall<T>(url: string): Promise<T | null> {
  try {
    const response = await fetch(url, {
      headers: { [HEADER_KEY]: apiKey },
    });

    if (response.status === 401) {
      throw new Error('Invalid API key');
    }
    if (response.status === 429) {
      throw new Error('Rate limit exceeded - wait before retrying');
    }
    if (response.status === 404) {
      console.warn('Resource not found');
      return null;
    }
    if (!response.ok) {
      throw new Error(`API error: ${response.status}`);
    }

    return response.json();
  } catch (error) {
    console.error('CoinGecko API error:', error);
    throw error;
  }
}

常见错误代码

代码	含义	解决方案
401	API 密钥无效	检查 API 密钥
429	超出速率限制	等待后重试，或升级方案
404	未找到资源	检查地址/网络 ID
500+	服务端错误	使用指数退避策略重试

---

最佳实践

安全

• 切勿将 API 密钥提交到 git
• 使用环境变量
• 定期轮换密钥
• 为开发和生产环境使用不同的密钥

性能

• 尽可能批量请求代币数据
• 缓存经常访问的数据
• 为 OHLCV 使用合适的时间范围
• 针对速率限制实现请求队列

数据质量

• 核实市值数据（未经验证时可能为 null）
• 在信任价格前检查池的流动性
• 使用多个时间范围进行价格分析
• 监控最近交易时间戳以了解活跃度

---

资源

• CoinGecko API 文档
• GeckoTerminal
• CoinGecko API 定价
• API 更新日志

---

技能结构

coingecko/
├── SKILL.md                      # This file
├── resources/
│   ├── api-reference.md          # Complete API endpoint reference
│   ├── network-dex-ids.md        # Solana network and DEX identifiers
│   └── token-addresses.md        # Common Solana token addresses
├── examples/
│   ├── token-prices/
│   │   └── get-token-price.ts    # Token price examples
│   ├── pools/
│   │   └── pool-data.ts          # Pool data examples
│   ├── ohlcv/
│   │   └── ohlcv-charts.ts       # OHLCV chart examples
│   ├── trades/
│   │   └── recent-trades.ts      # Trade history examples
│   └── integration/
│       └── full-client.ts        # Complete client example
├── templates/
│   └── coingecko-client.ts       # Production-ready client template
└── docs/
    └── troubleshooting.md        # Common issues and solutions