Place Strategy Order

Use this page to place one leg-based Trading API V3 FNO strategy order through the REST API.

A strategy order sets isMultiLeg: true and sends a non-empty legs list. The strategy is treated as one order object, with one strategy-level intentOrderId in the response.

Strategy orders help users build complex FNO strategies by grouping multiple option or future legs into one strategy order.

With basket-level execution, users can choose strategy-level entry and/or exit configs. Both time-based and price-based entry and exits are possible, along with trailing stop-loss and other trigger configurations.

stratTags

The strategy order can pass exactly one tag inside stratTags. Use hyphen-separated tag names only, such as rest-api-v3-nifty-buy-straddle. Do not use underscores, spaces, colons, plus signs, timestamps, or other special characters.

Scope

Use this page for one strategy order composed from FNO legs. This shape omits top-level refId, requires isMultiLeg: true, sets the strategy-level side, and uses legs[].refId plus signed legs[].unitQty. Set executionMode based on the top-level entry and exit fields. Do not use this page for multiple independent single orders; use Place Multi Order.

Price and quantity format

Trading API V3 examples on this page use rupee prices snapped to the live contract tick_size. For strategy quantities, use qty as the common executable base quantity derived from the leg lot sizes, and use legs[].unitQty as the lot multiplier for each leg. For example, if both legs trade in 65-lot contracts, set qty: 65 for one strategy unit and unitQty: 1 on each leg. If you want to scale the whole strategy to two strategy units, set qty: 130. If you want two lots only on one leg, keep the same base qty and set that leg's unitQty: 2. Use a negative unitQty for short legs.

Endpoint

Method: POST
Endpoint: /sentinel/orders/create

Base URLs

Environment	Base URL
PROD	https://api.nubra.io
UAT	https://uatapi.nubra.io

Headers

Authorization: Bearer <session_token>
x-device-id: <device_id>
Content-Type: application/json

cURL

curl --location 'https://api.nubra.io/sentinel/orders/create' \
--header 'Authorization: Bearer <session_token>' \
--header 'x-device-id: <device_id>' \
--header 'Content-Type: application/json' \
--data '{
  "orders": [
    {
      "isMultiLeg": true,
      "qty": 65,
      "side": "BUY",
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "DAY",
      "executionMode": "ENTRY_AND_EXIT",
      "entryPrice": 44935,
      "legs": [
        { "refId": 1497712, "unitQty": 1 },
        { "refId": 1497713, "unitQty": 1 }
      ],
      "entryConfig": {
        "triggers": {
          "ltp": {
            "atOrAbove": { "value": 44945 }
          }
        }
      },
      "exitConfig": {
        "stoplossParams": {
          "stoplossTriggerPrice": { "value": 44895 },
          "stoplossLimitPrice": { "value": 44885 }
        },
        "targetParams": {
          "targetProfitTriggerPrice": { "value": 45015 },
          "targetProfitLimitPrice": { "value": 45005 }
        }
      },
      "stratTags": ["rest-api-v3-nifty-buy-straddle"]
    }
  ]
}'

Basic Usage

{
  "orders": [
    {
      "isMultiLeg": true,
      "qty": 65,
      "side": "BUY",
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "DAY",
      "executionMode": "ENTRY_AND_EXIT",
      "entryPrice": 44935,
      "legs": [
        { "refId": 1497712, "unitQty": 1 },
        { "refId": 1497713, "unitQty": 1 }
      ],
      "entryConfig": {
        "triggers": {
          "ltp": {
            "atOrAbove": { "value": 44945 }
          }
        }
      },
      "exitConfig": {
        "stoplossParams": {
          "stoplossTriggerPrice": { "value": 44895 },
          "stoplossLimitPrice": { "value": 44885 }
        },
        "targetParams": {
          "targetProfitTriggerPrice": { "value": 45015 },
          "targetProfitLimitPrice": { "value": 45005 }
        }
      },
      "stratTags": ["rest-api-v3-nifty-buy-straddle"]
    }
  ]
}

