Getting data with Free plan

I’ll show you two Free-plan workflows that don’t use the LEAN CLI:

• Cloud backtest exporter: a tiny algorithm that pulls Hourly/Daily history in the QuantConnect Cloud and writes it to CSV files in your project’s output folder for download.
• Research notebook: a QuantBook snippet that fetches history and saves CSVs.

Per QuantConnect docs, you can request Hourly/Daily history in the cloud, while using the LEAN CLI with QuantConnect datasets requires being on a paid tier. I’ll include ready-to-run code for both workflows next. citeturn0search1turn0search0turn0search3

Now I’ll generate the code.You’re right: with the Free plan you can access Hourly and Daily history in the QuantConnect Cloud, but the LEAN CLI with QuantConnect datasets requires a paid tier. That means you should pull the data in the Cloud (Backtests or Research) and then download the CSVs, rather than via the CLI on Free.

Two easy Free-plan workflows

1) Cloud backtest “exporter” (no CLI)

• What you do: Run a tiny algorithm in the Cloud that requests Hourly/Daily history and writes one CSV per symbol to your project’s output folder.
• How to download: After the backtest finishes, open Project panel > output > right-click the CSV(s) > Download.

2) Cloud Research notebook

• What you do: In a QuantBook notebook, request history and save CSVs to the same output folder.
• How to download: Same as above.

I’ve generated ready-to-run code for both options below.

Cloud backtest exporter (Python) Copy this into a new Cloud project’s main.py and Run Backtest. It will export CSV(s) to output/ and quit immediately.

from AlgorithmImports import * class ExportHistoryAlgorithm(QCAlgorithm): """ Exports Hourly or Daily historical bars for a list of tickers to CSV files in the project's output/ folder. No trading logic — it fetches data in Initialize() and quits. """

def initialize(self) -> None:
    # ================== User settings (edit these) ==================
    # Tickers to export. You can add/remove tickers here.
    self._tickers: List[str] = ["SPY", "QQQ", "AAPL"]

    # Target bar resolution: choose Resolution.HOUR or Resolution.DAILY.
    self._target_resolution: Resolution = Resolution.HOUR

    # History window to export. Change these dates as needed.
    # Align the algorithm's backtest range to the same window so the
    # History() request can access the entire period.
    self.set_start_date(2015, 1, 1)
    self.set_end_date(2025, 10, 24)
    self._history_start_date: datetime = self.start_date
    self._history_end_date: datetime = self.end_date

    # Include pre/post-market data for equities (True) or only regular hours (False).
    self._extended_market_hours: bool = False

    # Data normalization for equities: Adjusted by default. To export raw prices,
    # set to DataNormalizationMode.RAW.
    self._normalization: DataNormalizationMode = DataNormalizationMode.ADJUSTED
    # ==================================================================

    # Add requested assets and store their Symbols.
    self._symbols: List[Symbol] = []
    for ticker in self._tickers:
        equity = self.add_equity(
            ticker,
            resolution=self._target_resolution,
            extended_market_hours=self._extended_market_hours,
        )
        symbol = equity.symbol
        # Set normalization mode per-security
        self.securities[symbol].set_data_normalization_mode(self._normalization)
        self._symbols.append(symbol)

    if len(self._symbols) == 0:
        self.log("No tickers provided. Nothing to export. Quitting.")
        self.quit()
        return

    # Request historical data for all symbols at once.
    # This returns a pandas MultiIndex DataFrame: index levels [symbol, time]
    # with columns like ['open','high','low','close','volume'].
    hist = self.history(
        self._symbols,
        self._history_start_date,
        self._history_end_date,
        self._target_resolution,
    )

    if hist is None or (hasattr(hist, "empty") and hist.empty):
        self.log(
            f"No historical data returned for window {self._history_start_date} -> {self._history_end_date} at {self._target_resolution}. Quitting."
        )
        self.quit()
        return

    # Ensure we only proceed if the history has the expected MultiIndex with a symbol level.
    index_names = list(hist.index.names) if hasattr(hist.index, "names") else []
    has_symbol_level = ("symbol" in index_names) or (0 < len(index_names))

    # Map resolution to a short suffix for filenames.
    res_suffix = "hour" if self._target_resolution == Resolution.HOUR else "daily"

    # Expected columns to write (keep order consistent)
    expected_cols = ["open", "high", "low", "close", "volume"]

    exported = 0
    for symbol in self._symbols:
        try:
            if has_symbol_level:
                # Slice the MultiIndex frame for this symbol
                sym_df = hist.xs(symbol, level=0, drop_level=True)
            else:
                # Fallback (in case a single DataFrame without symbol level is returned)
                sym_df = hist

            if sym_df is None or (hasattr(sym_df, "empty") and sym_df.empty):
                self.log(f"No data for {symbol.value} in the requested window. Skipping.")
                continue

            # Keep only desired columns that exist
            cols = [c for c in expected_cols if c in list(sym_df.columns)]
            if len(cols) == 0:
                self.log(f"{symbol.value}: No OHLCV columns present. Skipping.")
                continue

            # Sort by time just in case and write CSV to the output folder.
            sym_df = sym_df.sort_index()
            filepath = f"output/{symbol.value}_{res_suffix}.csv"
            # Include the index in the file with label "time"
            sym_df.to_csv(filepath, columns=cols, index_label="time")
            exported += 1
        except KeyError:
            self.log(f"{symbol.value}: No history slice found. Skipping.")
        except Exception as e:
            self.error(f"{symbol.value}: Failed to export due to error: {e}")

    if exported == 0:
        self.log("No CSV files were generated. Quitting.")
    else:
        self.log(
            f"Exported {exported} file(s) to the project's output/ folder."
        )

    # Where to download: In the Cloud IDE, open Project panel -> output -> right-click the file -> Download.
    # Time zone note: History timestamps are in the algorithm's time zone (America/New_York by default).
    # To convert to UTC if desired, load the CSV in pandas and localize/convert the index to UTC.
    # Switching asset class: To export crypto instead, replace AddEquity with AddCrypto (extended hours does not apply).

    # End immediately — this algorithm is for data export only.
    self.quit()

