GET https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd

{
  "bitcoin": {
    "usd": 43250.67
  }
}

GET https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest?symbol=BTC

X-CMC_PRO_API_KEY: your-api-key-here

GET https://api.coinbase.com/v2/exchange-rates?currency=BTC

GET https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT

// Hàm lấy giá Bitcoin từ CoinGecko
async function getBitcoinPriceCoinGecko() {
  try {
    const response = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd,eur,gbp');
    const data = await response.json();
    return {
      source: 'CoinGecko',
      usd: data.bitcoin.usd,
      eur: data.bitcoin.eur,
      gbp: data.bitcoin.gbp
    };
  } catch (error) {
    console.error('Lỗi khi lấy dữ liệu từ CoinGecko:', error);
    return null;
  }
}

// Hàm lấy giá Bitcoin từ Coinbase
async function getBitcoinPriceCoinbase() {
  try {
    const response = await fetch('https://api.coinbase.com/v2/exchange-rates?currency=BTC');
    const data = await response.json();
    return {
      source: 'Coinbase',
      usd: parseFloat(data.data.rates.USD),
      eur: parseFloat(data.data.rates.EUR),
      gbp: parseFloat(data.data.rates.GBP)
    };
  } catch (error) {
    console.error('Lỗi khi lấy dữ liệu từ Coinbase:', error);
    return null;
  }
}

import requests
import json

def get_bitcoin_price_coingecko():
    """Lấy giá Bitcoin từ API CoinGecko"""
    url = "https://api.coingecko.com/api/v3/simple/price"
    params = {
        'ids': 'bitcoin',
        'vs_currencies': 'usd,eur,gbp',
        'include_24hr_change': 'true'
    }
    try:
        response = requests.get(url, params=params)
        response.raise_for_status()
        data = response.json()

        return {
            'source': 'CoinGecko',
            'price_usd': data['bitcoin']['usd'],
            'price_eur': data['bitcoin']['eur'],
            'price_gbp': data['bitcoin']['gbp'],
            'change_24h': data['bitcoin'].get('usd_24h_change', 0)
        }
    except requests.RequestException as e:
        print(f"Lỗi khi lấy giá Bitcoin: {e}")
        return None

class BitcoinPriceCache {
  constructor(cacheDurationMs = 60000) { // Thời gian mặc định 1 phút
    this.cache = new Map();
    this.cacheDuration = cacheDurationMs;
  }

  async getPrice(source) {
    const cached = this.cache.get(source);
    const now = Date.now();

    if (cached && (now - cached.timestamp) < this.cacheDuration) {
      return cached.data;
    }

    const freshData = await this.fetchFreshPrice(source);
    if (freshData) {
      this.cache.set(source, {
        data: freshData,
        timestamp: now
      });
    }

    return freshData;
  }
}

async function getBitcoinPriceWithFallback() {
  const apiSources = [
    getBitcoinPriceCoinGecko,
    getBitcoinPriceCoinbase,
    getBitcoinPriceBinance
  ];

  for (const apiFunction of apiSources) {
    try {
      const result = await apiFunction();
      if (result && result.usd) {
        return result;
      }
    } catch (error) {
      console.warn(`API nguồn thất bại, thử nguồn tiếp theo...`, error);
      continue;
    }
  }

  throw new Error('Tất cả các API giá Bitcoin hiện không khả dụng');
}

class BitcoinPriceStream {
  constructor() {
    this.ws = null;
    this.callbacks = [];
  }

  connect() {
    // WebSocket của Binance cho giá BTC thời gian thực
    this.ws = new WebSocket('wss://stream.binance.com:9443/ws/btcusdt@ticker');

    this.ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      const priceUpdate = {
        price: parseFloat(data.c), // Giá hiện tại
        change: parseFloat(data.P), // % thay đổi 24h
        timestamp: new Date(data.E) // Thời gian sự kiện
      };

      this.callbacks.forEach(callback => callback(priceUpdate));
    };
  }

  subscribe(callback) {
    this.callbacks.push(callback);
  }
}

// Endpoint phía server (Node.js/Express)
app.get('/api/bitcoin-price', async (req, res) => {
  const apiKey = process.env.COINMARKETCAP_API_KEY;
  try {
    const response = await fetch('https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest?symbol=BTC', {
      headers: {
        'X-CMC_PRO_API_KEY': apiKey
      }
    });

    const data = await response.json();
    res.json({
      price: data.data.BTC.quote.USD.price,
      change_24h: data.data.BTC.quote.USD.percent_change_24h
    });
  } catch (error) {
    res.status(500).json({ error: 'Không thể lấy giá Bitcoin' });
  }
});

function validateBitcoinPrice(data) {
  if (!data || typeof data !== 'object') {
    throw new Error('Định dạng dữ liệu giá không hợp lệ');
  }

  const price = parseFloat(data.price);
  if (isNaN(price) || price <= 0) {
    throw new Error('Giá trị giá không hợp lệ');
  }

  return {
    price: Math.round(price * 100) / 100, // Làm tròn đến 2 chữ số thập phân
    timestamp: Date.now(),
    validated: true
  };
}

async function getCryptoPrices(symbols = ['bitcoin', 'ethereum', 'cardano']) {
  const ids = symbols.join(',');
  const response = await fetch(`https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd`);
  return response.json();
}

const response = await fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});

class APIMonitor {
  constructor() {
    this.stats = {
      totalRequests: 0,
      successfulRequests: 0,
      failedRequests: 0,
      averageResponseTime: 0
    };
  }

  async monitoredRequest(apiFunction) {
    const startTime = Date.now();
    this.stats.totalRequests++;

    try {
      const result = await apiFunction();
      this.stats.successfulRequests++;
      this.updateResponseTime(Date.now() - startTime);
      return result;
    } catch (error) {
      this.stats.failedRequests++;
      throw error;
    }
  }
}