Synthetic crosses — constructing one currency cross from two others (for example EUR/JPY = EUR/USD × USD/JPY) — remain a practical edge for traders who can detect and exploit small, short-lived dislocations between direct cross prices and their synthetic equivalents. This guide walks through building, backtesting and deploying an intraday EUR/JPY strategy that uses synthetic crosses to locate mean‑reversion opportunities while accounting for market structure realities in mid‑2026: fragmented liquidity, tighter algorithmic quoting, and variable dealer behaviour across Tokyo, London and New York sessions.

Why use a synthetic‑cross intraday strategy?

There are three concrete reasons traders deploy synthetic crosses intraday:

  • Price discrepancies: Direct EUR/JPY quotes sometimes diverge from the synthetic EUR/USD × USD/JPY mid when liquidity is thin or when market participants price legs asymmetrically.
  • Execution control: Using a two‑leg synthetic trade lets you size and route legs separately — useful if liquidity or spreads differ materially between EUR/USD and USD/JPY at a given time.
  • Relative value signal: The difference between direct and synthetic prices is a high‑frequency relative‑value signal that often mean‑reverts within minutes to hours.

Preconditions and realistic expectations

This strategy is market‑structure dependent. Expect small gross price moves — typical exploitable deviations are measured in single to low double digits of fractional percent (e.g., a few pips on EUR/JPY). Profiting requires disciplined cost modelling (spreads, commissions, slippage), fast tick or 1‑s resolution data for backtesting, and reliable execution. This is not a long‑term carry strategy; it’s an execution‑ and market‑microstructure play.

Step 1 — Define the signal and entry rules

Signal construction (example):

  1. Compute the synthetic mid: synth_mid_t = mid(EUR/USD)_t × mid(USD/JPY)_t, using mid prices (bid+ask)/2 at tick or 1‑second granularity.
  2. Capture the direct mid: direct_mid_t = mid(EUR/JPY)_t.
  3. Define the deviation: dev_t = (direct_mid_t − synth_mid_t) / synth_mid_t (relative difference).
  4. Estimate rolling mean μ_t and rolling standard deviation σ_t of dev over a lookback window (e.g., 60 trading days on 1‑minute bars or 30 trading days on 5‑minute bars for intraday work).
  5. Entry condition: when dev_t > μ_t + k·σ_t (overvalued direct EUR/JPY) or dev_t μ_t − k·σ_t (undervalued), with k commonly 1.5–3 depending on your risk tolerance. Example: k = 2 for a moderately selective filter.
  6. Trade direction: if direct is expensive (dev positive and above threshold), short direct EUR/JPY and buy the synthetic legs (buy EUR/USD and sell USD/JPY) sized to replicate notional exposure; inverse for opposite case.
  7. Time‑of‑day filter: limit trading to the most liquid intraday windows (e.g., London open 07:00–10:00 UTC and New York overlap 12:00–16:00 UTC) to reduce execution cost risk.

Step 2 — Data and backtest design

Data is the foundation. For credible backtests you need tick or 1‑second data for EUR/USD, USD/JPY and EUR/JPY (or the best available sub‑second feeds). Sources commonly used by practitioners:

  • Dukascopy tick data for retail‑access historical ticks.
  • Broker-provided historical ticks if testing on broker execution (mobile platforms, ECN feeds).
  • Institutional feeds (EBS/Refinitiv/LMAX) if available to you — these better capture interbank quotes.

Backtest plumbing:

  • Synchronise timestamps across feeds to the same clock (UTC) and align ticks or resample to uniform bars (1s or 1min) carefully — prefer tick‑level arithmetic where possible.
  • Model spreads explicitly: use historical best bid/ask where available. Synthetic spread = spread_leg1 × price_leg2 + spread_leg2 × price_leg1 (approximation); practically, synthetic effective spread is the sum of leg spreads adjusted by prices.
  • Include commission and slippage models: slippage can be modeled as a function of quoted spread, recent trade volume and time‑of‑day; use conservative estimates (e.g., add 0.2–0.5 pip slippage per leg in normal liquidity, more in thin Asian hours).
  • Latency costs: if your execution is not co‑located or you use retail APIs, add an execution latency penalty (e.g., 10–200 ms) and test order fills under delayed price updates.
  • Rollouts: test multiple thresholds and lookback windows and use walk‑forward validation — do not rely on a single in‑sample period.

Step 3 — Sizing, hedging and execution logic

Sizing and hedging must respect triangular relationships and currency pair notional equivalence:

  • Notional equivalence: one unit of direct EUR/JPY exposure equals one unit of EUR/USD priced in USD then converted via USD/JPY — compute leg sizes so P&L of the synthetic equals direct exposure at outset.
  • Execution order types: use IOC marketable limit orders for legs if available, or limit orders with small ticks beyond mid to reduce adverse selection. Consider pegged or midpoint orders where supported.
  • Routing: if you can, route legs to venues with narrower spreads per leg. For example, EUR/USD may be greenlit on an ECN and USD/JPY on a different pool — optimizing per leg reduces overall costs.
  • Hedging imbalance: partial fills on one leg create residual exposure; implement a fill‑management routine — e.g., cancel remaining legs if one leg fails to fill within X ms, or hedge residual quickly with a market order sized to cap directional exposure.

