Recently, automatic trading systems in the stock market have attracted attention among many investors.
In particular, Python has established itself as a suitable language for financial data processing and
automatic trading system development due to its simplicity and powerful libraries. In this article, we will
explore how to develop an automatic trading system using the Kiwoom Securities API and
how to utilize PyQt for building a user interface.
1. Self Diagnosis: Why Use an Automatic Trading System?
An automatic trading system allows trading to be executed automatically based on predefined algorithms,
free from human emotions and momentary judgments. This increases the possibility of maximizing profits
by maintaining consistency in trading and optimizing trading time.
2. Overview of Kiwoom Securities API
The Kiwoom Securities API is a tool provided by Kiwoom Securities that helps to perform trading programmatically.
Through this API, users can access real-time stock data, create orders, and manage trading history.
2.1. Installing Kiwoom API
To use the Kiwoom API, you must first install Kiwoom Securities’ Open API+. After installation, you can set up
the API through the following steps.
1. Download 'Open API+' from the Kiwoom Securities homepage. 2. After installation, run 'OPKorea_1.2.0.exe' in the 'Kiwoom Securities Open API' folder. 3. Enter the API key and password to authenticate. 4. Check if the API is functioning properly.
2.2. Key Features of Kiwoom API
- Stock Search
- Real-Time Price Inquiry
- Order and Trade Execution
- Transaction History Inquiry
- Portfolio Management
3. Integrating Python with Kiwoom Securities API
To integrate the Kiwoom Securities API using Python, you can use a GUI framework like PyQt5.
Let’s look at example code using the Kiwoom API and PyQt5.
3.1. Installing PyQt5
pip install PyQt5 pip install PyQt5-tools
3.2. Implementing Login via Kiwoom API
Below is the basic code for logging into the Kiwoom Securities API.
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton
from PyQt5.QtCore import pyqtSlot
import win32com.client
class Kiwoom(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Kiwoom Securities Automatic Trading System")
self.setGeometry(300, 300, 400, 300)
self.login_button = QPushButton("Login", self)
self.login_button.clicked.connect(self.login)
self.login_button.resize(100, 40)
self.login_button.move(150, 130)
self.kiwoom = win32com.client.Dispatch("KHOpenAPI.KHOpenAPICtrl.1")
@pyqtSlot()
def login(self):
self.kiwoom.CommConnect()
if __name__ == "__main__":
app = QApplication(sys.argv)
kiwoom = Kiwoom()
kiwoom.show()
sys.exit(app.exec_())
4. Real-Time Stock Data Inquiry
Now, after adding the login feature, let’s add the real-time data inquiry functionality.
To access real-time prices, we need to write a function for data requests.
class Kiwoom(QMainWindow):
# ... Previous code omitted ...
def retrieve_stock_data(self, stock_code):
self.kiwoom.SetInputValue("종목코드", stock_code)
self.kiwoom.CommRqData("Basic Stock Information", "opt10001", 0, "0101")
def OnReceiveTrData(self, scrno, rqname, trcode, recordname, prevnext,
dataLength, errorCode, message, splm):
print("Data Received")
self.current_price = self.kiwoom.GetCommData(trcode, rqname, 0, "Current Price")
print(f"Current Price: {self.current_price.strip()}")
4.1. Adding Real-Time Data Reception Functionality
We added the `OnReceiveTrData` method to the basic code above.
In this method, we will implement the logic for processing the received data.
5. Implementing Order Functionality
Now, let’s add a simple order functionality.
Let’s look at a code example for handling buy and sell orders.
def buy_stock(self, stock_code, quantity):
self.kiwoom.SetInputValue("Stock Code", stock_code)
self.kiwoom.SetInputValue("Order Quantity", quantity)
self.kiwoom.SetInputValue("Price", 0) # Market Price
self.kiwoom.SetInputValue("Order Type", 1) # Buy
self.kiwoom.CommRqData("Stock Order", "opt00001", 0, "0101")
def sell_stock(self, stock_code, quantity):
self.kiwoom.SetInputValue("Stock Code", stock_code)
self.kiwoom.SetInputValue("Order Quantity", quantity)
self.kiwoom.SetInputValue("Price", 0) # Market Price
self.kiwoom.SetInputValue("Order Type", 2) # Sell
self.kiwoom.CommRqData("Stock Order", "opt00001", 0, "0101")
6. Optimizing GUI Design
You can design a more intuitive and user-friendly GUI using PyQt5.
By using various widgets, user experience can be enhanced.
self.quantity_input = QLineEdit(self)
self.quantity_input.move(150, 50)
self.quantity_input.resize(100, 30)
self.stock_code_input = QLineEdit(self)
self.stock_code_input.move(150, 90)
self.stock_code_input.resize(100, 30)
self.buy_button = QPushButton("Buy", self)
self.buy_button.move(150, 130)
self.buy_button.clicked.connect(self.on_buy_click)
6.1. Handling Click Events for the Order Button
def on_buy_click(self):
stock_code = self.stock_code_input.text()
quantity = int(self.quantity_input.text())
self.buy_stock(stock_code, quantity)
7. Developing an Automatic Trading Algorithm
Now, let’s implement the core algorithm of automatic trading.
A simple strategy to consider is the moving average crossover strategy.
def moving_average_strategy(self):
short_window = 5
long_window = 20
prices = self.get_past_prices(stock_code)
short_ma = prices[-short_window:].mean()
long_ma = prices[-long_window:].mean()
if short_ma > long_ma:
self.buy_stock(stock_code, 1)
elif short_ma < long_ma:
self.sell_stock(stock_code, 1)
7.1. Getting Historical Price Data
def get_past_prices(self, stock_code):
# Implement the method to retrieve historical price data
pass
8. Termination and Continuous Trading
When managing assets, it is very important to monitor trading history after orders are executed and
take necessary actions. After a trade is completed, the process of updating the portfolio is necessary.
def update_portfolio(self):
# Implement the method to update portfolio status
pass
Conclusion
In this article, we explored how to implement a simple automatic trading system using the
Kiwoom Securities API with Python. By adding a user interface through PyQt, we were able to
create a more intuitive and user-friendly system. Next, it is recommended to build upon this
foundation by adding more complex and diverse algorithms to create a personalized automatic trading system.