Hide navigation sidebar
Hide table of contents sidebar
Back to top
Toggle table of contents sidebar

# Lumibot: Backtesting and Algorithmic Trading Library

An Easy to Use and Powerful Backtesting and Trading Library for Crypto, Stocks, Options, Futures and FOREX

Looking for a library that makes it easy for you to backtest your trading strategies and easily create algorithmic trading robots? Well you've found us!

Lumibot is a full featured, super fast library that will allow you to easily create trading robots that are profitable in many different asset classes, including Stocks, Options, Futures, FOREX, and more. It is in active development and is constantly being updated to include new features and bug fixes.

If you want to make a fortune with trading, then you need a library that will make it easy for you to check your trading strategies against historical data to make sure they are profitable before you invest in them. Lumibot makes it easy for you to do this (backtest) your trading strategies and easily convert them to algorithmic trading robots.

## Features

###### Works with Crypto, Options, Futures, Stocks, and FOREX!

We're one of the few libraries that supports Algorithmic Options trading and backtesting, as well as many other asset classes.

###### Built in Live Trading

It's very easy to switch between live trading and backtesting, just a few lines of code to go from backtesting to live trading.

###### Support For Top Brokers

We support many of the top brokers in the industry, including: Binance, Coinbase, Kucoin, Alpaca, Interactive Brokers and TradeStation. We will also support more brokers in the future.

###### Easy to Use and Get Started

We've built the library to be easy to use and get started in minutes. We also offer courses and tutorials to help you with building your own trading bot. (see our Algorithmic Trading course here)

###### Advanced Analyics Out of the Box

We've built a suite of advanced analytics tools that can be used to analyze and optimize your trading strategies, including interactive charts and more.

###### Event Based Backtesting

Our backtesting engine is event-based so that you can see your strategies run as if they were live trading. You don't have to deal with complicated and confusing vector math to see your strategies run.

## Getting Started

To get started with the library, first install it on your computer by typing this into your Terminal (on a Mac) or Powershell (on a Windows):
pip install lumibot

After you have installed Lumibot on your computer, you can then create a strategy and backtest it using free data available from Yahoo Finance, or use your own data (see the Backtesting section to get more details on this). Here’s some code to get you started:

    from datetime import datetime

    from lumibot.backtesting import YahooDataBacktesting
    from lumibot.strategies import Strategy

    # A simple strategy that buys AAPL on the first day and hold it
    class MyStrategy(Strategy):
        def on_trading_iteration(self):
            if self.first_iteration:
                aapl_price = self.get_last_price("AAPL")
                quantity = self.portfolio_value // aapl_price
                order = self.create_order("AAPL", quantity, "buy")
                self.submit_order(order)

    # Pick the dates that you want to start and end your backtest
    # and the allocated budget
    backtesting_start = datetime(2020, 11, 1)
    backtesting_end = datetime(2020, 12, 31)

    # Run the backtest
    MyStrategy.backtest(
        YahooDataBacktesting,
        backtesting_start,
        backtesting_end,
    )

