We rewrite MT5 Expert Advisors as Quantower strategies and MT5 indicators as Quantower indicators in C# — rebuilding positions, sizes and sessions for your Quantower connection, and checking the result against criteria agreed with you.
iMA(…, MODE_EMA, …) + CopyBuffer(…)Core.Indicators.BuiltIn.EMA(21, PriceType.Close)SetIndexBuffer(0, EmaBuffer)AddLineSeries("EMA", Color.DodgerBlue, 2)CopyRates(_Symbol, PERIOD_H1, …)Symbol.GetHistory(Period.HOUR1, …)trade.Buy(lots, _Symbol)Core.Instance.PlaceOrder(… Side.Buy …)Same logic, rebuilt on Quantower’s C# API
MT5 to Quantower conversion means rewriting MQL5 code in C# on Quantower’s API: an Expert Advisor becomes a Quantower strategy and an indicator becomes a Quantower indicator. The move can keep the same market — depending on your connection, Quantower works with forex brokers as well as futures, stock and crypto feeds — or change it. If the instrument changes, trade sizes, price distances and sessions are adapted as well.
An MT5 Expert Advisor and a Quantower strategy automate the same kind of trading, but they track positions, size trades and react to new data differently. Converting an EA keeps its trading rules and rebuilds its trade handling for Quantower and your connection.
Trade calls built around MT5 positions, orders and deals are rebuilt with Quantower’s trading methods, together with the logic that runs after them — confirmations and partial fills, cancellations and rejections, and protection set after a deal. One MT5 trade operation can produce several trade transactions, so this logic is mapped step by step.
Position handling depends on your Quantower connection — one net position or separate positions — so it is checked and agreed, together with how the strategy runs alongside other strategies and manual trades, and what it does if a position is already open at start.
Position sizes are recalculated using the target symbol’s lot size, volume limits and step, then checked against your risk rules.
Stop loss, take profit, trailing stop and breakeven are placed as protective orders your connection supports, with price distances converted for the symbol.
Each MT5 symbol is matched to a symbol on your Quantower connection. If the instrument changes, the strategy is adapted to its tick size, tick value and sessions.
Logic written to act once per bar keeps that timing, and tick-by-tick logic is rebuilt on the quote or trade events of your connection — the agreed calculation mode is kept, and signal timing is checked on the chosen data.
Results in Quantower won’t match the MT5 Strategy Tester exactly: the platforms use different data — sometimes for a different instrument — and model fills differently. We check that entries and exits follow the agreed rules.
Converting an MT5 indicator to Quantower means rebuilding its calculations on Quantower’s API and how it draws on the chart. We convert standard, custom and multi-timeframe indicators, as well as panels and dashboards.
Calculations are rebuilt in C#; buffers become line series, histograms keep their style, and arrows become markers. Any visual differences are agreed in advance.
MQL5 calculations built on indicator handles and CopyBuffer become direct indicator calls in Quantower, checked bar by bar.
Data from other timeframes or symbols is loaded as separate history and keeps the original’s behaviour — from the forming bar or from confirmed bars only.
Lines, labels, boxes and panels drawn as chart objects become drawings, markers or custom painting in Quantower; the look is agreed separately.
Calls to MT5’s built-in indicators use Quantower’s own indicators where their values match; where the platforms calculate differently, we write the calculation ourselves.
Alert conditions are built into the Quantower version, and new settings or functions can be added on request.
MetaTrader 5 and Quantower handle instruments, positions and code in different ways. These are the differences that decide whether a converted script behaves like the original — and what we do about each of them.
Forex, CFDs and other symbols from your MT5 broker
Symbols from your Quantower connection — futures, crypto, stocks or forex
If the instrument changes, we agree which one replaces each MT5 symbol and adapt sizes, price distances and sessions.
Lots, sized by the MT5 symbol’s contract
Quantity in lots, with the lot size and step set by each symbol
Sizes are recalculated with the target symbol’s lot size, volume limits and step, and checked against your risk rules.
Separate positions on a hedging account; one shared position per symbol on a netting account
Position handling depends on your connection — one net position or separate positions
We map each entry and its exits, and agree how the strategy works alongside other strategies, manual trades and positions already open at start.
Arrays and buffers that can be indexed in either direction
History that can be read from the newest or the oldest bar
We check the reading direction for every series, so values line up bar by bar.
An EA reacts to tick events for its chart symbol; bar-close logic checks for a new bar
A strategy reacts to the quote, trade and bar events it subscribes to — new quotes and new trades are separate events
We keep the agreed conditions and calculation timing, and check historical and real-time behaviour separately.
Your MT5 broker’s server time
The session settings of your connection and the bar timestamps it provides
We compare sessions, bar timestamps and the time zone each version’s logic uses — matching chart clocks alone isn’t enough.
The MT5 Strategy Tester and its tick modelling
Quantower’s own backtesting and optimisation
We agree how both backtests are run, so they are compared on similar assumptions.
Some things depend on the platform itself: native DLLs the EA calls are checked one by one — .NET libraries can often be used directly; symbols your Quantower connection doesn’t provide; and real traded volume, which depends on your feed. We point these out before work starts and agree the closest Quantower equivalent with you.
A converter or an AI pass can produce C# quickly. The risk is not the tool but an unchecked result: code can compile and still trade differently, because MetaTrader and Quantower read history, size trades and track positions differently. We start from how the MT5 version behaves and rebuild it on Quantower’s API.
| Automatic conversion | Manual conversion at Nordman Algorithms | |
|---|---|---|
| Starting point | Often the MQL syntax, statement by statement | How the MT5 version behaves |
| Platform differences | Often found later, if at all | Identified before work starts and agreed with you |
| Positions and sizes | Positions, deals and lots copied as they are | Rebuilt for your Quantower connection and symbol units |
Send it to us — we review it and give you a fixed price and timeline before work starts.
We run the MT5 original and the Quantower version on the same timeframe, with comparable price types, trading sessions and bar timestamps, and compare them against acceptance criteria agreed with you:
If the instrument stays the same, we compare values and signal timing directly. If it changes — say, from a forex pair to a futures contract — the data differ, so we check that the agreed rules are followed and the risk is recalculated correctly, rather than expecting identical values or trades. If something doesn’t match, we find the cause — price data, platform behaviour or the code.
Share the .mq5 source with its .mqh include files, the source of any custom indicators it calls and your .set file if you have one — plus a short description.
You sendSource + dependenciesWe analyse the code, agree the Quantower connection, symbol and sessions — the same market or a new one — and agree settings, acceptance criteria, price and timeline.
You getFixed price + criteriaThe EA or indicator is rebuilt as a Quantower strategy or indicator, including any extra features you asked for.
We buildThe Quantower versionThe Quantower version is checked against the acceptance criteria agreed in step 2.
We checkValues, signals, tradesBugs and differences from the agreed specification are fixed after delivery.
You getSource + files to runEvery EA and indicator is reviewed before we quote. These are the main factors.
How much logic the code contains and how many parts depend on each other.
For EAs: how orders, positions, stops, scaling and partial closes are managed.
Which Quantower connection and symbols the strategy will trade — the same market or a new one.
Objects, panels and dashboards drawn on the chart.
Each dependency is checked: whether a .NET library can be used directly or a replacement is needed.
Conversion needs the .mq5 source. Without it, recreating the EA or indicator from your description is assessed separately.
No. Quantower runs C# written against its own API; MQL5 code — .mq5 or .ex5 — has to be rewritten.
Yes. The EA’s trading rules are kept and its trade handling is rebuilt for Quantower — quantity, positions, protective orders and any extra trade management — with sizing and risk agreed with you.
If your Quantower connection provides the same symbols, you don’t need to change markets — but the symbol’s specification, position size, price type, trading hours and execution rules are still checked. If you move to another market — say, futures — sizes, price distances and sessions are adapted, and how the strategy behaves there is checked against the agreed rules.
Yes. For indicators, the connection decides which symbols, history and volume data are available. For strategies, it also decides the order types, execution and position handling. We agree the connection before work starts and build for it.
On the same market, values can come close but not always match exactly: your MT5 broker and your Quantower connection provide different data, and some built-in indicators are calculated slightly differently. If the instrument changes, identical values aren’t the goal — we check that the agreed rules are followed and the risk is recalculated correctly.
Quantower has its own backtesting and optimisation, and whether a particular strategy’s logic can be reproduced on history there is checked before work starts. Results won’t match the MT5 Strategy Tester exactly: the platforms use different data and model fills differently.
Conversion needs the .mq5 source code. Without it, we can assess recreating the EA or indicator from your description, settings and examples of how it behaves — but an exact match with the original can’t be promised in advance.
Yes. Quantower indicators and strategies can be rewritten in MQL5; parts that rely on Quantower-only features are agreed before work starts.
It depends on the size of the code, the trade handling, the indicators it calls, visual elements and any DLLs. After reviewing your .mq5 code we give you a fixed price and an estimated timeline before work starts.
Share the .mq5 source code with its include files and the custom indicators it uses, and a short description of what it does and which Quantower connection it should trade through. We will review it and give you a fixed price and timeline before work starts.