Intraday Strategies

# Pull 5-minute intraday candles -- the raw material for every intraday strategy.
import os
from datetime import datetime, timedelta

from openalgo import api

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=10)).strftime("%Y-%m-%d")

df = client.history(symbol="SBIN", exchange="NSE", interval="5m", start_date=start, end_date=end)

# Each row is one 5-minute candle. The index is a timezone-aware timestamp (IST).
print("5m candles:", len(df), "over", df.index.normalize().nunique(), "sessions")
print("First bar of the data:", df.index[0].strftime("%Y-%m-%d %H:%M"))
print("Last bar of the data: ", df.index[-1].strftime("%Y-%m-%d %H:%M"))
print(df[["open", "high", "low", "close", "volume"]].head(3))

# Slice out a single trading session -- intraday logic always runs day by day.
import os
from datetime import datetime, timedelta

from openalgo import api

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=10)).strftime("%Y-%m-%d")
df = client.history(symbol="SBIN", exchange="NSE", interval="5m", start_date=start, end_date=end)

# Group by the calendar date (drop the time part) and take the most recent day.
sessions = df.groupby(df.index.normalize())
last_date = list(sessions.groups)[-1]
day = sessions.get_group(last_date)

print("Session:", last_date.strftime("%Y-%m-%d"), "with", len(day), "five-minute bars")
print("Open (first bar):", day["open"].iloc[0])
print("High of day:     ", day["high"].max())
print("Low of day:      ", day["low"].min())
print("Close (last bar):", day["close"].iloc[-1])

# Opening Range Breakout (ORB): the high and low of the first 15 minutes.
import os
from datetime import datetime, timedelta

from openalgo import api

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=10)).strftime("%Y-%m-%d")
df = client.history(symbol="SBIN", exchange="NSE", interval="5m", start_date=start, end_date=end)

# The first 15 minutes = the 09:15, 09:20 and 09:25 bars. between_time selects them.
opening = df.between_time("09:15", "09:29")
ranges = opening.groupby(opening.index.date).agg(or_high=("high", "max"), or_low=("low", "min"))
ranges["width"] = ranges["or_high"] - ranges["or_low"]

print("Opening range (first 15 min) per session:")
print(ranges.tail(5).round(2))
print("\nA breakout BUY triggers if a later bar closes ABOVE that day's or_high;")
print("a breakout SELL triggers if it closes BELOW that day's or_low.")

# Turn the opening range into an actual breakout signal for the latest session.
import os
from datetime import datetime, timedelta

from openalgo import api

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=10)).strftime("%Y-%m-%d")
df = client.history(symbol="RELIANCE", exchange="NSE", interval="5m", start_date=start, end_date=end)

# Take the most recent session only.
last_date = df.index.normalize()[-1]
day = df[df.index.normalize() == last_date]

opening = day.between_time("09:15", "09:29")
or_high, or_low = opening["high"].max(), opening["low"].min()

# After the opening range, look for the first bar that breaks out.
after = day.between_time("09:30", "15:15")
longs = after[after["close"] > or_high]
shorts = after[after["close"] < or_low]

print(f"Session {last_date.date()}  range {or_low:.1f} - {or_high:.1f}")
if not longs.empty:
    t = longs.index[0]
    print(f"LONG breakout at {t.strftime('%H:%M')} close {longs['close'].iloc[0]:.1f}")
elif not shorts.empty:
    t = shorts.index[0]
    print(f"SHORT breakout at {t.strftime('%H:%M')} close {shorts['close'].iloc[0]:.1f}")
else:
    print("No breakout today -- price stayed inside the opening range (a quiet day).")

# VWAP -- the volume-weighted average price, the intraday fair-value line.
import os
from datetime import datetime, timedelta

from openalgo import api, ta

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=8)).strftime("%Y-%m-%d")
df = client.history(symbol="INFY", exchange="NSE", interval="5m", start_date=start, end_date=end)

# anchor="Session" resets the VWAP at the start of each trading day -- exactly what
# an intraday trader wants. It is the running average price weighted by volume.
df["vwap"] = ta.vwap(df["high"], df["low"], df["close"], df["volume"], anchor="Session")
df["gap"] = (df["close"] - df["vwap"]) / df["vwap"] * 100

print(df[["close", "vwap", "gap"]].tail(6).round(3))
last = df.iloc[-1]
side = "ABOVE" if last["close"] > last["vwap"] else "BELOW"
print(f"\nPrice is {side} VWAP by {abs(last['gap']):.2f}% -- bulls control the day when price holds above VWAP.")

# VWAP mean-reversion: fade stretches away from VWAP, expecting a snap back.
import os
from datetime import datetime, timedelta

from openalgo import api, ta

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=8)).strftime("%Y-%m-%d")
df = client.history(symbol="ICICIBANK", exchange="NSE", interval="5m", start_date=start, end_date=end)

df["vwap"] = ta.vwap(df["high"], df["low"], df["close"], df["volume"], anchor="Session")
# Distance from VWAP measured in that session's percentage terms.
df["dist"] = (df["close"] - df["vwap"]) / df["vwap"] * 100

# Reversion idea: when price is unusually FAR below VWAP, buy expecting a pullback up.
threshold = 0.40  # percent
dips = df[df["dist"] < -threshold]

