Placing & Managing Orders

# Before placing any order, confirm the server is in analyze mode (simulated).
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"),
)

status = client.analyzerstatus()
data = status["data"]

print(f"Mode        : {data['mode']}")
print(f"Analyze mode: {data['analyze_mode']}")

if data["analyze_mode"]:
    print("Safe to practise: every order below is simulated, nothing trades.")
else:
    print("WARNING: live mode is on. Orders would hit the real exchange.")

# A MARKET order: buy 1 RELIANCE for delivery (CNC) at the best available price.
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"),
)

# price_type=MARKET means "fill me now at whatever the market is".
# product=CNC means delivery (you intend to hold the shares).
response = client.placeorder(
    strategy="Chapter25",
    symbol="RELIANCE",
    exchange="NSE",
    action="BUY",
    price_type="MARKET",
    product="CNC",
    quantity=1,
)

print(response)
print(f"Status : {response['status']}")
print(f"Order id: {response.get('orderid')}")

# A LIMIT order: buy SBIN only if the price reaches your chosen level or better.
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"),
)

# A LIMIT order needs a price. We bid below the market so it rests as a pending
# order instead of filling instantly. trigger_price is 0 (not a stop order).
response = client.placeorder(
    strategy="Chapter25",
    symbol="SBIN",
    exchange="NSE",
    action="BUY",
    price_type="LIMIT",
    product="CNC",
    quantity=1,
    price=700,
    trigger_price=0,
)

print(f"Status : {response['status']}")
print(f"Order id: {response.get('orderid')}  (resting at 700)")

# Stop orders that protect a position: SL (stop-limit) and SL-M (stop-market).
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"),
)

# SL = Stop-Loss LIMIT. When price hits trigger_price (24820), a SELL LIMIT at
# price (24800) is sent. Use on an NFO future (NRML = overnight carry).
sl = client.placeorder(
    strategy="Chapter25", symbol="NIFTY30JUN26FUT", exchange="NFO",
    action="SELL", price_type="SL", product="NRML",
    quantity=65, price=24800, trigger_price=24820,
)
print(f"SL   order id: {sl.get('orderid')}  status: {sl['status']}")

# SL-M = Stop-Loss MARKET. Only a trigger is needed; once hit it fills at market.
slm = client.placeorder(
    strategy="Chapter25", symbol="GOLDM03JUL26FUT", exchange="MCX",
    action="SELL", price_type="SL-M", product="NRML",
    quantity=1, trigger_price=140000,
)
print(f"SL-M order id: {slm.get('orderid')}  status: {slm['status']}")

# placesmartorder() drives your position to a TARGET size, not a fixed quantity.
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"),
)

# position_size is the absolute target holding you want to end up with.
# OpenAlgo checks your current position and only sends the difference.
# Here: target 5 long. If you hold 0, it buys 5; if you hold 3, it buys 2.
response = client.placesmartorder(
    strategy="Chapter25",
    symbol="RELIANCE",
    exchange="NSE",
    action="BUY",
    price_type="MARKET",
    product="CNC",
    quantity=1,
    position_size=5,
)

print(f"Status  : {response['status']}")
print(f"Order id: {response.get('orderid')}")
print("Smart orders keep you AT a target size instead of adding blindly.")

# A basket order fires several different orders in one call (a long/short pair).
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"),
)

# Each basket leg is its own dictionary, and basket legs use the key "pricetype"
# (no underscore) -- unlike placeorder and splitorder, which use price_type=.
orders = [
    {"symbol": "RELIANCE", "exchange": "NSE", "action": "BUY",
     "quantity": 1, "pricetype": "MARKET", "product": "CNC"},
    {"symbol": "INFY", "exchange": "NSE", "action": "SELL",
     "quantity": 1, "pricetype": "MARKET", "product": "CNC"},
]

response = client.basketorder(orders=orders)

print(f"Basket status: {response['status']}")
for leg in response["results"]:
    print(f"  {leg['symbol']:10s} -> {leg['status']}  id {leg['orderid']}")

# A split order chops one big order into smaller child orders automatically.
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"),
)

# Buy 5 lots of GOLDM but in chunks of 2 -> orders of 2, 2, 1. Useful for large
# F&O orders that exceed the exchange freeze limit, or to reduce market impact.
response = client.splitorder(
    symbol="GOLDM03JUL26FUT",
    exchange="MCX",
    action="BUY",
    quantity=5,
    splitsize=2,
    price_type="MARKET",
    product="NRML",
)

print(f"Status: {response['status']}  total {response['total_quantity']} in chunks of {response['split_size']}")
for leg in response["results"]:
    print(f"  order {leg['order_num']}: qty {leg['quantity']}  id {leg['orderid']}")

# The full life of a resting order: place it, modify the price, then cancel it.
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"),
)

# 1) Place a LIMIT order that rests away from the market.
placed = client.placeorder(
    strategy="Chapter25", symbol="SBIN", exchange="NSE", action="BUY",
    price_type="LIMIT", product="CNC", quantity=1, price=700,
)
order_id = placed["orderid"]
print(f"Placed  : {order_id} at 700")

# 2) Modify it: raise the limit price to 710. Re-send the order's details.
modified = client.modifyorder(
    order_id=order_id, strategy="Chapter25", symbol="SBIN", exchange="NSE",
    action="BUY", price_type="LIMIT", product="CNC", quantity=1, price=710,
)
print(f"Modified: {modified['status']} -> new price 710")

# 3) Changed your mind? Cancel it by id.
cancelled = client.cancelorder(order_id=order_id, strategy="Chapter25")
print(f"Cancelled: {cancelled['status']}")

# Read the order book: every order you sent today and a summary of their states.
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"),
)

book = client.orderbook()
data = book["data"]
orders = data["orders"]
stats = data["statistics"]

print(f"Orders today: {len(orders)}")
print(f"  completed: {stats['total_completed_orders']:.0f}  "
      f"open: {stats['total_open_orders']:.0f}  "
      f"rejected: {stats['total_rejected_orders']:.0f}")

# Show the five most recent orders.
for o in orders[:5]:
    print(f"  {o['action']:4s} {o['symbol']:16s} {o['pricetype']:7s} "
          f"qty {o['quantity']} -> {o['order_status']}")

# Trade book = what actually FILLED. Position book = what you currently HOLD.
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"),
)

# Both books return their data as a list of dictionaries.
trades = client.tradebook()["data"]
print(f"Trades filled today: {len(trades)}")
for t in trades[:3]:
    print(f"  {t['action']:4s} {t['symbol']:16s} @ {t['average_price']}")

positions = client.positionbook()["data"]
open_pos = [p for p in positions if int(float(p["quantity"])) != 0]
print(f"\nOpen positions: {len(open_pos)}")
for p in open_pos[:5]:
    print(f"  {p['symbol']:16s} qty {p['quantity']:>4}  ltp {p['ltp']}  pnl {p['pnl']}")

# The two "panic buttons": cancel every pending order and flatten every position.
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"),
)

# cancelallorder() removes every open/pending order in one shot.
cancelled = client.cancelallorder(strategy="Chapter25")
print(f"Cancel all : {cancelled['status']} - {cancelled.get('message')}")

# closeposition() squares off every open position with market orders
# (a SELL for longs, a BUY for shorts). Your end-of-day flatten button.
closed = client.closeposition(strategy="Chapter25")
print(f"Close all  : {closed['status']} - {closed.get('message')}")

print("Use these for an emergency exit or a clean end-of-day square-off.")