Example Order Patterns

These examples show common option strategy orders built with Trading API V3 multi-leg payloads.

• each leg is passed through legs
• strategy-level pricing and controls stay on the top-level order object
• option refId values should be resolved before order placement
• set isMultiLeg: true, set strategy side: "BUY", omit top-level refId, and set the correct executionMode
• use qty as the common executable base quantity for the strategy and legs[].unitQty as the signed lot multiplier for each leg
• strategy orders can combine validityType: "GTE", goodTillDate, price and time entry, stop-loss, trailing stop-loss, and target in the same payload
• if you use validityType: "GTE", do not add exitConfig.exitTime
• resolve lot size and tick size from instruments instead of hardcoding values such as 65
• there is no separate top-level basket multiplier field in this strategy shape

StraddleStrangleBull Call SpreadIron CondorIron Butterfly

{
  "orders": [
    {
      "isMultiLeg": true,
      "qty": 65,
      "side": "BUY",
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "DAY",
      "executionMode": "ENTRY",
      "entryPrice": 44935,
      "legs": [
        { "refId": 1497712, "unitQty": 1 },
        { "refId": 1497713, "unitQty": 1 }
      ],
      "stratTags": ["rest-api-v3-nifty-buy-straddle"]
    }
  ]
}

Use this pattern for a two-leg same-strike buy straddle strategy.

{
  "orders": [
    {
      "isMultiLeg": true,
      "qty": 65,
      "side": "BUY",
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "DAY",
      "executionMode": "ENTRY",
      "entryPrice": 37250,
      "legs": [
        { "refId": 1497720, "unitQty": 1 },
        { "refId": 1497721, "unitQty": 1 }
      ],
      "stratTags": ["rest-api-v3-nifty-buy-strangle"]
    }
  ]
}

Use this pattern for a two-leg buy strangle strategy with different call and put strikes.

{
  "orders": [
    {
      "isMultiLeg": true,
      "qty": 65,
      "side": "BUY",
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "GTE",
      "goodTillDate": "2026-10-16T15:10:00.000Z",
      "executionMode": "ENTRY_AND_EXIT",
      "entryPrice": 18050,
      "legs": [
        { "refId": 1497730, "unitQty": 1 },
        { "refId": 1497731, "unitQty": -1 }
      ],
      "entryConfig": {
        "entryTime": "2026-10-16T09:20:00.000Z",
        "triggers": {
          "ltp": {
            "atOrAbove": { "value": 18060 }
          }
        }
      },
      "exitConfig": {
        "stoplossParams": {
          "stoplossTriggerPrice": { "value": 18010 },
          "stoplossLimitPrice": { "value": 18000 },
          "stoplossTrailJump": 5
        },
        "targetParams": {
          "targetProfitTriggerPrice": { "value": 18130 },
          "targetProfitLimitPrice": { "value": 18120 }
        }
      },
      "stratTags": ["rest-api-v3-nifty-bull-call-flexible"]
    }
  ]
}

Use this pattern for a two-leg bull call spread that combines good-till validity, price and time entry, stop-loss, trailing stop-loss, and target controls. Replace the sample entryTime and goodTillDate values before running the payload.

{
  "orders": [
    {
      "isMultiLeg": true,
      "qty": 65,
      "side": "BUY",
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "DAY",
      "executionMode": "ENTRY",
      "entryPrice": 21500,
      "legs": [
        { "refId": 1497740, "unitQty": 1 },
        { "refId": 1497741, "unitQty": -1 },
        { "refId": 1497742, "unitQty": -1 },
        { "refId": 1497743, "unitQty": 1 }
      ],
      "stratTags": ["rest-api-v3-nifty-iron-condor"]
    }
  ]
}

Use this pattern for a four-leg defined-risk short-volatility strategy with wider protective wings.

