Introduction to Automated Trading

Hi, I’m excited to share my journey with you on how I’ve managed to automate my trading strategy using Python. This means I’ve built a free trading bot that can autonomously execute trades on my behalf, adhering to a specific strategy I’ve programmed into it. The code for this trading bot is available for download here, so feel free to follow along now and grab the file later for your use. What I’m demonstrating today applies to any strategy that you can encapsulate within a Python function. This could arguably be the most effective method to test any strategy in real-time market conditions, beyond mere backtesting on historical data. If you’re keen on seeing how your strategy performs with future or live data, everything I’m showing you here could be pivotal.

Setting Up Our Environment

Let’s kick things off by focusing on our Jupyter notebook file. Initially, I’m downloading some historical data. Although this data isn’t intended for live trading with our trading bot, it’s crucial for testing whether our function or signals are functioning correctly. It’s a step to ensure our signal functions are operational. I’m sourcing this data from the YFinance module, selecting the Euro/US Dollar exchange data for a specified period, using a 15-minute timeframe. A point of caution here: when attempting to download data for short intervals like the 15-minute one, Yahoo Finance restricts us to the last 60 days. It means we can’t download more than 60 days of data at once, and it must be the most recent 60 days from the current date. If you encounter issues with the file not working, double-check these dates.

Testing Our Downloaded Data

Now that we’ve secured our data, it’s time to test what we’ve downloaded. I’ll briefly comment out these two lines to highlight the downloaded row. Removing this limitation gives us the entire dataframe, which, in our case, contains around 3,973 rows. This dataframe includes datetime, open, high, low, close, and adjusted close prices. Volumes aren’t provided in this dataframe, but that’s not an issue for our current purpose with the trading bot.

Defining Your Signal Generator

Moving on, the next phase is to define our signal generator. It’s essentially a function where we feed the current dataframe. As we stream live data for our trading bot, we’ll acquire a dataframe that this function will analyze, returning a signal — be it a buy, sell, or no clear pattern. In this example, my trading bot is tuned to detect only engulfing patterns among candles. Though this is a simplistic strategy, it’s merely to demonstrate the process. Should you wish to craft a comprehensive strategy, this function is where you’d embed your signal generator strategy. For instance, this function scrutinizes the open and close prices of the current and previous candles, testing for engulfing patterns to determine if a bearish or bullish signal should be issued by the trading bot.

Implementing the Signal Test

To verify the functionality of this signal generator, I’ve set up a test. Initially, I create a list named ‘signal’ and append a zero, indicating no initial signal. Following this, I iterate over every row of the dataframe, applying our signal generator function to the last two rows to ensure we’re analyzing the correct dataset. Depending on the function’s return, I append the result to my signal list. This list is then added as a new column to our testing dataframe, allowing us to visually confirm the presence of signals. Despite the simplicity of this test and its lack of a complex strategy, it’s crucial for ensuring our trading bot operates correctly.

Connecting to the Market and Executing Trades

Now, the exciting part: connecting to the market to execute trades with our trading bot. Before delving into strategy automation, it’s imperative to confirm that your broker supports API connections and provides ample documentation for connecting via Python. While Oanda is the broker I’ve used — owing to my existing account and its compatibility with my objectives — this is not an endorsement. You’re encouraged to explore various brokers and their documentation. The process I’ll show, using Oanda, involves importing necessary libraries and setting up an account, possibly a demo account for experimentation. After account setup, you’ll generate an access token, which I’ve stored in a config file for security. This setup phase is critical for ensuring a smooth operation of our trading bot as we proceed to live trading.

Acquiring Market Data

Our initial function, ‘get_candles’, is designed to fetch live market data, specifically the last ’n’ candles, crucial for our trading bot’s operation. By employing the candle client from Oanda and setting parameters like the currency pair and timeframe, we retrieve this data. This step involves careful consideration of the data’s structure, ensuring we have accurate open, high, low, and close prices for each candle. Testing this function allows us to confirm its efficacy, laying a solid foundation for our trading bot’s decision-making process.

The Trading Job Function

Within the trading job function, we amalgamate our efforts, fetching the latest candles from the market and analyzing them for engulfing patterns. This function constructs a dataframe from the candle data, which is then passed to our signal generator. Based on the signals returned, we determine whether to initiate buy or sell orders. Setting appropriate stop loss and take profit values is crucial here, as they dictate the risk and reward parameters for our trades. This part of the code also involves interfacing with the broker’s API to execute trades based on the signals generated by our trading bot.

Automating and Scheduling Trades

Finally, the culmination of our efforts is the automation of the trading process. By scheduling the trading job function, we ensure our trading bot operates continuously, analyzing market data and executing trades according to the defined strategy. This scheduling is flexible, allowing for adjustments based on the chosen timeframe and trading hours. It’s a powerful feature that enables our trading bot to operate autonomously, potentially allowing for multiple orders in parallel and adapting to market conditions in real time.

Conclusion and Next Steps

In wrapping up, I’ve shown you the steps to build and test a trading bot using Python, from downloading historical data to defining signal generators and executing trades based on live market data. This journey through automating a trading strategy highlights the potential of Python and API integration for engaging with financial markets. Remember, the strategies and configurations I’ve shared are starting points. I encourage you to explore, experiment, and refine your trading bot to suit your trading goals and risk tolerance. If you found this information helpful, please support by commenting, liking, and subscribing. Until our next article, trade safely, and see you next time with your trading bot humming along.