Place Order¶

create_order() places a single order. Use it for standard one-instrument trading workflows such as regular limit orders, stop-loss orders, and iceberg orders.

LLM guidance

Use this page for one independent order using one ref_id. Do not use this page for F&O multi-leg basket strategies. For multiple independent orders in one request, use Place Multi Order. For basket-level strategy execution such as straddles or iron condors, use Place Flexi Order.

Walkthrough Video¶

If the embedded video does not load, watch it on YouTube: Place Order Walkthrough

Basic Usage¶

from nubra_python_sdk.start_sdk import InitNubraSdk, NubraEnv
from nubra_python_sdk.refdata.instruments import InstrumentData
from nubra_python_sdk.marketdata.market_data import MarketData
from nubra_python_sdk.trading.trading_data import NubraTrader
from nubra_python_sdk.trading.trading_enum import ExchangeEnum

nubra = InitNubraSdk(NubraEnv.UAT, env_creds=True)
instruments = InstrumentData(nubra)
market_data = MarketData(nubra)
trader = NubraTrader(nubra, version="V2")

ref_id = instruments.get_instrument_by_symbol("HDFCBANK", exchange=ExchangeEnum.NSE).ref_id
ltp = market_data.quote(ref_id=ref_id, levels=1).orderBook.last_traded_price

result = trader.create_order({
    "ref_id": ref_id,
    "order_type": "ORDER_TYPE_REGULAR",
    "order_qty": 1,
    "order_side": "ORDER_SIDE_BUY",
    "order_delivery_type": "ORDER_DELIVERY_TYPE_CNC",
    "validity_type": "DAY",
    "price_type": "LIMIT",
    "order_price": ltp + 10,
    "exchange": "NSE",
    "tag": "example_single_order"
})

print(result.order_id)

Example Order Patterns¶

These examples map directly to common single-order workflows:

limit order placement
stop-loss order placement
iceberg order placement

Limit OrderStoploss OrderIceberg Order

from nubra_python_sdk.start_sdk import InitNubraSdk, NubraEnv
from nubra_python_sdk.marketdata.market_data import MarketData
from nubra_python_sdk.trading.trading_data import NubraTrader
from nubra_python_sdk.refdata.instruments import InstrumentData

nubra = InitNubraSdk(NubraEnv.UAT)
instruments = InstrumentData(nubra)
md = MarketData(nubra)
trade = NubraTrader(nubra, version="V2")

ref_id = instruments.get_instrument_by_symbol("HDFCBANK", exchange="NSE").ref_id
quote = md.quote(ref_id=ref_id, levels=5)
ltp = quote.orderBook.last_traded_price

result = trade.create_order({
    "ref_id": ref_id,
    "order_type": "ORDER_TYPE_REGULAR",
    "order_qty": 1,
    "order_side": "ORDER_SIDE_BUY",
    "order_delivery_type": "ORDER_DELIVERY_TYPE_CNC",
    "validity_type": "DAY",
    "price_type": "LIMIT",
    "order_price": ltp + 90,
    "exchange": "NSE",
    "tag": "Limit_example"
})

Use this pattern when you want to place a standard single-instrument limit order.

from nubra_python_sdk.start_sdk import InitNubraSdk, NubraEnv
from nubra_python_sdk.marketdata.market_data import MarketData
from nubra_python_sdk.trading.trading_data import NubraTrader
from nubra_python_sdk.refdata.instruments import InstrumentData

nubra = InitNubraSdk(NubraEnv.UAT)
instruments = InstrumentData(nubra)
md = MarketData(nubra)
trade = NubraTrader(nubra, version="V2")

ref_id = instruments.get_instrument_by_symbol("RELIANCE", exchange="NSE").ref_id
quote = md.quote(ref_id=ref_id, levels=5)
ltp = quote.orderBook.last_traded_price

result = trade.create_order({
    "ref_id": ref_id,
    "order_type": "ORDER_TYPE_STOPLOSS",
    "order_qty": 1,
    "order_side": "ORDER_SIDE_BUY",
    "order_delivery_type": "ORDER_DELIVERY_TYPE_IDAY",
    "validity_type": "DAY",
    "price_type": "LIMIT",
    "order_price": ltp + 50,
    "exchange": "NSE",
    "tag": "Stoploss_example",
    "algo_params": {
        "trigger_price": ltp + 30
    }
})

