Automated Algo Implementation with Upstox API

The following guide and Python script fully automate your multi-timeframe momentum + volume + breakout strategy on Upstox. It covers environment setup, authentication, data retrieval, signal generation, order management, risk controls, logging, and deployment/testing.

1. Environment Setup

Create and activate a Python virtual environment:


bash
python3 -m venv quant_env
source quant_env/bin/activate

Install dependencies:


bash
pip install upstox-api pandas numpy schedule pytz

2. Upstox API Authentication


python
# upstox_auth.py
from upstox_api.api import Upstox, Session

API_KEY      = 'YOUR_API_KEY'
API_SECRET   = 'YOUR_API_SECRET'
REDIRECT_URI = 'https://yourapp.com/callback'

def authenticate():
    session = Session(API_KEY, API_SECRET)
    session.set_redirect_uri(REDIRECT_URI)
    login_url = session.get_login_url(redirect_uri=REDIRECT_URI, response_type='code')
    print("Login URL:", login_url)
    code = input("Enter the code from callback URL: ").strip()
    session.set_code(code)
    access_token = session.retrieve_access_token()
    return Upstox(API_KEY, access_token)

# Usage:
# from upstox_auth import authenticate
# u = authenticate()

3. Data Retrieval & Multi-Timeframe Aggregation


python
# data_utils.py
import pandas as pd
from upstox_api.api import LiveFeedType

def fetch_ohlc(u, symbol, from_date, to_date, interval='ONE_DAY'):
    inst = u.get_instrument_by_symbol('NSE_EQ', symbol)
    bars = u.get_ohlc(inst, interval, from_date, to_date)
    df = pd.DataFrame([{
        'datetime': b.timestamp, 'open': b.open, 'high': b.high,
        'low': b.low, 'close': b.close, 'volume': b.volume
    } for b in bars])
    df.set_index('datetime', inplace=True)
    return df

def aggregate_timeframes(df_daily):
    df = df_daily.copy()
    df['week']  = df.index.to_series().dt.to_period('W').apply(lambda r: r.start_time)
    df['month'] = df.index.to_series().dt.to_period('M').apply(lambda r: r.start_time)
    df['quarter'] = df.index.to_series().dt.to_period('Q').apply(lambda r: r.start_time)
    aggregations = {
        'open':'first','high':'max','low':'min','close':'last','volume':'sum'
    }
    df_wk  = df.groupby('week').agg(aggregations)
    df_mo  = df.groupby('month').agg(aggregations)
    df_qtr = df.groupby('quarter').agg(aggregations)
    return df_wk, df_mo, df_qtr

4. Signal Generation Logic


python
# signal_generator.py
import numpy as np

def multi_timeframe_strength(d_daily, d_wk, d_mo, d_qtr):
    latest = d_daily.iloc[-1]
    cond1 = (latest.close > latest.open and
             d_wk.close.iloc[-1] > d_wk.open.iloc[-1] and
             d_mo.close.iloc[-1] > d_mo.open.iloc[-1] and
             d_qtr.close.iloc[-1] > d_qtr.open.iloc[-1])
    return cond1

def ema_stack(df, spans):
    for span in spans:
        df[f'ema{span}'] = df.close.ewm(span=span, adjust=False).mean()
    # require ema5>ema20>ema50>ema200
    return (df.ema5.iloc[-1] > df.ema20.iloc[-1] >
            df.ema50.iloc[-1] > df.ema200.iloc[-1])

def breakout_and_volume(df_daily):
    latest = df_daily.iloc[-1]
    prev_high = df_daily.high.shift(1).iloc[-1]
    vol_ok = latest.volume > 100000
    price_ok = latest.close > prev_high
    return vol_ok and price_ok

def vsa_proxy(df_daily):
    latest = df_daily.iloc[-1]
    body = abs(latest.close - latest.open)
    rng  = latest.high - latest.low
    vol_spike = latest.volume > 1.8 * df_daily.volume[-30:].mean()
    return (body/rng > 0.8) and vol_spike

def generate_signal(u, symbol, start_date, end_date):
    df_daily = fetch_ohlc(u, symbol, start_date, end_date)
    df_wk, df_mo, df_qtr = aggregate_timeframes(df_daily)
    if not multi_timeframe_strength(df_daily, df_wk, df_mo, df_qtr): return False
    if not ema_stack(df_daily, [5,20,50,200]): return False
    if not breakout_and_volume(df_daily): return False
    if not vsa_proxy(df_daily): return False
    return True

5. Order Management & Risk Controls


python
# order_manager.py
from upstox_api.api import TransactionType, OrderType, ProductType
import pandas as pd

MAX_RISK_PER_TRADE = 0.02  # 2% equity
SL_MULTIPLIER      = 1.0   # Stop-loss 1× ATR or weekly low

def place_order(u, symbol, equity, df_daily):
    entry_price = df_daily.close.iloc[-1]
    # Stop-loss at weekly low
    df_wk,_,_ = aggregate_timeframes(df_daily)
    sl_price = df_wk.low.iloc[-1]
    risk_per_share = entry_price - sl_price
    max_loss = equity * MAX_RISK_PER_TRADE
    qty = int(max_loss / risk_per_share) if risk_per_share>0 else 0
    if qty<=0: return
    inst = u.get_instrument_by_symbol('NSE_EQ', symbol)
    u.place_order(inst, qty, TransactionType.Buy,
                  ProductType.Intraday, OrderType.Market)
    return {'symbol':symbol,'qty':qty,'entry':entry_price,'sl':sl_price}

6. Scheduler & Main Loop


python
# main.py
import schedule, time
from datetime import date
from upstox_auth import authenticate
from signal_generator import generate_signal, fetch_ohlc
from order_manager import place_order

WATCHLIST = ['RELIANCE','TCS','HDFC','INFY']  # adjust as needed

def job():
    u = authenticate()
    equity = 1000000  # ₹10 Lakh
    today = date.today().isoformat()
    for sym in WATCHLIST:
        if generate_signal(u, sym, '2023-01-01', today):
            df = fetch_ohlc(u, sym, today, today)
            order = place_order(u, sym, equity, df)
            print("Ordered:",order)

schedule.every().day.at("15:45").do(job)  # run after market close

if __name__=='__main__':
    while True:
        schedule.run_pending()
        time.sleep(30)

7. Deployment & Testing

Backtest Locally:
- Comment out place_order in main.py; log signals for 6–12 months.
- Validate Sharpe, CAGR, drawdown.
Paper Trade:
- Create a “dry-run” mode in place_order to simulate fills and P&L.
Live Deployment (VPS or Cloud):
- Host main.py on a reliable server (AWS EC2, DigitalOcean).
- Ensure environment auto-restarts on failure (use systemd or Docker).
Monitoring & Alerts:
- Log all signals and orders to a CSV or database.
- Configure email/SMS alerts for order confirmations and SL triggers.
Kill-Switch & Fail-Safe:
- Implement equity drawdown check in job(); if >5% drawdown, stop trading by exiting scheduler loop.

8. Ongoing Maintenance

Monthly Review:
Retrain/slightly tweak VSA parameters, EMA spans, volume thresholds.
Data Updates:
Refresh historical data quarterly to include new stocks and corporate actions.
Regulatory Compliance:
Keep records for SEBI audit (order logs, position limits, session logs).

This end-to-end automation framework allows you to run your multi-timeframe, volume-confirmed breakout strategy entirely via the Upstox API, from signal generation through live order placement, with robust risk controls, logging, and deployment guidance.

Search This Blog

AlgoMatrix