Step 4 — Risk controls and exits

Standard risk controls for intraday execution:

  • Stop loss: set a monetary or pip stop for each trade. For intraday EUR/JPY, sensible example stops are 15–40 pips depending on timeframe (example only).
  • Time stop: close the trade if not mean‑reverted within a time window (e.g., 30–120 minutes) to avoid overnight carry risk.
  • Daily loss limit: stop trading for the day after X% drawdown (commonly 1–2% of equity for intraday strategies).
  • Fill imbalance cap: abort trade if leg fill ratio threshold (e.g., if synthetic legs fill 90% within Y ms), to avoid directional gamma exposure.
  • Real‑time spread filter: cancel entries when aggregate leg spreads widen beyond a multiple of historical medians (e.g., > 2× median spread for that hour), which often precedes liquidity evaporation.

Step 5 — Backtest metrics and evaluation

Key metrics to evaluate:

  • Net P&L after spreads, commissions and measured slippage.
  • Win rate and average win/loss ratio for intraday horizons.
  • Sharpe ratio (use intraday annualisation carefully) and Sortino ratio.
  • Maximum intraday drawdown and average time‑to‑exit.
  • Realised fill rate per leg and time‑to‑fill statistics — the operational metric often kills strategies despite attractive gross signals.

Crucially, report results with realistic costs. A common error is to backtest on mid prices but execute against the bid/ask; always measure P&L against executed prices including both legs’ costs.

Illustrative backtest setup (example)

To illustrate a conservative test design you can replicate:

  • Universe: EUR/USD, USD/JPY, EUR/JPY tick data 2019–2025 (or your best available 3–5 year window).
  • Resample: 1‑second mid prices, compute synth and direct dev series.
  • Signal: dev > μ + 2σ or dev μ − 2σ with μ/σ from rolling 30‑day 1‑minute series.
  • Time window: trade only between 07:00–15:00 UTC to capture London and NY overlap.
  • Costs: use historical bid/ask where available; otherwise add spread estimates (EUR/USD 0.4–0.8 pip, USD/JPY 0.3–0.7 pip, EUR/JPY 0.6–1.5 pip depending on hour) and commission 0.02% round‑turn; slippage 0.2 pip per leg in normal hours.
  • Exits: mean‑reversion to mid or fixed take profit at 0.15% and time stop 90 minutes.

Run walk‑forward tests and report both in‑sample and out‑of‑sample performance. Emphasise execution metrics: if fill rates or slippage in live tests exceed backtest assumptions, re‑calibrate.

Deployment checklist

Before going live with capital, validate these items:

  1. Data parity: ensure your live pricing feed and backtest feed are comparable (venue, aggregator or broker). Differences here are the largest source of mismatch.
  2. Order management: build robust two‑leg order management to manage partial fills, latencies, cancellations and re‑pricing.
  3. Monitoring: real‑time dashboards for leg fills, synthetic/direct deviation, spread multipliers and session heatmaps.
  4. Simulated trading: run the strategy in paper mode against live market data for several weeks to measure actual fills and slippage.
  5. Capital and risk limits: define max notional per trade, daily max trades and max exposure per currency pair.

Operational pitfalls and mitigation

Common operational failure modes with synthetic‑cross strategies and quick mitigations:

  • Partial fills creating directional exposure — mitigation: auto‑hedge residual with market order capped at safety size.
  • Latency mismatch between legs — mitigation: implement leg sequencing rules (execute the cheaper leg first) and use limit IOC to minimise time risk.
  • Data timestamp misalignment — mitigation: normalise to a single exchange clock and use time‑synchronisation libraries (NTP or PTP where available).
  • Sudden volatility spikes (news) — mitigation: incorporate real‑time news and economic calendar filters; widen spread thresholds around scheduled releases or block trading during major prints.

Monitoring and continuous improvement

Once live, treat this as an execution business:

  • Track per‑leg liquidity and spreads by hour and update slippage models monthly.
  • Recalculate μ/σ on rolling windows and check for regime shifts — increased volatility or structural changes (e.g., new liquidity providers) will change historic behaviour.
  • Maintain an incident log for misfills, outages and large slippage events. Use these events to harden rules (e.g., stricter spread filters).

Conclusion

Synthetic‑cross intraday strategies such as EUR/JPY constructed from EUR/USD and USD/JPY can be a reliable relative‑value microstructure play when designed with realistic execution and risk models. The strategy’s viability depends less on the raw signal and more on rigorous cost modelling, fill management and solid operational controls. Start with conservative assumptions, validate with live paper trading, and scale only after confirming that real‑world fills match backtest expectations.

Appendix — quick resources

  • Dukascopy historical tick data (retail accessible)
  • LMAX and EBS for institutional reference pricing
  • Python libraries: pandas for time series, numpy, vectorbt for vectorised backtests, and custom tick replay engines for fine‑grain testing
  • Order connectivity: use FIX for low‑latency two‑leg execution where possible; REST/APIs for smaller or retail setups.