Use this pattern when your order must trigger only after the specified trigger_price is reached. For post-placement edits, continue with Modify Order.

from nubra_python_sdk.start_sdk import InitNubraSdk, NubraEnv
from nubra_python_sdk.marketdata.market_data import MarketData
from nubra_python_sdk.trading.trading_data import NubraTrader
from nubra_python_sdk.refdata.instruments import InstrumentData

nubra = InitNubraSdk(NubraEnv.UAT)
md = MarketData(nubra)
instruments = InstrumentData(nubra)
trade = NubraTrader(nubra, version="V2")

instrument = instruments.get_instrument_by_symbol("RELIANCE", exchange="NSE")
ref_id = instrument.ref_id

quote = md.quote(ref_id=ref_id, levels=5)
ltp = quote.orderBook.last_traded_price

total_qty = 1000
leg_size = 100

result = trade.create_order({
    "ref_id": ref_id,
    "order_type": "ORDER_TYPE_ICEBERG",
    "order_qty": total_qty,
    "order_side": "ORDER_SIDE_BUY",
    "order_delivery_type": "ORDER_DELIVERY_TYPE_CNC",
    "validity_type": "DAY",
    "price_type": "LIMIT",
    "order_price": ltp + 10,
    "exchange": "NSE",
    "tag": "iceberg_example",
    "algo_params": {
        "leg_size": leg_size
    }
})

Use this pattern when you want to place a larger quantity while exposing only part of it at a time.

Request Contract¶

Field	Type	Required	Meaning
`ref_id`	`int`	yes	instrument reference ID
`order_type`	`enum`	yes	order style such as `ORDER_TYPE_REGULAR`, `ORDER_TYPE_STOPLOSS`, or `ORDER_TYPE_ICEBERG`
`order_qty`	`int`	yes	quantity
`order_side`	`enum`	yes	`ORDER_SIDE_BUY` or `ORDER_SIDE_SELL`
`order_delivery_type`	`enum`	yes	delivery type such as `ORDER_DELIVERY_TYPE_CNC` or `ORDER_DELIVERY_TYPE_IDAY`
`validity_type`	`enum`	yes	validity such as `DAY` or `IOC`
`price_type`	`enum`	yes	typically `LIMIT`
`order_price`	`int`	conditional	order price in exchange-native integer units
`exchange`	`enum`	yes	`NSE` or `BSE`
`tag`	`str`	no	optional tag
`algo_params`	`dict`	conditional	required for strategy-specific fields such as `trigger_price` or `leg_size`

Common `algo_params`¶

Field	Used for	Meaning
`trigger_price`	stop-loss orders	trigger price
`leg_size`	iceberg orders	visible leg size
`benchmark_price`	benchmark-driven orders	benchmark reference
`benchmark_type`	benchmark-driven orders	benchmark mode

Response Contract¶

Field	Type	Meaning
`order_id`	`int`	Nubra order identifier
`exchange_order_id`	`int`	exchange-assigned order identifier
`ref_id`	`int`	instrument reference ID
`order_type`	`enum`	order type
`order_side`	`enum`	buy or sell
`order_price`	`int`	order price
`order_qty`	`int`	requested quantity
`filled_qty`	`int`	filled quantity
`avg_filled_price`	`int`	average fill price
`order_status`	`str`	order status
`last_modified`	`int`	last update time
`ref_data`	`RefData`	instrument metadata
`last_traded_price`	`int`	current LTP field in the response
`display_name`	`str`	display name
`brokerage`	`float`	brokerage value when available
`tag`	`str`	order tag
`update_msg`	`str`	update message when present

Important Rules¶

Important Rules

ref_id must belong to the current environment. Do not reuse UAT identifiers in PROD.
Resolve instruments before placing orders instead of hardcoding identifiers.
Order prices are typically passed in exchange-native integer units such as paise for NSE instruments.
Strategy-specific fields must be passed through algo_params.
Review Rate Limits & API Usage before automating high-frequency placement logic.