print(f"5m bars more than {threshold:.2f}% below VWAP (buy-the-dip candidates):", len(dips))
print(dips[["close", "vwap", "dist"]].tail(5).round(3))
print("\nMean-reversion assumes the gap closes. It works in range days, NOT in strong trends.")

# Intraday EMA crossover: a fast EMA crossing a slow EMA is a classic momentum signal.
import os
from datetime import datetime, timedelta

import pandas as pd

from openalgo import api, ta

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=8)).strftime("%Y-%m-%d")
df = client.history(symbol="TCS", exchange="NSE", interval="5m", start_date=start, end_date=end)

df["ema_fast"] = ta.ema(df["close"], 9)
df["ema_slow"] = ta.ema(df["close"], 21)

# crossover() returns a numpy boolean array; wrap it in a Series to align with the index.
df["buy"] = pd.Series(ta.crossover(df["ema_fast"], df["ema_slow"]), index=df.index)
df["sell"] = pd.Series(ta.crossunder(df["ema_fast"], df["ema_slow"]), index=df.index)

print("Bullish 9/21 EMA crosses:", int(df["buy"].sum()))
print("Bearish 9/21 EMA crosses:", int(df["sell"].sum()))
print("\nMost recent crossover signals:")
crosses = df[df["buy"] | df["sell"]]
for ts, row in crosses.tail(4).iterrows():
    print(f"  {ts.strftime('%m-%d %H:%M')}  {'BUY ' if row['buy'] else 'SELL'}  close {row['close']:.1f}")

# Time-based exit: square off everything by a cutoff time, no matter what.
import os
from datetime import datetime, timedelta

import pandas as pd

from openalgo import api, ta

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=8)).strftime("%Y-%m-%d")
df = client.history(symbol="HDFCBANK", exchange="NSE", interval="5m", start_date=start, end_date=end)

# Entries from a 9/21 EMA cross...
df["buy"] = pd.Series(ta.crossover(ta.ema(df["close"], 9), ta.ema(df["close"], 21)), index=df.index)

# ...but force ALL positions flat after the cutoff. A time mask makes this trivial.
CUTOFF = "15:10"
square_off = df.index.indexer_between_time(CUTOFF, "15:30")
df["force_exit"] = False
df.iloc[square_off, df.columns.get_loc("force_exit")] = True

buys_after_cutoff = df[(df["buy"]) & (df["force_exit"])]
print(f"Square-off window starts at {CUTOFF} IST.")
print("New entries blocked after cutoff:", len(buys_after_cutoff), "(we ignore late signals)")
print("Bars in the square-off window per session:",
      int(df["force_exit"].sum() / df.index.normalize().nunique()))
print("\nIntraday rule: never carry an MIS position into the close -- the broker auto-squares it for you.")

# The MIS product: intraday margin orders that auto-square-off before the close.
import os

from openalgo import api

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

# product="MIS" tells the broker this is an intraday trade. It gives extra leverage
# but the position is force-closed near the session close. We use an MCX commodity
# future here because MCX trades into the evening, so this MIS order is accepted
# even after the equity market has shut. (Server is in analyze mode -- it is simulated.)
resp = client.placeorder(
    strategy="Intraday ORB",
    symbol="GOLDM03JUL26FUT",
    action="BUY",
    exchange="MCX",
    price_type="MARKET",
    product="MIS",      # MIS = intraday;  CNC = delivery;  NRML = F&O carry
    quantity=1,
)

print("Order status:", resp.get("status"))
print("Order id     :", resp.get("orderid"))
print("\nProduct codes you will use intraday:")
print("  MIS  -> intraday, higher leverage, auto square-off (this strategy)")
print("  CNC  -> delivery / overnight equity")
print("  NRML -> futures & options carried overnight")
print("\nNote: equity MIS orders are blocked after 15:15 IST -- the broker enforces square-off for you.")

# Backtest an intraday EMA system on the NIFTY future with VectorBT.
import os
import time
from datetime import datetime, timedelta

import pandas as pd

from openalgo import api, ta

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=20)).strftime("%Y-%m-%d")


def hist():
    for _ in range(3):
        d = client.history(symbol="NIFTY30JUN26FUT", exchange="NFO", interval="5m",
                           start_date=start, end_date=end)
        if isinstance(d, pd.DataFrame) and "close" in d:
            return d
        time.sleep(1)
    raise RuntimeError(f"Could not fetch history: {d}")


df = hist()
close = df["close"]
entries = pd.Series(ta.crossover(ta.ema(close, 9), ta.ema(close, 21)), index=close.index)
exits = pd.Series(ta.crossunder(ta.ema(close, 9), ta.ema(close, 21)), index=close.index)

# Square off every position on the last bar of each session (no overnight risk).
day = pd.Series(df.index.normalize(), index=df.index)
exits = exits | (day != day.shift(-1))

import vectorbt as vbt

# Reset to a simple integer index so VectorBT ignores the overnight gaps between sessions.
pf = vbt.Portfolio.from_signals(
    close.reset_index(drop=True), entries.reset_index(drop=True), exits.reset_index(drop=True),
    init_cash=500000, fees=0.0003,
)
print("NIFTY future intraday EMA 9/21 (5m, square-off each day)")
print("Total return :", round(float(pf.total_return()) * 100, 2), "%")
print("Trades       :", int(pf.trades.count()))
print("Win rate     :", round(float(pf.trades.win_rate()) * 100, 1), "%")
print("\nA losing result on a few weeks of data is normal -- intraday edges are thin and costs bite.")