In This Page

Introduction

About the Provider

Getting Started

Data Summary

Universe Selection

Requesting Data

Accessing Data

Historical Data

Remove Subscriptions

Example Applications

Data Point Attributes

EOD Historical Data

Upcoming Dividends

Introduction

The Upcoming Dividends dataset, provided by EODHD, offers daily alerts for US Equities that will have a dividend event within the upcoming 7 days. The data starts in January 2015 and is delivered on a daily frequency.

Compared to US Equity Security Master as a benchmark, the Upcoming Dividends dataset has a 98.56% coverage of all dividend events, while having a 99.71% precision on the exact dividend dates of the covered ones and a 99.90% precision within +/- 3 days.

For more information about the Upcoming Dividends dataset, including CLI commands and pricing, see the dataset listing.

About the Provider

EOD Historical Data (EODHD) is a financial data provider based in France, and founded in April 2015. They focus on providing clean financial data, including stock prices, splits, dividends, fundamentals, macroeconomic indicators, technical indicators, and alternative data sources, through 24/7 API seamlessly. For more information about EODHD, visit https://eodhd.com/.

Getting Started

The following snippet demonstrates how to request data from the Upcoming Dividends dataset:

Select Language:

self.add_data(EODHDUpcomingDividends, "dividends")
self.add_universe(EODHDUpcomingDividends, self.selection_function)

using QuantConnect.DataSource;
AddUniverse<EODHDUpcomingDividends>(SelectionFunction);
AddData<EODHDUpcomingDividends>("dividends");

Data Summary

The following table describes the dataset properties:

Property	Value
Start Date	January 2015
Data Density	Sparse
Resolution	Daily
Timezone	New York

Universe Selection

To select a dynamic universe of US Equities based on the Upcoming Dividends dataset, call the AddUniverseadd_universe method with a EODHDUpcomingDividends cast.

Select Language:

def initialize(self) -> None:
    self._universe = self.add_universe(EODHDUpcomingDividends, self.universe_selection_filter)

def universe_selection_filter(self, dividends: List[EODHDUpcomingDividends]) -> List[Symbol]:
    return [d.symbol for d in dividends if d.dividend_date <= self.time + timedelta(1) and d.dividend > 0.05]

public override void Initialize()
{
    _universe = AddUniverse<EODHDUpcomingDividends>(UniverseSelectionFilter);
}

private IEnumerable<Symol> UniverseSelectionFilter(IEnumerable<BaseData> dividends)
{
    return from EODHDUpcomingDividends d in dividends
           where d.DividendsDate <= Time.AddDays(1) && d.Dividends > 0.05m
           select d.Symbol;
}

For more information about universe settings, see Settings.

Requesting Data

To add Upcoming Dividends data to your algorithm, call the AddData<EODHDUpcomingDividends>add_data method.

Select Language:

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

        self._symbol = self.add_equity("AAPL", Resolution.DAILY).symbol
        self.dataset_symbol = self.add_data(EODHDUpcomingDividends, "dividends").symbol

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

        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2020, 6, 1);
            SetCash(100000);
            _symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
            _datasetSymbol = AddData<EODHDUpcomingDividends>("dividends").Symbol;
        }
    }
}

Accessing Data

To get the current Upcoming Dividends data, call the Get<EODHDUpcomingDividends>get(EODHDUpcomingDividends) method from the current Slice and index the result with the security Symbol. Slice objects deliver unique events to your algorithm as they happen, but the Slice may not contain data for your security at every time step. To avoid issues, check if the Slice contains the data you want before you index it.

Select Language:

def on_data(self, slice: Slice) -> None:
    upcomings_dividends = slice.get(EODHDUpcomingDividends)
    if upcomings_dividends and self._symbol in upcomings_dividends:
        upcomings_dividends_data_point = upcomings_dividends[self._symbol]
        self.log(f"{self._symbol} will pay dividend at {upcomings_dividends_data_point.dividend_date} with dividend per share of ${upcomings_dividends_data_point.dividend}")

