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 AlgorithmImports 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

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);

class CryptoMarketCapUniverseAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_account_currency("USD") 
        self._market = Market.COINBASE
        self._market_pairs = [
            x.key.symbol 
            for x in self.symbol_properties_database.get_symbol_properties_list(self._market) 
            if x.value.quote_currency == self.account_currency
        ]
        self._universe = self.add_universe(CoinGeckoUniverse, 'CoinGeckoUniverse', Resolution.DAILY, self._select_assets)

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

        # Select the coins that our brokerage supports and have a quote currency that matches
        # our account currency.
        tradable_coins = [d for d in data if d.coin + self.account_currency in self._market_pairs]
        # Select the largest coins and create their Symbol objects.
        return [
            c.create_symbol(self._market, self.account_currency) 
            for c in sorted(tradable_coins, key=lambda x: x.market_cap)[-10:]
        ]

public class CryptoMarketCapUniverseAlgorithm : QCAlgorithm
{
    private Universe _universe;
    public override void Initialize()
    {
        SetAccountCurrency("USD");
        var market = Market.Coinbase;
        var marketPairs = SymbolPropertiesDatabase.GetSymbolPropertiesList(market)
            .Where(x => x.Value.QuoteCurrency == AccountCurrency)
            .Select(x => x.Key.Symbol)
            .ToList();
        _universe = AddUniverse<CoinGecko>(data =>
        {
            foreach (var datum in data.OfType<CoinGecko>())
            {
                Debug($"{datum.Coin},{datum.MarketCap},{datum.Price}");
            }
            return data
                .Select(c => c as CoinGecko)
                // Select the coins that the brokerage supports and have a quote currency that 
                // matches our account currency.
                .Where(c => marketPairs.Contains(c.Coin + AccountCurrency))
                // Select the 10 largest coins.
                .OrderByDescending(c => c.MarketCap)
                .Take(10)
                // Create the Symbol objects of the selected coins.
                .Select(c => c.CreateSymbol(market, AccountCurrency));
        });
    }
}

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);