{
  "orders": [
    {
      "isMultiLeg": true,
      "qty": 65,
      "side": "BUY",
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "DAY",
      "executionMode": "ENTRY",
      "entryPrice": 19800,
      "legs": [
        { "refId": 1497750, "unitQty": 1 },
        { "refId": 1497751, "unitQty": -1 },
        { "refId": 1497752, "unitQty": -1 },
        { "refId": 1497753, "unitQty": 1 }
      ],
      "stratTags": ["rest-api-v3-nifty-iron-butterfly"]
    }
  ]
}

Use this pattern for a four-leg strategy with the short call and short put at the same strike.

Multi-Leg Behavior

When isMultiLeg is true, Trading API V3 treats the payload as one strategy order made from legs.

Rule	Meaning
isMultiLeg: true	Selects the leg-based validation path.
no top-level refId	The instrument lives on each leg through legs[].refId.
top-level side is required	Use side: "BUY" for the strategy order. Leg direction still lives on each leg through the sign of legs[].unitQty.
legs must be non-empty	Each leg needs its own FNO refId and signed unitQty.
qty is the common executable base quantity	Use the base executable quantity derived from the leg lot sizes. For same-lot NIFTY option legs, one strategy unit is typically qty: 65. To scale the full strategy, multiply that base quantity at the top level.
legs[].unitQty is the signed leg lot multiplier	Positive values are buy legs and negative values are sell legs. 1 means one lot of that leg, 2 means two lots of that leg, and so on.
entry and exit controls are top-level	entryPrice, entryConfig, and exitConfig apply to the strategy order, not to individual legs.

Execution Modes

Use executionMode to match the strategy lifecycle fields in the payload.

Payload shape	executionMode	Meaning
The strategy has entryPrice and/or entryConfig, and no exitConfig.	ENTRY	Entry-only multi-leg strategy order.
The strategy has no entryPrice or entryConfig, and has exitConfig.	EXIT	Exit-only multi-leg strategy order.
The strategy has entryPrice and/or entryConfig, and also has exitConfig.	ENTRY_AND_EXIT	Entry multi-leg strategy order with attached stop-loss, target, trailing stop-loss, or timed exit.

Multi-leg execution mode

executionMode is still required for the strategy order. The difference from single order is that isMultiLeg: true moves instrument direction into legs[], while executionMode still describes whether the strategy payload is defining entry, exit, or both.

Strategy side and leg direction

The top-level side is the strategy-level side required by the Trading API V3 strategy order shape. Individual leg direction is controlled by signed legs[].unitQty: positive values are buy legs and negative values are sell legs.

REST Payload Shape

Send one strategy object inside the orders array.

{
  "orders": [
    {
      "isMultiLeg": true,
      "qty": 65,
      "side": "BUY",
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "DAY",
      "executionMode": "ENTRY",
      "entryPrice": 44935,
      "legs": [
        { "refId": 1497712, "unitQty": 1 },
        { "refId": 1497713, "unitQty": -1 }
      ],
      "stratTags": ["rest-api-v3-basic-strategy-order"]
    }
  ]
}

Strategy Order Fields

