Crypto

public override void OnData(Slice slice)
{
    // Check if the symbol is contained in TradeBars object
    if (slice.Bars.ContainsKey(_symbol))
    {
        // Obtain the mapped TradeBar of the symbol
        var tradeBar = slice.Bars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    # Obtain the mapped TradeBar of the symbol if any
    trade_bar = slice.bars.get(self._symbol)   # None if not found

public override void OnData(Slice slice)
{
    // Iterate all received Symbol-TradeBar key-value pairs
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    # Iterate all received Symbol-TradeBar key-value pairs
    for symbol, trade_bar in slice.bars.items():
        close_price = trade_bar.close

public override void OnData(Slice slice)
{
    // Check if the symbol is contained in QuoteBars object
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        // Obtain the mapped QuoteBar of the symbol
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    # Obtain the mapped QuoteBar of the symbol if any
    quote_bar = slice.quote_bars.get(self._symbol)   # None if not found

public override void OnData(Slice slice)
{
    // Iterate all received Symbol-QuoteBar key-value pairs
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def on_data(self, slice: Slice) -> None:
    # Iterate all received Symbol-QuoteBar key-value pairs
    for symbol, quote_bar in slice.quote_bars.items():
        ask_price = quote_bar.ask.close

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    ticks = slice.ticks.get(self._symbol, [])   # Empty if not found
    for tick in ticks:
        price = tick.price

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, ticks in slice.ticks.items():
        for tick in ticks:
            price = tick.price

public class CryptoExampleAlgorithm : QCAlgorithm
{
    private Symbol _symbol;
    // Set a day count variable for counting the days of the DCA trade.
    private int _dayCount = 0;

    public override void Initialize()
    {
        // Set the brokerage and account type to match your brokerage environment for accurate fee and margin behavior.
        SetBrokerageModel(BrokerageName.Bitfinex, AccountType.Cash);
        // For daily DCA purchases, subscribe to daily asset data.
        _symbol = AddCrypto("BTCUSD", Resolution.Daily).Symbol;
    }

    public override void OnData(Slice slice)
    {
        // If you haven't invested for 30 consecutive days yet, continue buying.
        if (slice.Bars.ContainsKey(_symbol) && _dayCount++ < 30)
        {
            // Calculate the order size for $10,000 USD using the current price.
            var size = 10000m / slice.Bars[_symbol].Close;
            MarketOrder(_symbol, size);
        }
    }
}

class CryptoExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # Set a day count variable for counting the days of the DCA trade.
        self.day_count = 0
        # Set the brokerage and account type to match your brokerage environment for accurate fee and margin behavior.
        self.set_brokerage_model(BrokerageName.BITFINEX, AccountType.CASH)
        # For daily DCA purchases, subscribe to daily asset data.
        self._symbol = self.add_crypto("BTCUSD", Resolution.DAILY, Market.BITFINEX).symbol

    def on_data(self, slice: Slice) -> None:
        # If you haven't invested for 30 consecutive days yet, continue buying.
        if self._symbol in slice.bars and self.day_count < 30:
            # Calculate the order size for $10,000 USD using the current price.
            size = 10000 / slice.bars[self._symbol].close
            self.market_order(self._symbol, size)
    
            # Increase the day count.
            self.day_count += 1

public class CryptoExampleAlgorithm : QCAlgorithm
{
    private Symbol _krakenBtc;
    private Symbol _coinbaseBtc;

    public override void Initialize()
    {
        // Subscribe to BTC/USD on 2 different exchanges.
        _krakenBtc = AddCrypto("BTCUSD", market: Market.Kraken).Symbol;
        _coinbaseBtc = AddCrypto("BTCUSD", market: Market.Coinbase).Symbol;
    }

    public override void OnData(Slice slice)
    {
        // Only calculate the spread if the prices on both exchanges are in the current Slice.
        if (slice.Bars.ContainsKey(_krakenBtc) && slice.Bars.ContainsKey(_coinbaseBtc))
        {
            // Calculate the spread between the 2 exchanges, making sure the comparison is always in the same direction.
            var spread = slice.Bars[_krakenBtc].Close - slice.Bars[_coinbaseBtc].Close;
            // Plot the spread between the 2 exchanges in a custom plot.
            Plot("BTC Close Spread", "Spread", spread);
        }
    }
}

class CryptoExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # Subscribe to BTC/USD on 2 different exchanges.
        self.kraken_btc = self.add_crypto("BTCUSD", market=Market.KRAKEN).symbol
        self.coinbase_btc = self.add_crypto("BTCUSD", market=Market.COINBASE).symbol

    def on_data(self, slice: Slice) -> None:
        # Only calculate the spread if the prices on both exchanges are in the current Slice.
        if self.kraken_btc in slice.bars and self.coinbase_btc in slice.bars:
            # Calculate the spread between the 2 exchanges, making sure the comparison is always in the same direction.
            spread = slice.bars[self.kraken_btc].close - slice.bars[self.coinbase_btc].close
            # Plot the spread between the 2 exchanges in a custom plot.
            self.plot("BTC Close Spread", "Spread", spread)