Direct answer
In forex, “Multiple Targets” generally means placing a set of take-profit orders at different price levels for the same position, so the position can close in parts rather than all at one exit price. The mechanism is about how the orders are defined and how the platform executes them when the market reaches one or more of those target levels. Multiple Targets does not guarantee a particular outcome; the actual sequence depends on execution details and market movement.
Mechanism and definition
A simple way to model the idea is to separate three concepts:
- The position you want to close
- You start with a position size (for example, “the trade volume”), often thought of as the total amount that could be closed.
- The targets
- Instead of one take-profit price, you define multiple target prices (Target A, Target B, etc.).
- The allocation of the exit
- For “Multiple Targets” to be operational, you must specify how much of the position is intended to close at each target. Common allocation approaches in platforms include:
- Equal parts (e.g., 50% at the first target and 50% at the second), or
- Custom splits (e.g., 30% at Target A, 70% at Target B), or
- A final remainder rule (e.g., after earlier targets fill, the remaining size is managed by another take-profit or a different order rule).
What “sequence” means here
When price moves, one target might be hit before another. The platform’s order logic then determines:
- whether the portion assigned to the first target closes when that level is reached,
- whether later targets remain active for any remaining portion,
- how to treat any leftover size if only some targets are reached.
A key point is that “Multiple Targets” is an order-management concept. The market does not decide “how many targets you chose”; it only moves. The platform decides which orders get filled and in what order.
Inputs and outputs (what you need to specify, and what you get back)
To understand how Multiple Targets works, think in terms of inputs (what you configure) and outputs (what you observe afterward).
Inputs to specify
- Position size (total volume): the amount you intend to have open initially.
- Target prices: the different price levels for take-profit.
- Allocation per target: what fraction (or specific volume) closes at each target.
- Order behavior on partial fills: whether the platform can close exactly the requested portion or may fill partially due to execution conditions.
- Interaction with stop-loss (if present): if you also use a stop-loss, the platform may close the remaining portion when the stop-loss level is hit before all targets are filled.
Outputs you should be able to check
- Which targets filled: did Target A fill, Target B fill, or neither?
- How much closed at each target: not just “did it fill,” but the realized closed amount per target.
- What happened to the remainder: after some targets fill, does any portion remain open, get canceled, or get managed by a separate rule.
Because execution details vary by provider and platform, two users with the same target prices and allocations might observe different filled amounts if fills differ. This is why it’s important to verify the platform’s exact order behavior.
Evidence or example (with explicit assumptions)
Below is a conceptual example to show the mechanics. It is not a prediction.
Assumptions for the example
- Total position size: 1.00 lot (consider this as 100% of the position).
- Two take-profit targets:
- Target A at a higher price level.
- Target B at a lower price level.
- Allocation:
- 50% intended to close at Target A.
- 50% intended to close at Target B.
- Market movement occurs in only one direction at a time (for simplicity), and we assume fills happen when the price reaches the target.
Scenario 1: Price reaches Target A first
- Price moves up and reaches Target A.
- The platform closes the portion allocated to Target A: 50%.
- The remaining 50% stays open with Target B still relevant, unless your platform cancels remaining targets after partial closure.
- If price later moves down and reaches Target B, the remaining 50% closes there.
Resulting output to verify: Target A filled for 50%, Target B filled for the remaining 50% (or Target B did not fill if price never returned).
Scenario 2: Price reaches Target B first
The sequence reverses:
- Price moves down to Target B.
- The portion allocated to Target B closes: 50%.
- The remaining 50% waits for Target A unless canceled by platform rules.
- If price later moves up to Target A, the remainder closes.
Resulting output to verify: Target B filled first, and whether Target A later filled.
Scenario 3: Price never reaches one of the targets
If price reaches only Target A and then reverses before hitting Target B, then only the portion allocated to Target A will have closed. The remainder may stay open, be closed by another order, or be managed by a different rule depending on your configuration.
Limitations and risks (material failure modes)
Multiple Targets can behave differently from what a user expects, because the concept depends on execution mechanics and platform-specific order handling.
1) Partial fills and allocation mismatch
Even if you intend “exactly 50%,” real execution may produce outcomes that differ due to how the platform calculates fill size and how liquidity conditions affect fills. This can lead to:
- one target filling with slightly less or more than planned, and
- the remainder becoming a size that no longer matches your original mental model.
2) Target reach vs. execution
A target being “reached” in charts does not automatically guarantee the order will fill exactly as assumed. Real fills depend on:
- price movement timing,
- execution latency, and
- the platform’s handling of price precision and order triggering.
3) Interaction with other orders
If you also use a stop-loss or other exit rules, the platform may close the position before all targets can fill. In that case:
- later targets might never get a chance to execute, and
- you might observe only the first (or none) of the intended take-profit events.
4) Provider or platform order rules
Different providers and platforms can implement Multiple Targets differently (for example, whether remaining targets are kept active after a partial exit).