Developing Python Automated Trading, Using Kiwoom Securities API, KOA Studio

Auto trading is a system that automatically executes trades in the financial market using algorithms. Python is preferred by many traders and developers because it is easy to process data and implement algorithms. This article will explain in detail how to develop an auto trading system using Kiwoom Securities’ API and KOA Studio with Python.

1. Introduction to Kiwoom Securities API

The Kiwoom Securities API is provided by Kiwoom Securities, allowing traders to implement their algorithms and collect market data in real-time. The Kiwoom Securities API offers the following features:

  • Real-time price inquiry
  • Order transmission and management
  • Account information inquiry
  • Transaction history inquiry

2. Introduction to KOA Studio

KOA Studio is an integrated development environment that allows the development of auto trading systems using Kiwoom Securities’ API. It provides a variety of features to help developers develop easily. The main features of KOA Studio are:

  • Visual user interface
  • Data visualization features
  • Contextual help provided
  • Code templates provided

3. Environment Setup

To develop an auto trading system, the environment must be set up in the following order:

3.1. Open a Kiwoom Securities Account

First, you need to open an account with Kiwoom Securities. Without a brokerage account, you cannot use the API, so please open an account on the official website.

3.2. Apply for API Access Approval

To use the API, you need to apply for API access approval from Kiwoom Securities. Once approved, you will receive an API key, which is required for authentication in the code.

3.3. Install KOA Studio

Download and install KOA Studio. Once the installation is complete, run the program to perform the initial setup.

4. Basic Code Structure

The basic code structure for an auto trading system is as follows:

import win32com.client
import time

class AutoTrader:
    def __init__(self):
        self.app = win32com.client.Dispatch('KHOPENAPI.KHOpenAPICtrl.1')
        self.app.CommConnect()
        time.sleep(1)

    def get_stock_price(self, code):
        price = self.app.CommGetData("OPTKWM", "조회", 0, 0, code)
        return price

    def buy_stock(self, code, quantity):
        order_result = self.app.SendOrder("Order01", "123456", code, quantity, 0, 0, 0, "")
        return order_result

    def sell_stock(self, code, quantity):
        order_result = self.app.SendOrder("Order01", "123456", code, -quantity, 0, 0, 0, "")
        return order_result

The above code provides basic functionality to retrieve the current price of stocks and to buy and sell stocks using the Kiwoom Securities API.

5. Data Collection and Analysis

To devise an auto trading strategy, it is necessary to collect and analyze market data. You can solidify your strategy by utilizing prices, trading volumes, and technical indicators.

5.1. Requesting Real-time Prices

The method for requesting real-time prices to utilize in trading strategies is as follows:

def request_realtime_quotes(self, code):
    self.app.SetInputValue("StockCode", code)
    self.app.CommRQData("RealTimeInquiry", "OPTKWM", 0, "0101")

The method above is necessary for querying real-time prices of a specific stock.

5.2. Calculating Technical Indicators

You can calculate technical indicators based on the collected data. For example, here is how to calculate the moving average (MA):

def calculate_moving_average(prices, period):
    return sum(prices[-period:]) / period

6. Implementing Auto Trading Strategy

Now let’s implement an auto trading strategy based on the collected data and analysis results. One example would be a simple moving average crossover strategy.

def trading_strategy(self):
    short_ma = calculate_moving_average(self.prices, short_period)
    long_ma = calculate_moving_average(self.prices, long_period)

    if short_ma > long_ma:
        self.buy_stock(self.current_stock_code, 1)
    elif short_ma < long_ma:
        self.sell_stock(self.current_stock_code, 1)

7. Backtesting

To validate the effectiveness of the strategy, backtesting based on historical data should be conducted. The pandas library is useful for data analysis. Here’s an example of backtesting:

import pandas as pd

def backtest_strategy(data, strategy):
    results = []
    for index, row in data.iterrows():
        result = strategy(row)
        results.append(result)
    return results

8. Conclusion

In this article, we explored the development of an auto trading system using Python. By utilizing the Kiwoom Securities API and KOA Studio, try to implement your own auto trading strategy. Through Python's powerful data processing capabilities and the Kiwoom Securities API, we hope you discover more opportunities and achieve successful trading.

9. Additional Resources

Additional materials and links for auto trading are as follows:

If you found this article helpful, please share it!