public override void OnData(Slice slice)
{
    var upcomingDividends = slice.Get<EODHDUpcomingDividends>();
    if (upcomingDividends.TryGetValue(_symbol, out var upcomingDividendsDataPoint))
    {
        Log($"{_symbol} will pay dividend at {upcomingDividendsDataPoint.DividendDate} with dividend per share of ${upcomingDividendsDataPoint.Dividend}");
    }
}

You can also iterate through all of the dataset objects in the current Slice

Select Language:

def on_data(self, slice: Slice) -> None:
    for equity_symbol, upcomings_dividends_data_point in slice.get(EODHDUpcomingDividends).items():
        self.log(f"{equity_symbol} will pay dividend at {upcomings_dividends_data_point.dividend_date} with dividend per share of ${upcomings_dividends_data_point.dividend}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Get<EODHDUpcomingDividends>())
    {
        var equitySymbol = kvp.Key;
        var upcomingDividendsDataPoint = kvp.Value;
        Log($"{equitySymbol} will pay dividend at {upcomingDividendsDataPoint.DividendDate} with dividend per share of ${upcomingDividendsDataPoint.Dividend}");
    }
}

Historical Data

To get historical Upcoming Dividends data, call the Historyhistory method with the type EODHDUpcomingDividends cast and the period of request. If there is no data in the period you request, the history result is empty.

Select Language:

history = self.history[EODHDUpcomingDividends](timedelta(100), Resolution.DAILY)

var history = History<EODHDUpcomingDividends>(TimeSpan.FromDays(100), Resolution.Daily);

For more information about historical data, see History Requests.

Remove Subscriptions

To remove a subscription, call the RemoveSecurityremove_security method.

Select Language:

self.remove_security(self.dataset_symbol)

RemoveSecurity(_datasetSymbol);

Example Applications

The Upcoming Dividends dataset allows traders to trade the price change due to dividends. Examples include the following strategies:

Short the stocks on dividend report day to earn the dividend discount on pricing.
Avoid volatility on securities with upcoming dividends

Classic Algorithm Example

The following example algorithm shorts each equity in equal size with an upcoming dividend by the next day. It selects stocks with dividend recording over $0.5 per share to capitalize on the price shock momentum due to dividend payment.

Select Language:

class UpcomingDividendsExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2024, 10, 1)
        self.set_cash(100000)

        # Trade on a daily basis based on daily upcoming dividend signals.
        self.universe_settings.resolution = Resolution.DAILY
        # Universe consists of equities with upcoming dividend events.
        self._universe = self.add_universe(EODHDUpcomingDividends, self.selection)
    
    def selection(self, dividends: List[EODHDUpcomingDividends]) -> List[Symbol]:
        # Select the stocks with upcoming dividend record date, with a sufficient dividend size.
        return [x.symbol for x in dividends if x.dividend_date < self.time + timedelta(1) and x.dividend > 0.5]
    
    def on_data(self, slice: Slice) -> None:
        # Equally invest in each member of the universe to evenly dissipate the capital risk.
        total_count = len(self._universe.selected)
        targets = [PortfolioTarget.percent(self, symbol, -1. / total_count) for symbol in self._universe.selected]
        self.set_holdings(targets, liquidate_existing_holdings=True)

namespace QuantConnect
{
    public class UpcomingDividendsExampleAlgorithm : QCAlgorithm
    {
        private Universe _universe;

        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2024, 10, 1);
            SetCash(100000);

            // Trade on daily basis based on daily upcoming dividend signals.
            UniverseSettings.Resolution = Resolution.Daily;
            // Universe consists of equities with upcoming dividend events.
            _universe = AddUniverse<EODHDUpcomingDividends>((dividends) => {
                // Select the stocks with upcoming dividend record date, with a sufficient dividend size.
                return from EODHDUpcomingDividends d in dividends
                       where d.DividendDate < Time.AddDays(1) && d.Dividend > 0.5
                       select d.Symbol;
            });
        }

        public override void OnData(Slice slice)
        {
            // Equally invest in each member of the universe to evenly dissipate the capital risk.
            var totalCount = _universe.Members.Count;
            var targets = _universe.Selected
                .Select(symbol => (PortfolioTarget)PortfolioTarget.Percent(this, symbol, -1m / totalCount))
                .ToList();
            SetHoldings(targets, liquidateExistingHoldings=True);
        }
    }
}

