---
id: "M:cAlgo.API.Indicator.ModifyPositionAsync(cAlgo.API.Position,System.Double,System.Action{cAlgo.API.TradeResult})"
kind: "method"
type: "T:cAlgo.API.Indicator"
url: "https://help.ctrader.com/ctrader-algo/references/General/Indicator/ModifyPositionAsync/"
---

> Documentation index for agents: https://help.ctrader.com/ctrader-algo/llms.txt · machine index: https://help.ctrader.com/ctrader-algo/api.json

# Indicator.ModifyPositionAsync

Member of [Indicator](https://help.ctrader.com/ctrader-algo/references/General/Indicator/index.md).

## ModifyPositionAsync(Position position, double volume, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, double volume, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, volume: float, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `volume` (`double`, Python `float`): New volume
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10000, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10000, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, double? stopLoss, double? takeProfit, ProtectionType? protectionType, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, double? stopLoss, double? takeProfit, ProtectionType? protectionType, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`double?`, Python `float | None`): New stop loss
- `takeProfit` (`double?`, Python `float | None`): New take profit
- `protectionType` (`ProtectionType?`, Python `ProtectionType | None`): New protection type
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.1.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10000, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10000, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], 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.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], 10, 20, ProtectionType.Relative, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10, 20, ProtectionType.Relative, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss
- `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10000, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10000, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], 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.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss
- `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10000, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10000, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], new AbsoluteStopLossProtection(10), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 10), new AbsoluteTakeProfitProtection(2000, 20), new AbsoluteTakeProfitLastProtection(30)), result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], AbsoluteStopLossProtection(10), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 10), AbsoluteTakeProfitProtection(2000, 20), AbsoluteTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `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<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10000, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10000, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], 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.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], 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.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `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<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10000, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10000, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], new AbsoluteStopLossProtection(10), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 10), new AbsoluteTakeProfitProtection(2000, 20), new AbsoluteTakeProfitLastProtection(30)), result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], AbsoluteStopLossProtection(10), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 10), AbsoluteTakeProfitProtection(2000, 20), AbsoluteTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], new AbsoluteStopLossProtection(10), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 10), new AbsoluteTakeProfitProtection(2000, 20), new AbsoluteTakeProfitLastProtection(30)), new StopLossBreakEven(15, 3), result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], AbsoluteStopLossProtection(10), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 10), AbsoluteTakeProfitProtection(2000, 20), AbsoluteTakeProfitLastProtection(30)), StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, double? stopLoss, double? takeProfit, ProtectionType? protectionType, bool hasTrailingStop, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, double? stopLoss, double? takeProfit, ProtectionType? protectionType, bool hasTrailingStop, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`double?`, Python `float | None`): New stop loss price
- `takeProfit` (`double?`, Python `float | None`): New take profit price
- `protectionType` (`ProtectionType?`, Python `ProtectionType | None`): Protection type
- `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.1.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10, 20, ProtectionType.Relative, true, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10, 20, ProtectionType.Relative, True, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, bool hasTrailingStop, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, bool hasTrailingStop, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss
- `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits
- `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10000, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10000, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], 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.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), true, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), True, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, bool hasTrailingStop, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, bool hasTrailingStop, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss
- `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits
- `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10000, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10000, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], new AbsoluteStopLossProtection(10), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 10), new AbsoluteTakeProfitProtection(2000, 20), new AbsoluteTakeProfitLastProtection(30)), result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], AbsoluteStopLossProtection(10), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 10), AbsoluteTakeProfitProtection(2000, 20), AbsoluteTakeProfitLastProtection(30)), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

C#:

```csharp
ModifyPositionAsync(Positions[0], new AbsoluteStopLossProtection(10), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 10), new AbsoluteTakeProfitProtection(2000, 20), new AbsoluteTakeProfitLastProtection(30)), true, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], AbsoluteStopLossProtection(10), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 10), AbsoluteTakeProfitProtection(2000, 20), AbsoluteTakeProfitLastProtection(30)), True, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss
- `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits
- `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position
- `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), true, new StopLossBreakEven(15, 3), result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), True, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, bool hasTrailingStop, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss
- `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits
- `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position
- `stopLossBreakEven` (`StopLossBreakEven`, Python `StopLossBreakEven`): Break-even for position's StopLoss
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], new AbsoluteStopLossProtection(10), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 10), new AbsoluteTakeProfitProtection(2000, 20), new AbsoluteTakeProfitLastProtection(30)), true, new StopLossBreakEven(15, 3), result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], AbsoluteStopLossProtection(10), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 10), AbsoluteTakeProfitProtection(2000, 20), AbsoluteTakeProfitLastProtection(30)), True, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, double? stopLoss, double? takeProfit, ProtectionType? protectionType, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, double? stopLoss, double? takeProfit, ProtectionType? protectionType, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: float | None, takeProfit: float | None, protectionType: ProtectionType | None, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`double?`, Python `float | None`): New stop loss
- `takeProfit` (`double?`, Python `float | None`): New take profit
- `protectionType` (`ProtectionType?`, Python `ProtectionType | None`): Protection type
- `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position
- `stopLossTriggerMethod` (`StopTriggerMethod?`, Python `StopTriggerMethod | None`): Trigger method for position's StopLoss
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.1.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], 10, 20, ProtectionType.Relative, true, StopTriggerMethod.Trade, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], 10, 20, ProtectionType.Relative, True, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss
- `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits
- `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position
- `stopLossTriggerMethod` (`StopTriggerMethod?`, Python `StopTriggerMethod | None`): Trigger method for position's StopLoss
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), true, StopTriggerMethod.Trade, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), True, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss
- `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits
- `hasTrailingStop` (`bool`, Python `bool`): Enable/disable TrailingStop for position
- `stopLossTriggerMethod` (`StopTriggerMethod?`, Python `StopTriggerMethod | None`): Trigger method for position's StopLoss
- `callback` (`Action<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], new AbsoluteStopLossProtection(10), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 10), new AbsoluteTakeProfitProtection(2000, 20), new AbsoluteTakeProfitLastProtection(30)), true, StopTriggerMethod.Trade, result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], AbsoluteStopLossProtection(10), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 10), AbsoluteTakeProfitProtection(2000, 20), AbsoluteTakeProfitLastProtection(30)), True, StopTriggerMethod.Trade, lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, RelativeStopLossProtection stopLoss, RelativeTakeProfitProtections takeProfits, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: RelativeStopLossProtection, takeProfits: RelativeTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`RelativeStopLossProtection`, Python `RelativeStopLossProtection`): Relative Stop loss
- `takeProfits` (`RelativeTakeProfitProtections`, Python `RelativeTakeProfitProtections`): Relative Take profits
- `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<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], new RelativeStopLossProtection(10), new RelativeTakeProfitProtections(new RelativeTakeProfitProtection(1000, 10), new RelativeTakeProfitProtection(2000, 20), new RelativeTakeProfitLastProtection(30)), true, StopTriggerMethod.Trade, new StopLossBreakEven(15, 3), result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], RelativeStopLossProtection(10), RelativeTakeProfitProtections(RelativeTakeProfitProtection(1000, 10), RelativeTakeProfitProtection(2000, 20), RelativeTakeProfitLastProtection(30)), True, StopTriggerMethod.Trade, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```

## ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)

Modify Position in asynchronous execution mode

Environments: Desktop supported · CLI supported · Cloud supported.

C#:

```csharp
public TradeOperation ModifyPositionAsync(Position position, AbsoluteStopLossProtection stopLoss, AbsoluteTakeProfitProtections takeProfits, bool hasTrailingStop, StopTriggerMethod? stopLossTriggerMethod, StopLossBreakEven stopLossBreakEven, Action<TradeResult> callback)
```

Python:

```python
api.ModifyPositionAsync(position: Position, stopLoss: AbsoluteStopLossProtection, takeProfits: AbsoluteTakeProfitProtections, hasTrailingStop: bool, stopLossTriggerMethod: StopTriggerMethod | None, stopLossBreakEven: StopLossBreakEven, callback: Callable[[TradeResult], None]) -> TradeOperation
```

### Parameters

- `position` (`Position`, Python `Position`): Position to modify
- `stopLoss` (`AbsoluteStopLossProtection`, Python `AbsoluteStopLossProtection`): Absolute Stop loss
- `takeProfits` (`AbsoluteTakeProfitProtections`, Python `AbsoluteTakeProfitProtections`): Absolute Take profits
- `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<TradeResult>`, Python `Callable[[TradeResult], None]`): Method that is called when position is modified

### Returns

`TradeOperation` — Trade Operation

Available since cAlgo.API 5.8.

### Examples

C#:

```csharp
ModifyPositionAsync(Positions[0], new AbsoluteStopLossProtection(10), new AbsoluteTakeProfitProtections(new AbsoluteTakeProfitProtection(1000, 10), new AbsoluteTakeProfitProtection(2000, 20), new AbsoluteTakeProfitLastProtection(30)), true, StopTriggerMethod.Trade, new StopLossBreakEven(15, 3), result => Print("Trade operation successful: {0}", result.IsSuccessful));
```

Python:

```python
api.ModifyPositionAsync(api.Positions[0], AbsoluteStopLossProtection(10), AbsoluteTakeProfitProtections(AbsoluteTakeProfitProtection(1000, 10), AbsoluteTakeProfitProtection(2000, 20), AbsoluteTakeProfitLastProtection(30)), True, StopTriggerMethod.Trade, StopLossBreakEven(15, 3), lambda result: api.Print(f"Trade operation successful: {result.IsSuccessful}"))
```