QuantConnect

US Equity Coarse Universe

Introduction

The US Equity Coarse Universe dataset by QuantConnect is a daily universe of all trading stocks in the US for a given day with the end of day price and volume. The data covers 30,000 US Equities in total, with approximately 8,000 Equities per day. The data starts in January 1998 and is delivered each trading day. This dataset is created by taking the closing auction price tick from the daily L1 trade and quote exchange dumps.

This dataset depends on the US Equity Security Master dataset because the US Equity Security Master dataset contains information on splits, dividends, and symbol changes.

QuantConnect/LEAN combines the data of this dataset with MorningStar Fundamental data in runtime. You can use this dataset in local development without the Morningstar counterpart.

For more information about the US Equity Coarse Universe dataset, including CLI commands and pricing, see the dataset listing.

About the Provider

QuantConnect was founded in 2012 to serve quants everywhere with the best possible algorithmic trading technology. Seeking to disrupt a notoriously closed-source industry, QuantConnect takes a radically open-source approach to algorithmic trading. Through the QuantConnect web platform, more than 50,000 quants are served every month.

Getting Started

The following snippet demonstrates how to request data from the US Equity Coarse Universe dataset:

  • Direct Access using the Security object
equity = self.AddEquity("IBM")
ibm_fundamental = equity.Fundamentals
var equity = AddEquity("IBM");
var ibmFundamental = equity.Fundamentals;
  • Direct Access using the Symbol object
ibm = Symbol.Create("IBM", SecurityType.Equity, Market.USA)
ibm_fundamental = self.Fundamentals(ibm)
var ibm = QuantConnect.Symbol.Create("IBM", SecurityType.Equity, Market.USA);
var ibmFundamental = Fundamentals(ibm);
  • Universe Selection
def Initialize(self) -> None:
    self.AddUniverse(self.FundamentalFilterFunction)

def FundamentalFilterFunction(self, fundamental: List[Fundamental]):
    sorted_by_dollar_volume = sorted([f for f in fundamental if f.Price > 10],
                                key=lambda f: f.DollarVolume)
    return [f.Symbol for f in sorted_by_dollar_volume[:10]]
public override void Initialize()
{
    AddUniverseSelection(new FundamentalUniverseSelectionModel(FundamentalFilterFunction));
}

public override List<Symbol> FundamentalFilterFunction(List<Fundamental> fundamental)
{
    return (from f in fundamental
            where f.Price > 10
            orderby f.DollarVolume
            select f.Symbol).Take(10);
}

Data Summary

The following table describes the dataset properties:

PropertyValue
Start DateJanuary 1998
Asset Coverage30,000 US Equities
Data DensityDense
ResolutionDaily
TimezoneNew York

Data Point Attributes

The US Equity Coarse Universe dataset provides its data within Fundamental objects, which have the following attributes:

Requesting Data

You don't need any special code to request US Coarse Fundamental Data. You can access the current and historical fundamental data for any of the US Equities that this dataset includes.

class CoarseFundamentalDataAlgorithm(QCAlgorithm):

    def Initialize(self) -> None:
        self.SetStartDate(2021, 1, 1)
        self.SetEndDate(2021, 7, 1)
        self.SetCash(100000) 

        # Option 1: Subscribe to individual US Equity assets
        self.AddEquity("IBM")        

        # Option 2A: Create a fundamental universe (classic version)
        self.AddUniverse(self.FundamentalFunction)

        # Option 2B: Create a fundamental universe (framework version)
        self.AddUniverseSelection(FundamentalUniverseSelectionModel(self.FundamentalFunction))
namespace QuantConnect
{
    public class CoarseFundamentalDataAlgorithm : QCAlgorithm
    {    	
        public override void Initialize()
        {
            SetStartDate(2021, 1, 1);
            SetEndDate(2021, 7, 1);
            SetCash(100000);
            
            // Option 1: Subscribe to individual US Equity assets
            AddEquity("IBM");

            // Option 2A: Create a fundamental universe (classic version)
            AddUniverse(FundamentalFilterFunction);

            // Option 2B: Create a fundamental universe (framework version)
            AddUniverseSelection(new FundamentalUniverseSelectionModel(FundamentalFilterFunction));
        }
    }
}