Framework Algorithm Example

The following example implements a strategy of shorting each equity in equal size with an upcoming dividend by the next day using the framework. It selects stocks with dividend recording over $0.5 per share to capitalize on the price shock momentum due to dividend payment.

Select Language:

class UpcomingDividendsExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2024, 10, 1)
        self.set_cash(100000)

        # Trade on a daily basis based on upcoming dividend signals daily.
        self.universe_settings.resolution = Resolution.DAILY
        # Universe consists of equities with upcoming dividend events.
        self._universe = self.add_universe(EODHDUpcomingDividends, self.selection)

        # A constant alpha model will emit insights for the stocks with dividend events in the upcoming day.
        # It is expecting a price shock due to pricing after the dividend, which might affect some momentum traders.
        self.add_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.DOWN, timedelta(1)))

        # Equal weighting for each signal to dissipate the capital risk evenly.
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel(Expiry.END_OF_DAY))
    
    def selection(self, splits: List[EODHDUpcomingDividends]) -> List[Symbol]:
        # Select the stocks with upcoming dividend record dates with a sufficient dividend size.
        return [x.symbol for x in dividends if x.dividend_date < self.time + timedelta(1) and x.dividend > 0.5]

namespace QuantConnect
{
    public class UpcomingDividendsExampleAlgorithm : QCAlgorithm
    {
        private Universe _universe;

        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2024, 10, 1);
            SetCash(100000);

            // Trade on a daily basis based on upcoming dividend signals daily.
            UniverseSettings.Resolution = Resolution.Daily;
            // Universe consists of equities with upcoming dividend events.
            _universe = AddUniverse<EODHDUpcomingDividends>((dividends) => {
                // Select the stocks with upcoming dividend record dates with a sufficient dividend size.
                return from EODHDUpcomingDividends d in dividends
                       where d.DividendDate < Time.AddDays(1) && d.Dividend > 0.5
                       select d.Symbol;
            });

            // A constant alpha model will emit insights for the stocks with dividend events in the upcoming day.
            // It is expecting a price shock due to pricing after the dividend, which might affect some momentum traders.
            AddAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Down, TimeSpan.FromDays(1)));

            // Equal weighting for each signal to dissipate the capital risk evenly.
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(Expiry.EndOfDay));
        }
    }
}

Data Point Attributes

The EODHD Upcoming Dividends dataset provides EODHDUpcomingDividends objects, which have the following attributes:

You can also see our Videos. You can also get in touch with us via Discord.

Did you find this page helpful?

Contribute to the documentation:

SIGN IN

Browse

Cloud Platform

Writing Algorithms

▶Key Concepts

Initialization

▶Securities

▶Portfolio

▶Universes

▶Datasets

▶Importing Data

▶Consolidating Data

▶Historical Data

▶Trading and Orders

▶Reality Modeling

Scheduled Events

▶Indicators

Object Store

▶Optimization

▶Machine Learning

▶Algorithm Framework

Charting

Logging

▶Statistics

▶Live Trading

Strategy Library

API Reference

▶Migrations

Research Environment

Local Platform

LEAN CLI

LEAN Engine

Hello

EOD Historical Data

Upcoming Dividends

Introduction

About the Provider

Getting Started

Data Summary

Universe Selection

Requesting Data

Accessing Data

Historical Data

Remove Subscriptions

Example Applications

Classic Algorithm Example

Framework Algorithm Example

Data Point Attributes

▶
Key Concepts

▶
Securities

▶
Portfolio

▶
Universes

▶
Datasets

▶
Importing Data

▶
Consolidating Data

▶
Historical Data

▶
Trading and Orders

▶
Reality Modeling

▶
Indicators

▶
Optimization

▶
Machine Learning

▶
Algorithm Framework

▶
Statistics

▶
Live Trading

▶
Migrations