Cloud Research notebook snippet (Python) Run this in a new Research notebook cell; CSVs will appear in output/.

from AlgorithmImports import *

qb = QuantBook()

_tickers: list[str] = ["SPY", "QQQ", "AAPL"]

_resolution: Resolution = Resolution.HOUR

_start: datetime = datetime(2015, 1, 1) _end: datetime = datetime(2025, 10, 24)

_extended_market_hours: bool = False

_normalization: DataNormalizationMode = DataNormalizationMode.ADJUSTED

_symbols: list[Symbol] = [] for t in _tickers: try: equity = qb.add_equity(t, _resolution, extended_market_hours=_extended_market_hours) if equity is None: continue equity.set_data_normalization_mode(_normalization) _symbols.append(equity.symbol) except Exception as add_err: print(f"Skipping {t}: {add_err}")

if len(_symbols) == 0: raise Exception("No symbols were added. Check tickers and settings.")

hist = qb.history(_symbols, _start, _end, _resolution)

if hist is None or (hasattr(hist, "empty") and hist.empty): print(f"No history returned for {_symbols} from {_start} to {_end} at {_resolution}.") else:

# Decide filename suffix based on resolution
suffix = "hour" if _resolution == Resolution.HOUR else "daily"

# Ensure only required columns are kept
required_cols = ["open", "high", "low", "close", "volume"]

# Loop symbols and write one CSV per symbol
for sym in _symbols:
    try:
        df_sym = None

        # Handle typical MultiIndex (time, symbol) or (symbol, time)
        if isinstance(hist.index, pd.MultiIndex):
            index_names = list(hist.index.names) if hist.index.names is not None else []
            if "symbol" in index_names:
                # Slice by named level if available
                df_sym = hist.xs(sym, level="symbol", drop_level=True)
            else:
                # Try common positional slicing fallbacks
                idx = pd.IndexSlice
                try:
                    df_sym = hist.loc[idx[:, sym], :]
                    if isinstance(df_sym.index, pd.MultiIndex) and "symbol" in list(df_sym.index.names):
                        df_sym = df_sym.droplevel("symbol")
                except Exception:
                    try:
                        df_sym = hist.loc[idx[sym, :], :]
                        if isinstance(df_sym.index, pd.MultiIndex) and "symbol" in list(df_sym.index.names):
                            df_sym = df_sym.droplevel("symbol")
                    except Exception:
                        df_sym = pd.DataFrame()
        else:
            # Single-index fallback (e.g., if only one symbol returned)
            df_sym = hist.copy()

        if df_sym is None or df_sym.empty:
            print(f"{sym.value}: 0 rows (no data in requested range)")
            continue

        # Drop any lingering symbol column
        for c in ["symbol", "Symbol"]:
            if c in df_sym.columns:
                df_sym = df_sym.drop(columns=[c])

        # Ensure the datetime index name is 'time' for reset_index
        if df_sym.index.name is None or str(df_sym.index.name).lower() != "time":
            df_sym.index.name = "time"

        df_out = df_sym.reset_index()

        # Keep only the required OHLCV columns
        present_cols = [c for c in required_cols if c in list(df_out.columns)]
        # Ensure 'time' column exists and is first
        if "time" not in list(df_out.columns):
            df_out.insert(0, "time", pd.NaT)
        ordered_cols = ["time"] + present_cols
        df_out = df_out[ordered_cols]

        # Sort and de-duplicate on time just in case
        if "time" in list(df_out.columns):
            df_out = df_out.sort_values("time").drop_duplicates(subset=["time"])  # type: ignore

        # Write to CSV in the project's output folder
        file_path = f"output/{sym.value}_{suffix}.csv"
        df_out.to_csv(file_path, index=False, encoding="utf-8")

        print(f"{sym.value}: {len(df_out)} rows written -> {file_path}")
    except Exception as write_err:
        print(f"{sym.value}: error while processing - {write_err}")

print("Done. Download CSVs from the output/ folder in the Cloud IDE. Timestamps are in the algorithm time zone (America/New_York by default).")

Notes and gotchas

• History availability: In the Cloud, Daily and Hourly history is available broadly; minute/second/tick have shorter trailing windows. If you need more granular data, plan accordingly.
• Extended hours: For intraday (Hour), set extended_market_hours=True if you want pre/post. For Daily, extended hours doesn’t apply.
• Normalization: Adjusted is default (splits/dividends). Switch to Raw if you need unadjusted prices.
• Time zones: History timestamps are in the algorithm’s time zone (America/New_York by default). Convert to UTC later if needed.

If you must use the LEAN CLI on Free

• Bring your own local Lean-formatted data (instead of pulling QuantConnect data), or
• Upgrade to a paid tier to use the CLI with QuantConnect datasets.

If you tell me your tickers, dates, and whether you want Hourly or Daily, I can tailor the snippets to your exact request.

Sources: Getting Started - QuantConnect.com, US Index Options - QuantConnect.com, US Futures - QuantConnect.com, Rendering Data with Notebooks - QuantConnect.com, Empty Equity And Options400 Benchmark

Free data is only available in the cloud platform