CoinAPI

# Binance accepts both Cash and Margin account types only.
self.set_brokerage_model(BrokerageName.BINANCE, AccountType.CASH)
#self.set_brokerage_model(BrokerageName.BINANCE, AccountType.MARGIN)

self.btcbusd = self.add_crypto("BTCBUSD", Resolution.MINUTE, Market.BINANCE).symbol

self._universe = self.add_universe(CryptoUniverse.binance(self.universe_selection_filter))

// Binance accepts both Cash and Margin account types only.
SetBrokerageModel(BrokerageName.Binance, AccountType.Cash);
//SetBrokerageModel(BrokerageName.Binance, AccountType.Margin);

_symbol = AddCrypto("BTCBUSD", Resolution.Minute, Market.Binance).Symbol;

_universe = AddUniverse(CryptoUniverse.Binance(UniverseSelectionFilter));

class CoinAPIDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 6, 1)
        self.set_end_date(2021, 6, 1)

        # Set Account Currency to Binance Stable Coin for USD
        self.set_account_currency("BUSD")
        self.set_cash(100000)

        # Binance accepts both Cash and Margin account types.
        self.set_brokerage_model(BrokerageName.BINANCE, AccountType.MARGIN)
        
        self.btcbusd = self.add_crypto("BTCBUSD", Resolution.MINUTE, Market.BINANCE).symbol

public class CoinAPIDataAlgorithm : QCAlgorithm
{
    private Symbol _symbol;
    
    public override void Initialize()
    {
        SetStartDate(2020, 6, 1);
        SetEndDate(2021, 6, 1);

        // Set Account Currency to Binance Stable Coin for USD
        SetAccountCurrency("BUSD");
        SetCash(100000);

        // Binance accepts both Cash and Margin account types.
        SetBrokerageModel(BrokerageName.Binance, AccountType.Margin);
        
        _symbol = AddCrypto("BTCBUSD", Resolution.Minute, Market.Binance).Symbol;
    }
}

def on_data(self, slice: Slice) -> None:
    if self.btcbusd in slice.bars:
        trade_bar = slice.bars[self.btcbusd]
        self.log(f"{self.btcbusd} close at {slice.time}: {trade_bar.close}")

    if self.btcbusd in slice.quote_bars:
        quote_bar = slice.quote_bars[self.btcbusd]
        self.log(f"{self.btcbusd} bid at {slice.time}: {quote_bar.bid.close}")

    if self.btcbusd in slice.ticks:
        ticks = slice.ticks[self.btcbusd]
        for tick in ticks:
            self.log(f"{self.btcbusd} price at {slice.time}: {tick.price}")

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
        Log($"{_symbol} price at {slice.Time}: {tradeBar.Close}");
    }

    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
        Log($"{_symbol} bid at {slice.Time}: {quoteBar.Bid.Close}");
    }

    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            Log($"{_symbol} price at {slice.Time}: {tick.Price}");
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.bars.items():
        self.log(f"{symbol} close at {slice.time}: {trade_bar.close}")

    for symbol, quote_bar in slice.quote_bars.items():
        self.log(f"{symbol} bid at {slice.time}: {quote_bar.bid.close}")

    for symbol, ticks in slice.ticks.items():
        for tick in ticks:
            self.log(f"{symbol} price at {slice.time}: {tick.price}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        Log($"{symbol} price at {slice.Time}: {tradeBar.Close}");
    }

    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        Log($"{symbol} bid at {slice.Time}: {quoteBar.Bid.Close}");
    }

    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            Log($"{symbol} price at {slice.Time}: {tick.Price}");
        }
    }
}

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

# TradeBar objects
history_trade_bars = self.history[TradeBar](self.btcbusd, 100, Resolution.MINUTE)

# QuoteBar objects
history_quote_bars = self.history[QuoteBar](self.btcbusd, 100, Resolution.MINUTE)

# Tick objects
history_ticks = self.history[Tick](self.btcbusd, timedelta(seconds=10), Resolution.TICK)

// TradeBar objects 
var historyTradeBars = History(_symbol, 100, Resolution.Daily);

// QuoteBar objects 
var historyQuoteBars = History<QuoteBar>(_symbol, 100, Resolution.Minute);

// Tick objects 
var historyTicks = History<Tick>(_symbol, TimeSpan.FromSeconds(10), Resolution.Tick);

def initialize(self) -> None:
    self.universe_settings.asynchronous = True
    self.set_brokerage_model(BrokerageName.BINANCE, AccountType.MARGIN)
    self._universe = self.add_universe(CryptoUniverse.binance(self.universe_selection_filter))

def universe_selection_filter(self, universe_day):
    return [c.symbol for c in universe_day if c.volume >= 100 and c.volume_in_usd > 10000]

using QuantConnect.Data.UniverseSelection;

public override void Initialize()
{
    UniverseSettings.Asynchronous = true;
    SetBrokerageModel(BrokerageName.Binance, AccountType.Margin);
    _universe = AddUniverse(CryptoUniverse.Binance(UniverseSelectionFilter));
}

private IEnumerable<Symbol> UniverseSelectionFilter(IEnumerable<CryptoUniverse> universeDay)
{
    return from c in universeDay
           where c.Volume >= 100m && c.VolumeInUsd > 10000m
           select c.Symbol;
}

var history = History(_universe, 30, Resolution.Daily);
foreach (var universeDay in history)
{
    foreach (CryptoUniverse universeItem in universeDay)
    {
        Log($"{universeItem.Symbol} price at {universeItem.EndTime}: {universeItem.Close}");
    }
}

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

# Series example where the values are lists of CryptoUniverse objects: 
history = self.history(self._universe, 30, Resolution.DAILY)
for (univere_symbol, time), universe_day in history.items():
    for universe_item in universe_day:
        self.log(f"{universe_item.symbol} price at {universe_item.end_time}: {universe_item.close}")

var universeHistory = qb.UniverseHistory(universe, qb.Time.AddDays(-30), qb.Time);
foreach (var universeDay in universeHistory)
{
    foreach (CryptoUniverse universeItem in universeDay)
    {
        Console.WriteLine($"{universeItem.Symbol} price at {universeItem.EndTime}: {universeItem.Close}");
    }
}

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

# Series example where the values are lists of CryptoUniverse objects: 
universe_history = qb.universe_history(universe, qb.time-timedelta(30), qb.time)
for (univere_symbol, time), universe_day in universe_history.items():
    for universe_item in universe_day:
        print(f"{universe_item.symbol} price at {universe_item.end_time}: {universe_item.close}")

self.remove_security(self.btcbusd)

RemoveSecurity(_symbol);