Field	Type	Required	Allowed values / shape	Meaning
orders	array	yes	one strategy object	Request wrapper. For this page, send one strategy order inside the list.
orders[].isMultiLeg	boolean	yes	true	Enables the leg-based order validation path.
orders[].legs	array	yes	non-empty list	FNO legs inside this one strategy order.
orders[].legs[].refId	int	yes	instrument ref ID	FNO instrument reference ID for that leg.
orders[].legs[].unitQty	int	yes	signed leg lot multiplier	Per-leg lot multiplier. Use positive values for buy legs and negative values for sell legs. 1 means one lot of that leg, 2 means two lots, and so on.
orders[].qty	int	yes	positive integer	Common executable base quantity for the strategy. For same-lot strategies, this is usually the live instrument lot_size. For mixed-lot strategies, use the common executable quantity derived from the leg lot sizes. To scale the full strategy, multiply this base quantity at the top level.
orders[].side	string	yes	BUY	Strategy-level order side required by the current strategy order placement path. Leg buy/sell direction is still represented by signed unitQty.
orders[].deliveryType	string	yes	CNC	Product or delivery type for the strategy order examples. Current Trading API V3 strategy order placement expects CNC for this strategy shape.
orders[].priceType	string	no	LIMIT, MARKET	Price behavior for the strategy order.
orders[].validityType	string	no	DAY, IOC, GTE, AMO	Order validity.
orders[].goodTillDate	string	no	date/time string	Good-till date for supported good-till workflows.
orders[].executionMode	string	yes	ENTRY, EXIT, ENTRY_AND_EXIT	Execution mode for the strategy order. Match this to the entry and exit fields in the payload.
orders[].entryPrice	int	conditional	price integer	Strategy entry price or net price, as expected by Trading API V3. Required for price-based ENTRY and ENTRY_AND_EXIT payloads. Omit for EXIT-only payloads.
orders[].entryConfig	object	no	see below	Delayed or trigger-based strategy entry conditions.
orders[].exitConfig	object	no	see below	Strategy stop-loss, target, trailing stop, or time exit settings.
orders[].algoId	string	no	string	Algo identifier when applicable.
orders[].stratTags	array	no	one hyphenated string inside list	Strategy or tracking tag. Pass exactly one tag inside the list. Tag names must use hyphen-separated text only, such as abc-def. Do not use underscores, spaces, colons, plus signs, timestamps, or other special characters.
orders[].echoFields	string	no	string	Free-form metadata echoed back by Trading API V3.
orders[].orderId	int	no	omit for new create requests	Present in some models, but not normally sent for new create requests.
orders[].refId	int	no	omit	Must be absent when isMultiLeg: true.
orders[].icebergInfo	object	no	omit unless enabled for strategy orders	Iceberg fields exist on the model, but are not part of the normal leg-based strategy shape.

Condition Fields

Field	Type	Required	Allowed values / shape	Meaning
orders[].entryConfig.entryTime	string	no	date/time string	Time at which the strategy entry can activate.
orders[].entryConfig.triggers.ltp	object	no	one or more LTP comparisons	Container for LTP trigger comparisons.
orders[].entryConfig.triggers.ltp.above.value	int	conditional	price integer	Trigger when the live price moves above the threshold.
orders[].entryConfig.triggers.ltp.below.value	int	conditional	price integer	Trigger when the live price moves below the threshold.
orders[].entryConfig.triggers.ltp.atOrAbove.value	int	conditional	price integer	Trigger when the live price reaches or exceeds the threshold.
orders[].entryConfig.triggers.ltp.atOrBelow.value	int	conditional	price integer	Trigger when the live price reaches or falls below the threshold.
orders[].exitConfig.stoplossParams.stoplossTriggerPrice	object	no	{"value": int} or {"disabled": true}	Stop-loss trigger price wrapper.
orders[].exitConfig.stoplossParams.stoplossLimitPrice	object	no	{"value": int} or {"disabled": true}	Stop-loss limit price wrapper.
orders[].exitConfig.stoplossParams.stoplossTrailJump	number	no	number	Trailing stop jump.
orders[].exitConfig.targetParams.targetProfitTriggerPrice	object	no	{"value": int} or {"disabled": true}	Target trigger price wrapper.
orders[].exitConfig.targetParams.targetProfitLimitPrice	object	no	{"value": int} or {"disabled": true}	Target limit price wrapper.
orders[].exitConfig.exitTime	string	no	date/time string	Time-based exit.

Response Shape