Once you have backtested your strategy and found it to be profitable on historical data, you can then very easily take your bot live. Notice here how the strategy code is exactly the same, it only takes a few lines of code to switch from backtesting to live trading. Here’s an example using Alpaca (you can create a free Paper Trading account here in minutes: https://alpaca.markets/)

    from lumibot.backtesting import YahooDataBacktesting
    from lumibot.brokers import Alpaca
    from lumibot.strategies.strategy import Strategy
    from lumibot.traders import Trader

    ALPACA_CONFIG = {
         # Put your own Alpaca key here:
         "API_KEY": "YOUR_ALPACA_API_KEY",
         # Put your own Alpaca secret here:
         "API_SECRET": "YOUR_ALPACA_SECRET",
         # If you want to go live, you must change this. It is currently set for paper trading
         "ENDPOINT": "https://paper-api.alpaca.markets"
     }

    # A simple strategy that buys AAPL on the first day and hold it
    class MyStrategy(Strategy):
       def on_trading_iteration(self):
          if self.first_iteration:
                aapl_price = self.get_last_price("AAPL")
                quantity = self.portfolio_value // aapl_price
                order = self.create_order("AAPL", quantity, "buy")
                self.submit_order(order)

    trader = Trader()
    broker = Alpaca(ALPACA_CONFIG)
    strategy = MyStrategy(broker=broker)

    # Run the strategy live
    trader.add_strategy(strategy)
    trader.run_all()

And that’s it! Easy-peasy.

If you would like to learn how to modify your strategies we suggest that you first learn about Lifecycle Methods, then Strategy Methods and Strategy Properties. You can find the documentation for these in the menu, with the main pages describing what they are, then the sub-pages describing each method and property individually.

We also have some more sample code that you can check out here: https://github.com/Lumiwealth/lumibot/tree/dev/lumibot/example_strategies

We wish you good luck with your trading strategies, don’t forget us when you’re swimming in cash!

## Need Extra Help?

If you need some extra help building your stratgeies and making them profitable, then we also have courses that can help you out. We have taught thousands of students to create their own algorithms and have a library of profitable strategies that you get access to when you become a student.
See Our Algorithmic Trading Course Here
We also have a course that will teach you how to use Lumibot to Algorithmically trade Options, which can be very profitable but can be very difficult to learn. Our course makes this easy for you.
See Our Options Trading Course Here
Lastly, we also have a course that will teach you how to use Machine Learning (the backbone of Artificial Intelligence) to really make money. This can be difficult to learn, but it is very profitable when you get it working right.
See Our Machine Learning for Trading Course Here

## Table of Contents

- Home
- Community/Forum
- What is Lumibot?
- Getting Started
- Adding Trading Fees
- Profiling to Improve Performance
  - Viewing the Results
- Lifecycle Methods
  - Summary
  - def initialize
    - Reference
  - def on_trading_iteration
    - Reference
  - def before_market_opens
    - Reference
  - def before_starting_trading
    - Reference
  - def before_market_closes
    - Reference
  - def after_market_closes
    - Reference
  - def on_abrupt_closing
    - Reference
  - def on_bot_crash
    - Reference
  - def trace_stats
    - Reference
  - def on_new_order
    - Reference
  - def on_partially_filled_order
    - Reference
  - def on_filled_order
    - Reference
  - def on_canceled_order
    - Reference
  - def on_parameters_updated
    - Reference
- Strategy Methods
  - Order Management
    - self.create_order
    - self.submit_order
    - self.submit_orders
    - self.cancel_order
    - self.cancel_orders
    - self.cancel_open_orders
    - self.get_selling_order
    - self.sell_all
    - self.get_order
    - self.get_orders
    - self.get_asset_potential_total
  - Account Management
    - self.get_portfolio_value
    - self.get_cash
    - self.get_position
    - self.get_positions
  - Data
    - self.get_last_price
    - self.get_last_prices
    - self.get_historical_prices
    - self.get_historical_prices_for_assets
    - self.start_realtime_bars
    - self.get_realtime_bars
    - self.cancel_realtime_bars
    - self.get_yesterday_dividend
    - self.get_yesterday_dividends
  - Chart Functions
    - self.add_marker
    - self.add_line
    - self.get_markers_df
    - self.get_lines_df
  - Parameters
    - self.get_parameters
    - self.set_parameters
  - Options
    - self.get_chain
    - self.get_chains
    - self.get_greeks
    - self.get_strikes
    - self.get_expiration
    - self.get_multiplier
    - self.options_expiry_to_datetime_date
    - self.get_option_expiration_after_date
  - DateTime
    - self.get_datetime
    - self.get_timestamp
    - self.get_round_minute
    - self.get_last_minute
    - self.get_round_day
    - self.get_last_day
    - self.get_datetime_range
    - self.localize_datetime
    - self.to_default_timezone
  - Miscellaneous
    - self.log_message
    - self.sleep
    - self.set_market
    - self.update_parameters
    - self.get_parameters
    - self.await_market_to_close
    - self.await_market_to_open
    - self.wait_for_order_registration
    - self.wait_for_order_execution
    - self.wait_for_orders_registration
    - self.wait_for_orders_execution
- Strategy Properties
  - self.cash
    - `Strategy.cash`
  - self.portfolio_value
    - `Strategy.portfolio_value`
  - self.first_iteration
    - `Strategy.first_iteration`
  - self.is_backtesting
    - `Strategy.is_backtesting`
  - self.quote_asset
    - `Strategy.quote_asset`
  - self.name
    - `Strategy.name`
  - self.initial_budget
    - `Strategy.initial_budget`
  - self.minutes_before_closing
    - `Strategy.minutes_before_closing`
  - self.minutes_before_opening
    - `Strategy.minutes_before_opening`
  - self.sleeptime
    - `Strategy.sleeptime`
  - self.last_on_trading_iteration_datetime
    - `Strategy.last_on_trading_iteration_datetime`
  - self.timezone
    - `Strategy.timezone`
  - self.pytz
    - `Strategy.pytz`
  - self.unspent_money
    - `Strategy.unspent_money`
- Backtesting
  - All Backtesting
    - `backtest()`
  - Yahoo
  - Pandas (CSV or other data)
    - In Summary
  - Polygon.io Backtesting
- Brokers
  - Alpaca
    - Documentation
  - Interactive Brokers
  - Crypto Brokers (Using CCXT)
    - Configuration Settings
    - Running Your Strategy
    - Full Example Strategy
- Entities
  - Asset
    - Documentation
  - Bars
    - Documentation
  - Data
    - `Data`
  - Order
    - Advanced Order Types
    - Order With Legs
    - Documentation
  - Position
    - `Position`
  - Trading Fee
    - `TradingFee`

# Indices and tables

- Index

- Module Index

- Search Page