Plugin.PlaceStopLimitOrderAsync

method · Plugin · cAlgo.API

DesktopCLICloud

Place Stop Limit order in asynchronous execution mode

Environment behaviour

CLI — not supported. Plugins cannot run in the CLI: ctrader-cli runs cBots only.

Cloud — not supported. Plugins cannot run in the cloud: it runs cBots only.

Overloads

Signature
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)`
`PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)`

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`double?`	`float \| None`	Stop loss
`takeProfit`	`double?`	`float \| None`	Take profit
`protectionType`	`ProtectionType?`	`ProtectionType \| None`	Protection type
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`double?`	`float \| None`	Stop loss
`takeProfit`	`double?`	`float \| None`	Take profit
`protectionType`	`ProtectionType?`	`ProtectionType \| None`	Protection type
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`double?`	`float \| None`	Stop loss
`takeProfit`	`double?`	`float \| None`	Take profit
`protectionType`	`ProtectionType?`	`ProtectionType \| None`	Protection type
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), "order comment", result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), "order comment", lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), "order comment", result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), "order comment", lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), "order comment", new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), "order comment", StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), "order comment", result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), "order comment", lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), "order comment", new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), "order comment", StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`double?`	`float \| None`	Stop loss
`takeProfit`	`double?`	`float \| None`	Take profit
`protectionType`	`ProtectionType?`	`ProtectionType \| None`	Protection type
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), "order comment", true, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), "order comment", True, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), "order comment", true, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), "order comment", True, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), "order comment", true, new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), "order comment", True, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), "order comment", true, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), "order comment", True, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), "order comment", true, new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), "order comment", True, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`double?`	`float \| None`	Stop loss
`takeProfit`	`double?`	`float \| None`	Take profit
`protectionType`	`ProtectionType?`	`ProtectionType \| None`	Protection type
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`double?`	`float \| None`	Stop loss
`takeProfit`	`double?`	`float \| None`	Take profit
`protectionType`	`ProtectionType?`	`ProtectionType \| None`	Protection type
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`stopOrderTriggerMethod`	`StopTriggerMethod`	`StopTriggerMethod`	Determines how pending order will be triggered in case it is a StopLimitOrder
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, StopTriggerMethod.Trade, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`stopOrderTriggerMethod`	`StopTriggerMethod`	`StopTriggerMethod`	Determines how pending order will be triggered in case it is a StopLimitOrder
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, StopTriggerMethod.Trade, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`RelativeStopLossProtection`	`RelativeStopLossProtection`	Relative Stop loss
`takeProfits`	`RelativeTakeProfitProtections`	`RelativeTakeProfitProtections`	Relative Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`stopOrderTriggerMethod`	`StopTriggerMethod`	`StopTriggerMethod`	Determines how pending order will be triggered in case it is a StopLimitOrder
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, StopTriggerMethod.Trade, new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, StopTriggerMethod.Trade, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`stopOrderTriggerMethod`	`StopTriggerMethod`	`StopTriggerMethod`	Determines how pending order will be triggered in case it is a StopLimitOrder
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, StopTriggerMethod.Trade, result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))

PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Place Stop Limit order in asynchronous execution mode

C#Python

public TradeOperation PlaceStopLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, double stopLimitRangePips, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopTriggerMethod stopOrderTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

api.PlaceStopLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, stopLimitRangePips: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopOrderTriggerMethod: StopTriggerMethod, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation

Parameters

Name	C# type	Python type	Description
`tradeType`	`TradeType`	`TradeType`	Direction of trade
`symbolName`	`string`	`str`	Symbol name of trade
`volume`	`double`	`float`	Volume (in units) of trade
`targetPrice`	`double`	`float`	Price (or better) at which order is filled
`stopLimitRangePips`	`double`	`float`	Maximum distance for order execution from target price
`label`	`string`	`str`	Label representing the order
`stopLoss`	`AbsoluteStopLossProtection`	`AbsoluteStopLossProtection`	Absolute Stop loss
`takeProfits`	`AbsoluteTakeProfitProtections`	`AbsoluteTakeProfitProtections`	Absolute Take profits
`expiration`	`DateTime?`	`DateTime \| None`	Order expiry date and time
`comment`	`string`	`str`	Order comment
`hasTrailingStop`	`bool`	`bool`	Enable/disable TrailingStop for position
`stopLossTriggerMethod`	`StopTriggerMethod?`	`StopTriggerMethod \| None`	Trigger method for position's StopLoss
`stopOrderTriggerMethod`	`StopTriggerMethod`	`StopTriggerMethod`	Determines how pending order will be triggered in case it is a StopLimitOrder
`stopLossBreakEven`	`StopLossBreakEven`	`StopLossBreakEven`	Break-even for position's StopLoss
`callback`	`Action<TradeResult>`	`Callable[[TradeResult], None]`	Action when order is placed

Returns TradeOperation — Trade Operation

Examples

C#Python

PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, StopTriggerMethod.Trade, new StopLossBreakEven(15, 3), result => Print("Trade result: {0}", result.IsSuccessful));

api.PlaceStopLimitOrderAsync(TradeType.Buy, "EURUSD", 10000, api.Symbols.GetSymbol("EURUSD").Ask, 5, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, StopTriggerMethod.Trade, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade result: {result.IsSuccessful}"))