{
  "message": "order creation request pushed successfully",
  "orders": [
    {
      "intentOrderId": 9965,
      "exchange": "NSE",
      "status": "OPEN",
      "isMulti": true,
      "legs": [
        {
          "refId": 1497712,
          "unitQty": 1,
          "orderQty": 65,
          "filledQty": 0,
          "filledPrice": 0,
          "refData": {
            "symbol": "NIFTY26JUN23400CE",
            "exchange": "NSE"
          }
        },
        {
          "refId": 1497713,
          "unitQty": 1,
          "orderQty": 65,
          "filledQty": 0,
          "filledPrice": 0,
          "refData": {
            "symbol": "NIFTY26JUN23400PE",
            "exchange": "NSE"
          }
        }
      ],
      "filledQty": 0,
      "orderQty": 65,
      "deliveryType": "CNC",
      "priceType": "LIMIT",
      "validityType": "DAY",
      "executionMode": "ENTRY_AND_EXIT",
      "entryConfig": {
        "conditions": []
      },
      "exitConfig": [],
      "stratTags": ["rest-api-v3-nifty-buy-straddle"],
      "entryPrice": 44935,
      "ltp": 44930,
      "orderPrice": 44935,
      "filledPrice": 0,
      "rejectionMsg": "",
      "timestamps": {
        "intentCreatedAt": 1781600400000
      },
      "positionId": "",
      "intentOrderType": "REGULAR",
      "side": "BUY"
    }
  ]
}

Response Fields

Field	Type	Meaning
message	string	Response message.
orders	array	Created Trading API V3 strategy orders. This request normally returns one item.
orders[].intentOrderId	int	Trading API V3 strategy order identifier.
orders[].status	string	Current order status.
orders[].isMulti	boolean	true for leg-based strategy orders.
orders[].exchange	string	Exchange.
orders[].legs	array	Leg details returned by Trading API V3.
orders[].legs[].refId	int	Leg instrument reference ID.
orders[].legs[].unitQty	int	Signed leg unit quantity.
orders[].legs[].orderQty	int	Expanded leg order quantity.
orders[].legs[].filledQty	int	Filled quantity for the leg.
orders[].legs[].filledPrice	int	Fill price for the leg.
orders[].legs[].refData	object	Leg instrument metadata.
orders[].orderQty	int	Strategy quantity.
orders[].deliveryType	string	Delivery type.
orders[].priceType	string	Price type.
orders[].validityType	string	Validity type.
orders[].executionMode	string	Execution mode.
orders[].entryConfig	object	Entry conditions as returned by Trading API V3.
orders[].exitConfig	array	Exit triggers as returned by Trading API V3.
orders[].stratTags	array	Strategy tag echoed back inside a one-item list. Tag values use hyphen-separated text only.
orders[].echoFields	string	Echo metadata.
orders[].entryPrice	int	Strategy entry price.
orders[].ltp	int	Latest traded price.
orders[].orderPrice	int	Order price.
orders[].filledPrice	int	Fill price.
orders[].rejectionMsg	string	Rejection reason when rejected.
orders[].timestamps	object	Lifecycle timestamps.
orders[].positionId	string	Position identifier when available.
orders[].intentOrderType	string	Trading API V3 intent order type.

Important Rules

Important Rules

• This is one strategy order, not multiple independent orders.
• isMultiLeg must be true.
• legs must be non-empty.
• Top-level refId must be absent.
• Top-level side should be BUY for the strategy shape; leg direction is represented by signed legs[].unitQty.
• Use FNO refId values in legs[].
• Use deliveryType: "CNC" for the strategy order payload.
• executionMode is required.
• Pass only one tag inside stratTags, for example ["abc-def"].
• Use hyphen-separated tag names only, for example abc-def. Do not use underscores, spaces, colons, plus signs, timestamps, or other special characters.
• Use qty as the common executable strategy quantity and legs[].unitQty as the per-leg signed lot multiplier.
• Use integer paise for all prices, and snap limit or trigger values to the contract tick_size.
• Use ENTRY_AND_EXIT when the same strategy payload has both entry fields and exitConfig.
• Do not send a top-level multiplier field.
• Use Get Order Margin before placement when margin impact matters.

What To Read Next

1. Get Orders
2. Modify Order
3. Cancel Order
4. Get Order Margin