Accessing Data

If you add a fundamental universe to your algorithm, you can access fundamental data in the universe selection function.

def FundamentalFunction(self, fundamental: List[Fundamental]) -> List[Symbol]:
    sorted_by_dollar_volume = sorted(fundamental, key=lambda x: x.DollarVolume, reverse=True)[:3]
    for cf in sorted_by_dollar_volume:
        self.Debug(f"{cf.EndTime} :: {cf.Symbol} : {cf.AdjustedPrice} :: {cf.DollarVolume}")

    return [ x.Symbol for x in sortedByDollarVolume]
public IEnumerable<Symbol> FundamentalFunction(IEnumerable<Fundamental> fundamental)
{
    var sortedByDollarVolume = fundamental
        .OrderByDescending(x => x.DollarVolume)
        .Take(3).ToList();

    foreach (var cf in sortedByDollarVolume)
    {
        Debug($"{cf.EndTime} :: {cf.Symbol} : {cf.AdjustedPrice} :: {cf.DollarVolume}");
    }

    return sortedByDollarVolume.Select(x => x.Symbol);
}

To get fundamental data for Equities in your algorithm, use the Fundamentals property of the Equity objects. The fundamental data represent the corporate fundamentals for the current algorithm time.

fundamentals = self.Securities[symbol].Fundamentals
var fundamentals = Securities[symbol].Fundamentals;

To get fundamental data for Equities, regardless of whether or not you have subscribed to them in your algorithm, call the Fundamentals method. If you pass one Symbol, the method returns a Fundamental object. If you pass a list of Symbol objects, the method returns a list of Fundamental objects.

// Single asset 
var ibm = QuantConnect.Symbol.Create("IBM", SecurityType.Equity, Market.USA);
var ibmFundamental = Fundamentals(ibm);

// Multiple assets
var nb = QuantConnect.Symbol.Create("NB", SecurityType.Equity, Market.USA);
var fundamentals = Fundamentals(new List<Symbol>{ nb, ibm }).ToList();
# Single asset
ibm = Symbol.Create("IBM", SecurityType.Equity, Market.USA)
ibm_fundamental = self.Fundamentals(ibm)

# Multiple assets
nb = Symbol.Create("NB", SecurityType.Equity, Market.USA)
fundamentals = self.Fundamentals([ nb, ibm ])

Historical Data

You can get historical fundamental data in an algorithm and in the Research Environment.

Historical Data in Algorithms

To get historical fundamental data in an algorithm, call the History method with Fundamental type and the Equity Symbol. If there is no data in the period you request, the history result is empty.

var ibm = QuantConnect.Symbol.Create("IBM", SecurityType.Equity, Market.USA);

// Fundamental objects
var fundamentalHistory = History<Fundamental>(ibm, TimeSpan.FromDays(30));

// Fundamentals objects for all US Equities (including delisted companies)
var fundamentalsHistory = History<Fundamentals>(TimeSpan.FromDays(30));
ibm = Symbol.Create("IBM", SecurityType.Equity, Market.USA)

# DataFrame objects
df_history = qb.History(Fundamental, ibm, timedelta(30))

# Fundamental objects
fundamental_history= self.History[Fundamental](ibm, timedelta(30))

# Fundamentals objects for all US Equities (including delisted companies)
fundamentals_history = self.History[Fundamentals](timedelta(30))

For more information about historical US Equity fundamental data, see Equity Fundamental Data.

Example Applications

The US Equity Coarse Universe dataset enables you to accurately design a universe of US Equities. Examples include the following strategies:

  • Selecting securities with the largest dollar volume
  • Selecting securities within a specific price range
  • Selecting securities that have fundamental data available (together with MorningStar Fundamental data in Fundamental objects)

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: