OpenAlgo — Trading Skill for Indian Markets

OpenAlgo is a broker-agnostic, self-hosted trading platform. One Python SDK (pip install openalgo) talks to 30+ Indian brokers behind a unified REST + WebSocket interface. This skill covers the complete SDK surface plus production-ready helpers and examples for the seven core workflows traders ask for:

1. Order execution — equity, F&O, options-by-offset, multi-leg, basket, split, smart
2. Custom execution algos — limit-order chasing, auto-modify, time/price triggered cancel
3. Scanners — multiquotes + history + filter pipelines
4. Visualization — heatmaps, OI charts, seasonality, gainers/losers, PCR dashboards
5. Backtesting — vectorbt glue with realistic Indian fees, NIFTY benchmark
6. Charting — candles (category x-axis, no weekend gaps), depth ladder, option-chain OI, IV smile
7. Real-time streaming — LTP / Quote / Depth WebSocket, reconnect loop, callback routing

Setup

pip install -U "openalgo[indicators]"
pip install -r requirements.txt   # includes vectorbt, TA-Lib, plotly, duckdb, dotenv
cp .env.sample .env               # fill in OPENALGO_API_KEY and host/ws URLs

Minimal init (every script in this skill starts the same way):

import os
from dotenv import find_dotenv, load_dotenv
from openalgo import api

load_dotenv(find_dotenv(), override=False)

client = api(
    api_key=os.environ["OPENALGO_API_KEY"],
    host=os.environ.get("OPENALGO_HOST", "http://127.0.0.1:5000"),
    ws_url=os.environ.get("OPENALGO_WS_URL", "ws://127.0.0.1:8765"),
)

For repo-resident scripts prefer the shared helper:

from scripts.openalgo_client import get_client
client = get_client()

Safety Rules — Always Enforce

1. Iterate in analyzer mode first. Toggle client.analyzertoggle(mode=True) so the SDK simulates responses without hitting the broker. Switch off only after the strategy is reviewed.
2. Confirm before live orders. Print a readable preview (symbol, side, qty, product, price, notional) and wait for user confirmation unless the user has explicitly authorized auto-execution for the current session.
3. Default to LIMIT over MARKET. Quote the symbol first and place a marketable-limit at LTP ± a few ticks. MARKET only when the user explicitly asks.
4. Validate F&O lot-size multiples. Load the bundled assets/LotSize.csv (or call client.symbol() for the current lotsize) and reject non-multiples before placement.
5. Warn on notional > Rs 50,000. For F&O, use lotsize × strike as a worst-case proxy when price is unknown.
6. Never CNC on F&O / commodity / currency. Only MIS (intraday) or NRML (overnight) for those segments. CNC is equity-delivery only.
7. Never hardcode API keys. Always read from .env via find_dotenv(). Reject scripts that contain literal 64-char hex keys.
8. Multi-leg execution needs explicit per-leg confirmation when run live. optionsmultiorder and basketorder route to the broker as separate orders that can partially fail — handle the results[] array, don't trust the top-level status.
9. Rate limits matter. Order APIs are capped at 10/sec (smart orders 2/sec), data APIs at 50/sec. Use the retry-with-backoff helper in scripts/orders.py rather than tight loops.
10. WebSocket reconnect is the user's responsibility. Use the subscribe() context manager in scripts/stream.py — it handles auth, heartbeat, and re-subscription on disconnect.

File-Output Convention

When this skill generates code for a specific action, write outputs into a per-action subfolder, created on-demand (never pre-created):

openalgo_workspace/
├── execution/
│   ├── atm_straddle/             # straddle.py, run.log, trade_journal.csv
│   └── iron_condor/
├── execution_algos/
│   ├── limit_chaser_reliance/    # chaser.py, fills.csv
│   └── twap_slicer_sbin/
├── scanners/
│   ├── rsi_oversold/             # scan.py, results_2026-05-24.csv
│   └── breakout/
├── visualization/
│   └── sector_heatmap/           # heatmap.py, heatmap_2026-05-24.html
├── backtesting/
│   ├── supertrend_sbin/          # backtest.py, trades.csv, equity.html
│   └── ema_crossover_nifty50/
├── charting/
│   └── nifty_option_chain_oi/    # chart.py, oi_27jan26.html
└── streaming/
    └── nifty_depth_stream/       # stream.py, ticks.parquet

Each subfolder is self-contained — script, generated data, plots, logs. The user can rm -rf any folder without affecting others.

Constants — Order Surface

Full grammar in references/order-constants.md and references/symbol-format.md. F&O lot sizes ship as a CSV at assets/LotSize.csv (see references/lot-sizes.md).

Symbol Format Quick-Reference

Equity:   RELIANCE                          (just the base symbol)
Futures:  NIFTY30JUN26FUT                   [base][DDMMMYY]FUT
Options:  NIFTY30JUN2626500CE               [base][DDMMMYY][strike][CE/PE]

Index quote-only symbols (no trading, use for quotes/history/ws): NIFTY BANKNIFTY FINNIFTY MIDCPNIFTY NIFTYNXT50 SENSEX BANKEX (and 80+ more — see references/symbol-format.md)

Complete SDK Method Map

The Python SDK doesn't expose every kwarg in its docstrings — when a parameter is missing or unclear, fall back to the per-endpoint REST docs at /Users/openalgo/test-zerodha/openalgo/docs/api/<group>/<endpoint>.md. That tree is parameter-complete.

Quick Template — Place an Order with Preview + Analyzer Safety

import os
from dotenv import find_dotenv, load_dotenv
from openalgo import api

load_dotenv(find_dotenv(), override=False)
client = api(
    api_key=os.environ["OPENALGO_API_KEY"],
    host=os.environ.get("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

SYMBOL, EXCHANGE = "RELIANCE", "NSE"
ACTION, QTY, PRODUCT = "BUY", 1, "MIS"

# 1. Quote to anchor a marketable limit price (safer than MARKET)
q = client.quotes(symbol=SYMBOL, exchange=EXCHANGE)["data"]
limit_price = round(q["ltp"] * 1.001, 2) if ACTION == "BUY" else round(q["ltp"] * 0.999, 2)
notional = limit_price * QTY

print(f"--- Order Preview ---")
print(f"  {ACTION} {QTY} {SYMBOL} @ LIMIT {limit_price}   notional Rs {notional:,.2f}")
print(f"  Product: {PRODUCT}   LTP: {q['ltp']}")

if input("Proceed? [y/N] ").strip().lower() != "y":
    raise SystemExit("aborted")

response = client.placeorder(
    strategy=os.environ.get("OPENALGO_DEFAULT_STRATEGY", "python"),
    symbol=SYMBOL,
    exchange=EXCHANGE,
    action=ACTION,
    price_type="LIMIT",
    product=PRODUCT,
    quantity=str(QTY),
    price=str(limit_price),
)
print("ORDER:", response)

Quick Template — Stream LTP with Reconnect

import os, time
from dotenv import find_dotenv, load_dotenv
from openalgo import api

load_dotenv(find_dotenv(), override=False)
client = api(
    api_key=os.environ["OPENALGO_API_KEY"],
    host=os.environ.get("OPENALGO_HOST", "http://127.0.0.1:5000"),
    ws_url=os.environ.get("OPENALGO_WS_URL", "ws://127.0.0.1:8765"),
    verbose=True,
)

instruments = [
    {"exchange": "NSE_INDEX", "symbol": "NIFTY"},
    {"exchange": "NSE", "symbol": "RELIANCE"},
]

def on_ltp(msg):
    d = msg["data"]
    print(f"{d['symbol']:<12} LTP {d['ltp']}  @ {d['timestamp']}")

client.connect()
client.subscribe_ltp(instruments, on_data_received=on_ltp)

try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    client.unsubscribe_ltp(instruments)
    client.disconnect()

Quick Template — History from Direct DuckDB (Historify)

client.history(..., source="db") routes through REST. For bulk multi-symbol pulls or backtesting, hit the DuckDB file directly:

import os, duckdb, pandas as pd
from dotenv import find_dotenv, load_dotenv

load_dotenv(find_dotenv(), override=False)
DB = os.environ["HISTORIFY_DUCKDB_PATH"]   # e.g. /srv/openalgo/db/historify.duckdb

con = duckdb.connect(DB, read_only=True)

# Historify schema: table `market_data` with epoch timestamps
df = con.execute("""
    SELECT
        symbol,
        exchange,
        to_timestamp(timestamp) AT TIME ZONE 'Asia/Kolkata' AS ts,
        open, high, low, close, volume
    FROM market_data
    WHERE symbol = ?
      AND exchange = ?
      AND timestamp >= EXTRACT(EPOCH FROM TIMESTAMP '2024-01-01')
    ORDER BY timestamp
""", ["SBIN", "NSE"]).fetchdf()
con.close()

df["ts"] = pd.to_datetime(df["ts"]).dt.tz_localize(None)
df = df.set_index("ts")
print(df.tail())

Full Historify usage, multi-symbol joins, and resampling alignment with NSE 09:15 IST in references/duckdb-historify.md.

Indicator Rule (matches vectorbt-backtesting-skills)

• TA-Lib for the standard set: EMA, SMA, RSI, MACD, ATR, BBANDS, ADX, STDDEV, MOM.
• openalgo.ta for: supertrend, donchian, ichimoku, hma, kama, alma, zlema, vwma.
• openalgo.ta for signal cleaning: exrem, crossover, crossunder, flip — always .fillna(False) before exrem.

Never use VectorBT's built-in indicators (vbt.MA.run etc.).

Helper Scripts (scripts/)

Examples Catalog (examples/)

Reference Files (references/)

How to Pick Live vs Analyzer Mode

status = client.analyzerstatus()["data"]
if status["analyze_mode"]:
    print(f"[ANALYZER] simulated mode — orders will not reach broker. logs: {status['total_logs']}")
else:
    print("[LIVE] orders will execute on the broker")

While developing a new strategy: client.analyzertoggle(mode=True). When the user is satisfied: ask for explicit go-live confirmation, then client.analyzertoggle(mode=False).

Output Encoding Rules

• Never put emojis in generated code or log output. Plain ASCII only.
• Plotly charts use template="plotly_dark" and candlesticks use xaxis_type="category" to skip weekend gaps.
• Trade journals / scan results write to CSV with a date-stamped filename inside the action's workspace folder.
• All datetime indexes are tz-naive after dropping Asia/Kolkata (matches the vectorbt skill's convention so dataframes round-trip cleanly).