CoinGecko

self.btc = self.add_data(CoinGecko, "BTC").symbol
self._universe = self.add_universe(CoinGeckoUniverse, self.universe_selection)

_symbol = AddData<CoinGecko>("BTC").Symbol;
_universe = AddUniverse(CoinGeckoUniverse, UniverseSelection)

from Algorithm import *

class CoinGeckoMarketCapDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2020, 6, 1)
        self.set_cash(100000)

        self.btcusd = self.add_crypto("BTCUSD", Resolution.DAILY).symbol
        self.dataset_symbol = self.add_data(CoinGecko, "BTC").symbol

using QuantConnect.DataSource;

namespace QuantConnect.Algorithm.CSharp.AltData
{
    public class CoinGeckoMarketCapDataAlgorithm: QCAlgorithm
    {
        private Symbol _symbol, _datasetSymbol;

        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2020, 6, 1);
            SetCash(100000);

            _symbol = AddCrypto("BTCUSD", Resolution.Daily).Symbol;
            _datasetSymbol = AddData<CoinGecko>("BTC").Symbol;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    if slice.contains_key(self.dataset_symbol):
        data_point = slice[self.dataset_symbol]
        self.log(f"{self.dataset_symbol} market cap::volume at {slice.time}: {data_point.market_cap}::{data_point.volume}")

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_datasetSymbol))
    {
        var dataPoint = slice[_datasetSymbol];
        Log($"{_datasetSymbol} market cap::volume at {slice.Time}: {dataPoint.MarketCap}::{dataPoint.Volume}");
    }
}

def on_data(self, slice: Slice) -> None:
    for dataset_symbol, data_point in slice.get(CoinGecko).items():
        self.log(f"{dataset_symbol} market cap::volume at {slice.time}: {data_point.market_cap}::{data_point.volume}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Get<CoinGecko>())
    {
        var datasetSymbol = kvp.Key;
        var dataPoint = kvp.Value;
        Log($"{datasetSymbol} market cap::volume at {slice.Time}: {dataPoint.MarketCap}::{dataPoint.Volume}");
    }
}

# DataFrame
history_df = self.history(self.dataset_symbol, 100, Resolution.DAILY)

# Dataset objects
history_bars = self.history[CoinGecko](self.dataset_symbol, 100, Resolution.DAILY)

var history = History<CoinGecko>(_datasetSymbol, 100, Resolution.Daily);

def initialize(self) -> None:
    self._universe = self.add_universe(CoinGeckoUniverse, self.universe_selection)

def universe_selection(self, data: List[CoinGeckoUniverse]) -> List[Symbol]:
    for datum in data:
        self.debug(f'{datum.coin},{datum.market_cap},{datum.price}')

    # define our selection criteria
    selected = sorted(data, key=lambda x: x.market_cap, reverse=True)[:3]
            
    # Use the CreateSymbol method to generate the Symbol object for
    # the desired market (Coinbase) and quote currency (e.g. USD)
    return [x.create_symbol(Market.COINBASE, "USD") for x in selected]

private Universe _universe;
public override void Initialize()
{
    _universe = AddUniverse<CoinGecko>(data =>
    {
        foreach (var datum in data.OfType<CoinGecko>())
        {
            Debug($"{datum.Coin},{datum.MarketCap},{datum.Price}");
        }

        // define our selection criteria
        // Use the CreateSymbol method to generate the Symbol object for
        // the desired market (Coinbase) and quote currency (e.g. USD)
        return (from d in data.OfType<CoinGeckoUniverse>()
            orderby d.MarketCap descending
            select d.CreateSymbol(Market.Coinbase, "USD")).Take(3);
    });
}

var universeHistory = History(_universe, 30, Resolution.Daily);
foreach (var coins in universeHistory)
{
    foreach (CoinGecko coin in coins)
    {
        Log($"{coin.Symbol.Value} market cap at {coin.EndTime}: {coin.MarketCap}");
    }
}

# DataFrame example where the columns are the CoinGeckoUniverse attributes: 
history_df = self.history(self._universe, 30, Resolution.DAILY, flatten=True)

# Series example where the values are lists of CoinGeckoUniverse objects: 
universe_history = self.history(self._universe, 30, Resolution.DAILY)
for (_, time), coins in universe_history.items():
    for coin in coins:
        self.log(f"{coin.symbol.value} market cap at {coin.end_time}: {coin.market_cap}")

var universeHistory = qb.UniverseHistory(universe, qb.Time.AddDays(-30), qb.Time);
foreach (var coins in universeHistory)
{
    foreach (CoinGecko coin in coins)
    {
        Console.WriteLine($"{coin.Symbol.Value} market cap at {coin.EndTime}: {coin.MarketCap}");
    }
}

# DataFrame example where the columns are the CoinGeckoUniverse attributes: 
history_df = qb.universe_history(universe, qb.time-timedelta(30), qb.time, flatten=True)

# Series example where the values are lists of CoinGeckoUniverse objects: 
universe_history = qb.universe_history(universe, qb.time-timedelta(30), qb.time)
for (_, time), coins in universe_history.items():
    for coin in coins:
        print(f"{coin.symbol.value} market cap at {coin.end_time}: {coin.market_cap}")

self.remove_security(self.dataset_symbol)

RemoveSecurity(_datasetSymbol);