--- id: "M:cAlgo.API.Robot.PlaceLimitOrderAsync(cAlgo.API.TradeType,System.String,System.Double,System.Double,System.Action{cAlgo.API.TradeResult})" kind: "method" type: "T:cAlgo.API.Robot" url: "https://help.ctrader.com/ctrader-algo/references/General/Robot/PlaceLimitOrderAsync/" --- > Documentation index for agents: https://help.ctrader.com/ctrader-algo/llms.txt · machine index: https://help.ctrader.com/ctrader-algo/api.json # Robot.PlaceLimitOrderAsync Member of [Robot](https://help.ctrader.com/ctrader-algo/references/General/Robot/index.md). ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`double?`, Python `float | None`): Stop loss - `takeProfit` (`double?`, Python `float | None`): Take profit - `protectionType` (`ProtectionType?`, Python `ProtectionType | None`): Protection type - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.1. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), new StopLossBreakEven(15, 3), result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", new AbsoluteStopLossProtection(1.0), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 1.05), new AbsoluteTakeProfitProtection(2000, 1.06), new AbsoluteTakeProfitLastProtection(1.07)), result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", AbsoluteStopLossProtection(1.0), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 1.05), AbsoluteTakeProfitProtection(2000, 1.06), AbsoluteTakeProfitLastProtection(1.07)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`double?`, Python `float | None`): Stop loss - `takeProfit` (`double?`, Python `float | None`): Take profit - `protectionType` (`ProtectionType?`, Python `ProtectionType | None`): Protection type - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.1. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), Server.Time.AddDays(1), result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), api.Server.Time.AddDays(1), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`double?`, Python `float | None`): Stop loss - `takeProfit` (`double?`, Python `float | None`): Take profit - `protectionType` (`ProtectionType?`, Python `ProtectionType | None`): Protection type - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.1. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), "order comment", result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), "order comment", lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: 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 - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`double?`, Python `float | None`): Stop loss - `takeProfit` (`double?`, Python `float | None`): Take profit - `protectionType` (`ProtectionType?`, Python `ProtectionType | None`): Protection type - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.1. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), "order comment", true, result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), "order comment", True, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, double? stopLoss, double? takeProfit, ProtectionType? protectionType, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: 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 - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`double?`, Python `float | None`): Stop loss - `takeProfit` (`double?`, Python `float | None`): Take profit - `protectionType` (`ProtectionType?`, Python `ProtectionType | None`): Protection type - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `stopLossTriggerMethod` (`StopTriggerMethod?`, Python `StopTriggerMethod | None`): Trigger method for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.1. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, Server.Time.AddDays(1), "order comment", true, StopTriggerMethod.Trade, result => Print("Trade operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "myLabel", 10, 20, ProtectionType.Relative, api.Server.Time.AddDays(1), "order comment", True, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `stopLossTriggerMethod` (`StopTriggerMethod?`, Python `StopTriggerMethod | None`): Trigger method for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: 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 - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss - `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `stopLossTriggerMethod` (`StopTriggerMethod?`, Python `StopTriggerMethod | None`): Trigger method for position's StopLoss - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: float, label: str, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, expiration: DateTime | None, comment: str, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation ``` ### Parameters - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `stopLossTriggerMethod` (`StopTriggerMethod?`, Python `StopTriggerMethod | None`): Trigger method for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ``` ## PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action callback) Place limit order in asynchronous execution mode Environments: Desktop supported · CLI supported · Cloud supported. C#: ```csharp public TradeOperation PlaceLimitOrderAsync(TradeType tradeType, string symbolName, double volume, double targetPrice, string label, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, DateTime? expiration, string comment, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action callback) ``` Python: ```python api.PlaceLimitOrderAsync(tradeType: TradeType, symbolName: str, volume: float, targetPrice: 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 - `tradeType` (`TradeType`, Python `TradeType`): Direction of trade - `symbolName` (`string`, Python `str`): Symbol name of trade - `volume` (`double`, Python `float`): Volume of trade - `targetPrice` (`double`, Python `float`): Target price (or better) at which the order is filled - `label` (`string`, Python `str`): Label that represents the order - `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss - `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits - `expiration` (`DateTime?`, Python `DateTime | None`): Order expiry date and time - `comment` (`string`, Python `str`): Order comment - `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position - `stopLossTriggerMethod` (`StopTriggerMethod?`, Python `StopTriggerMethod | None`): Trigger method for position's StopLoss - `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss - `callback` (`Action`, Python `Callable[[TradeResult], None]`): The action when the position closes ### Returns `TradeOperation` — Trade Operation Available since cAlgo.API 5.8. ### Examples C#: ```csharp PlaceLimitOrderAsync(TradeType.Buy, Symbol.Name, 10000, Symbol.Ask, "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 operation successful: {0}", result.IsSuccessful)); ``` Python: ```python api.PlaceLimitOrderAsync(TradeType.Buy, api.Symbol.Name, 10000, api.Symbol.Ask, "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 operation successful: {result.IsSuccessful}")) ```