US Equity

When a company does a stock split, the number of shares each shareholder owns increases and the price of each share decreases. When a company does a reverse stock split, the number of shares each shareholder owns decreases and the price of each share increases. A company may perform a stock split or a reverse stock split to adjust the price of their stock so that more investors trade it and the liquidity increases.

When a stock split or reverse stock split occurs for an Equity in your algorithm, LEAN sends a Split object to the OnDataon_data method. You receive Split objects when a split is in the near future and when it occurs. To know if the split occurs in the near future or now, check the Typetype property.

If you backtest without the RawRAW data normalization mode, the splits are factored into the price and volume. If you backtest with the RawRAW data normalization mode or trade live, when a split occurs, LEAN automatically adjusts your positions based on the SplitFactorsplit_factor. If the post-split quantity isn't a valid lot size, LEAN credits the remaining value to your cashbook in your account currency. If you have indicators in your algorithm, reset and warm-up your indicators with ScaledRaw data when splits occur so that the data in your indicators account for the price adjustments that the splits cause.

To get the Split objects, index the Splitssplits object with the security Symbolsymbol. The Splitssplits object may not contain data for your Symbol. To avoid issues, check if the Splitssplits object contains data for your security before you index it with the security Symbol.

public override void OnData(Slice slice)
{
    if (slice.Splits.ContainsKey(_symbol))
    {
        var split = slice.Splits[_symbol];
    }
}

public override void OnSplits(Splits splits)
{
    if (splits.ContainsKey(_symbol))
    {
        var split = splits[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    split = slice.splits.get(self._symbol)
    if split:
        pass


def on_splits(self, splits: Splits) -> None:
    split = splits.get(self._symbol)
    if split:
        pass

You can also iterate through the Splitssplits dictionary. The keys of the dictionary are the Symbol objects and the values are the Split objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

public override void OnSplits(Splits splits)
{
    foreach (var kvp in splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, split in slice.splits.items():
        pass

def on_splits(self, splits: Splits) -> None:
    for symbol, split in splits.items():
        pass

To get historical splits, make a history request with the Split type.

var splits = History<Split>(symbol, TimeSpan.FromDays(4*365));

splits_df = self.history(Split, symbol, timedelta(4*365))
splits = self.history[Split](symbol, timedelta(4*365))

LEAN stores the data for stock splits in factor files. To view some example factor files, see the LEAN GitHub repository. In backtests, your algorithm receives Split objects at midnight. In live trading, your algorithm receives Split objects when the factor files are ready.

If you hold an Option contract for an underlying Equity when a split occurs, LEAN closes your Option contract position.

If a split event occurs before your order is filled, the unfilled portion of the order is adjusted automatically, where its quantity is multiplied by the split factor and the limit/stop/trigger price (if any) is divided by the split factor.

Split objects have the following properties:

A dividend is a payment that a company gives to shareholders to distribute profits. When a dividend payment occurs for an Equity in your algorithm, LEAN sends a Dividend object to the OnDataon_data method.

If you backtest with the AdjustedADJUSTED or TotalReturnTOTAL_RETURN data normalization mode, the dividends are factored into the price. If you backtest with the other data normalization modes or trade live, when a dividend payment occurs, LEAN automatically adds the payment amount to your cashbook. If you have indicators in your algorithm, reset and warm-up your indicators with ScaledRaw data when dividend payments occur so that the data in your indicators account for the price adjustments that the dividend causes.

To get the Dividend objects, index the Dividendsdividends object with the security Symbolsymbol. The Dividendsdividends object may not contain data for your Symbolsymbol. To avoid issues, check if the Dividendsdividends object contains data for your security before you index it with the security Symbolsymbol.

public override void OnData(Slice slice)
{
    if (slice.Dividends.ContainsKey(_symbol))
    {
        var dividend = slice.Dividends[_symbol];
    }
}

public override void OnDividends(Dividends dividends)
{
    if (dividends.ContainsKey(_symbol))
    {
        var dividend = dividends[_symbol];
    }
}

def on_data(self, slice: Slice) -> None:
    dividend = slice.dividends.get(self._symbol)
    if dividend:
        pass

def on_dividends(self, dividends: Dividends) -> None:
    dividend = dividends.get(self._symbol)
    if dividend:
        pass

You can also iterate through the Dividendsdividends dictionary. The keys of the dictionary are the Symbol objects and the values are the Dividend objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

public override void OnDividends(Dividends dividends)
{
    foreach (var kvp in dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, dividend in slice.dividends.items():
        pass

def on_dividends(self, dividends: Dividends) -> None:
    for symbol, dividend in dividends.items():
        pass

To get historical dividends, make a history request with the Dividend type.

var dividends = History<Dividend>(symbol, TimeSpan.FromDays(4*365));

dividends_df = self.history(Dividend, symbol, timedelta(4*365))
dividends = self.history[Split](Dividend, timedelta(4*365))

For a full example, see the DividendAlgorithmDividendAlgorithm in the LEAN GitHub repository.

Dividend objects have the following properties: