Automated Trade Setup using Tradingview, AWS and Broker API

Motivation:

Emotion plays a very import part in every traders life. Most of the times we get attached to trades which leads to huge losses as we just cant let go of a trade thinking or believing that we cant be wrong.

So the best way to trade is develop a system and automate each trade such that there are no human emotions involved.

Concept:

Below are the required tools and how they are used:

Tradingview : For charting and signal generation using Pinescript[pinescript logic not covered here and there are lot of tutorials for same]. Please note that pro subscription is required for sending webhook requests from tradingview.

AWS/ cloud hosting provider : This is the main component where trading decisions happen and trades are send for execution. Chalice is a good option to test locally before deploying on AWS and it also helps with AWS deployment. It also provides a single API end point which can be configured in tradingview as webhook url. (ngrok can be used to test locally before deploying on AWS as a public endpoint is required to get triggers from tradingview)

Broker API: Zerodha(kitetrade) is taken as an example as it seems to be the most widely used and has a rich user community.

Telegram : The bot API is used as a real time messaging application to alert/update users regarding trades taken. There are lot of youtube videos how to create telegram bots and send automated messages.

Architecture:

Automated Trading Architecture

Flow:

1. Based on some technical Indicator Tradingview generates alert/signal and calls API hosted at AWS and POSTs JSON data.

2. Python script parses the JSON to determine type of trade with respect to buy/sell, symbol and qty.

3. Based on the trade type, checks are done with respect to API Keys/Margin/Risk/instrument symbol(in case of options) at AWS by the same python script.

4. Next Brokers order API is called for order placement.

5. Broker responds via web-hook url for order execution status.

Configurations and Codes:

Tradingview Configuration:

• update the AWS API url and json in the message section in the alert manager of tradingview

# tradingview message JSON format
{
    "price": {{strategy.order.price}},  # Price at which triggered
    "strategy" : "Your strategy_name",  # Your defined name
    "prev_position_size": "{{strategy.prev_market_position_size}}",
    "current_position_size": "{{strategy.market_position_size}}",
    "symbol": "{{ticker}}",  # Symbol triggered for
    "type": "{{strategy.order.action}}",   # buy/Sell(long/Short)
    "quantity": {{strategy.order.contracts}}, # Qty
    "trade_time": "{{timenow}}",
    "prev_position": "{{strategy.prev_market_position}}"
}

more details for pinescript can be found here, strategy alerts and variables.

Python code at AWS:

zerodha api documentation for python can be found here and more details for API here

from chalice import Chalice
import json, datetime, requests
import urllib3
from kiteconnect import KiteConnect
from telegram_message import send_message
import math
urllib3.disable_warnings()
# GET API authentication Details
token_file = open('token.txt', 'r')
access_token = token_file.read()
api_token = "token <your_api_key>:" + str(access_token)
headers = {"X-Kite-Version": "3", "Authorization": api_token}
kite = KiteConnect(api_key=<your_api_key>)
try:
    kite.set_access_token(access_token)
except Exception as e:
    print("Error while setting access token", str(e))
def place_equity_order(stock_name, txn_type, qty, tag, trade_price):
    # Place order
    try:
        order_id = kite.place_order(tradingsymbol=stock_name,
                                    exchange=kite.EXCHANGE_NSE,
                                    transaction_type=txn_type,
                                    quantity=int(qty),
                                    order_type=kite.ORDER_TYPE_LIMIT,
                                    price=trade_price,
                                    product=kite.PRODUCT_MIS,
                                    variety=kite.VARIETY_REGULAR)
        print("Success creating %s position for %s with order id %s \n" % (txn_type, stock_name, str(order_id)))
        return(order_id)
except Exception as e:
        print("Error taking position for %s due to error %s \n" % (stock_name, e))
@app.route('/equity/order', methods=['POST']) # This will be appended to the AWS API end point
def trigger_equity():
    # This Function will place order for equity
    webhook_message = app.current_request.json_body
    # Extract Values from WebHook Request
    stock_name = webhook_message['symbol']
    txn_type = webhook_message['type']
    prev_position = webhook_message['prev_position']
    if txn_type == "buy" or prev_position == "short":
        txn_type2 = kite.TRANSACTION_TYPE_BUY
    elif txn_type == "sell" or prev_position == "long":
        txn_type2 = kite.TRANSACTION_TYPE_SELL
    qty = webhook_message['quantity']
    trade_price = webhook_message['price']
    trade_time = datetime.datetime.now()
    tag = webhook_message['strategy']
place_order = place_equity_order(stock_name, txn_type2, qty,tag,trade_price)
telegram_msg = stock_name + " " + txn_type + " " + str(trade_price) + " placed via order_id : " + str(place_order)
    send_message(telegram_msg)

Telegram Integration code:

There are lots of youtube videos on how to create Telegram bots and get the required details like API_key, chat_id etc. Once that is obtained sending msg can be accomplished using below few lines of code in python.

# Telegram BOT for sending message
import requests
def send_message(msg):
    url = 'https://api.telegram.org/<your_bot>:<bot_api_key>/sendMessage?chat_id=<chat_id>&text='+str(msg)
    r = requests.get(url)

Notes: This article is meant for educational purpose only.