Entries & Exits
Market and pending orders, modifications and closes are rebuilt with Quantower’s trading methods — including scaling in, partial closes and exits tied to specific entries.
cTrader → Quantower Conversion
Convert cTrader cBots & Indicators to Quantower
Both platforms use C#, but a cBot doesn’t run in Quantower as it is. We keep the platform-independent logic, rebuild cBots as Quantower strategies and cTrader indicators as Quantower indicators, and check the result against criteria agreed with you.
cBot to Quantower StrategycTrader Indicator to QuantowercTrader C# to Quantower C#Rewritten by Hand
3,000+ Projects Delivered
Fixed Scope & Price Before Work
Full C# Source Code
Checked Against Agreed Criteria
C# · cTraderC# · Quantower
Indicators.ExponentialMovingAverage(…, 21)Core.Indicators.BuiltIn.EMA(21, PriceType.Close)[Output("EMA")] IndicatorDataSeries EmaAddLineSeries("EMA", Color.DodgerBlue, 2)MarketData.GetBars(TimeFrame.Hour)Symbol.GetHistory(Period.HOUR1, …)ExecuteMarketOrder(TradeType.Buy, "EURUSD", 10000)Core.Instance.PlaceOrder(… Side.Buy …)Same C#, a different API — platform code rebuilt for Quantower
Overview
What cTrader to Quantower Conversion Means
cTrader to Quantower conversion means rebuilding cTrader’s C# code on Quantower’s API: a cBot becomes a Quantower strategy and an indicator becomes a Quantower indicator. Both platforms use C#, so platform-independent calculations can often be kept, while code tied to cTrader’s API is rebuilt. 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, sizes, price distances and sessions are adapted as well.
- From
- C# on cTrader
- To
- C# on Quantower’s API
- cBot
- Quantower strategy
- Indicator
- Quantower indicator
- You receive
- C# source code and everything needed to run it
- Method
- Independent logic kept, platform code rebuilt by hand
cTrader features and how they work in Quantower
| cTrader feature | In cTrader | In Quantower |
|---|---|---|
| Renko, range, tick and Heikin-Ashi charts | Yes | YesQuantower chart types; bars are checked |
| Clouds between lines | Yes | YesQuantower clouds |
| Volume in units | Yes | PartlyQuantity in lots — on EURUSD with a 100,000 contract size, 10,000 units = 0.10 lot |
| Positions found by label | Yes | PartlyPosition handling depends on your connection |
| .NET libraries | Yes | YesUsually compatible; each one is checked |
| cTrader Cloud | Yes | NoThe strategy runs in the terminal |
cBots
Convert a cBot to a Quantower Strategy
A cBot and a Quantower strategy both trade automatically, but they react to data, size trades and track positions differently. Converting a cBot keeps its rules and rebuilds its trade handling for Quantower and your connection.
Positions & Connection
cBots find their positions by label; in Quantower, position handling depends on your 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 Sizing
Volume in units is recalculated as quantity using the target symbol’s lot size, volume limits and step, then checked against your risk rules.
Stops & Targets
Stops and targets set in pips become protective orders your connection supports, as prices or ticks. cBot stops can trigger on the opposite side of the price or after two consecutive quotes, so stop behaviour is checked, not only the distance.
Events & New Bars
In cBots, OnBar runs as a new bar opens and OnBarClosed reads the last closed bar — both wait for the next bar’s first tick. This logic, OnTick logic and position events are rebuilt on Quantower’s quote, trade, bar and position events, matching which bar each piece of logic reads and when orders are sent.
Sessions & Time Zone
The cBot’s time zone and session rules are matched to the bar timestamps and session settings of your Quantower connection.
Results in Quantower won’t match cTrader’s backtest 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.
Indicators
Convert a cTrader Indicator to Quantower
Converting a cTrader indicator to Quantower means rebuilding its calculations, data access and drawing on Quantower’s API. We convert standard, custom and multi-timeframe indicators, as well as panels and dashboards.
Outputs & Clouds
Outputs become line series and clouds stay clouds; platform-independent calculations are kept where possible. Any visual differences are agreed in advance.
Bar Indexing
cTrader series are indexed from the oldest bar, while Quantower history can be read from either end; each series is read in the right direction, so values line up bar by bar.
Other Timeframes & Symbols
Bars requested from other timeframes or symbols become separately loaded history, keeping the original’s behaviour — forming or confirmed values. We also check the original for future-data leakage and agree any corrections before conversion.
Chart Drawings
Lines, text, shapes and panels drawn on the chart become Quantower drawings, markers or custom painting; the look is agreed separately.
Chart Types
Indicators built for Renko, range, tick or Heikin-Ashi charts use Quantower’s own chart types; bars can form slightly differently, so values are checked. For strategies on Heikin-Ashi charts, the recalculated prices used for signals and the real prices orders fill at are checked separately.
Built-In Indicators & Alerts
Calls to cTrader’s built-in indicators use Quantower’s own where their values match — otherwise we write the calculation — and alerts are built into the Quantower version.
Platform differences
cTrader C# to Quantower C#: What Changes and How We Handle It
cTrader and Quantower run C# 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.
Language and API
C# on cTrader’s Automate API
C# on Quantower’s API
Platform-independent calculations and classes can often be kept; code tied to cTrader’s API, events, data and trading is rebuilt for Quantower.
Trade size
Volume in units
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.
Positions
Hedging or netting account; positions found by label
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.
Events
OnBar as a new bar opens and OnBarClosed for the last closed bar — both wait for the next bar’s first tick; OnTick and position events
Quote, trade and bar events the strategy subscribes to, plus position and order events
We match which bar each piece of logic reads — forming or closed — and when orders are sent, and check intrabar behaviour.
Bar indexing
Series indexed from the oldest bar
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.
Price data
Bid-based charts from your cTrader broker
History of the price type you request, from your connection
We match the price type where the connection supports it; otherwise the price basis and comparison criteria are agreed before work starts.
Where the code runs
Locally or in cTrader Cloud
In the Quantower terminal, on your computer or a VPS
If the cBot ran in the cloud, we agree where the Quantower strategy will run.
What may not carry over one to one
Some things depend on the platform itself: cTrader Cloud has no Quantower counterpart; symbols your Quantower connection doesn’t provide; and web requests and file access, which are set up differently in Quantower and checked one by one. We point these out before work starts and agree the closest Quantower equivalent with you.
Same language, different platform
Why the Same Language Isn’t Enough
Because both platforms use C#, it is tempting to copy the code across and swap the calls. The risk is an unchecked result: the code can compile and still trade differently, because the two platforms call it at different moments and handle sizes, positions and history differently. We start from how the cTrader version behaves, keep the platform-independent logic and rebuild what depends on cTrader’s API.
| Automatic conversion | Manual conversion at Nordman Algorithms | |
|---|---|---|
| Starting point | Often the C# code copied across, with cTrader calls swapped | How the cTrader version behaves |
| Platform differences | Often found later, if at all | Identified before work starts and agreed with you |
| Sizes and positions | Units, pips and labels carried over as they are | Rebuilt for your Quantower connection and symbol units |
Where unchecked conversions usually go wrong
- Same C#, different APICode that compiles after renaming calls can still run at different moments — a cBot’s bar events and a Quantower strategy’s quote and bar events don’t map one to one.
- Units copied as quantityOn EURUSD with a contract size of 100,000, 10,000 units is 0.10 lot; copied as a quantity of 10,000, the strategy would try to open 10,000 lots.
- Bars read in the wrong directioncTrader series count from the oldest bar and Quantower history can be read from either end; read the wrong way, values shift or reverse.
- Pips copied as ticksFor EURUSD with a pip size of 0.0001 and a target tick size of 0.00001, a 20-pip distance equals 200 ticks; copied as 20 ticks, the stop sits ten times closer to the price.
- Labels without a position modelLogic that finds its positions by label needs another way to track them if your Quantower connection nets positions; otherwise exits close the wrong trades.
- Trades at the wrong momentWhen a signal is calculated, when the order is sent and when it fills depend on the order type and settings on each platform; transferred wrongly, they shift entries and exits.
Have a cBot or cTrader indicator you want in Quantower?
Send it to us — we review it and give you a fixed price and timeline before work starts.
Checking the result
How We Check the Converted Script
We run the cTrader 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:
- Calculated values on selected bars
- Signal timing — on which bar a signal appears, inside the bar or after it closes
- Entry and exit conditions for strategies
- Agreed deviations — differences accepted in advance, such as visual layout or broker-specific execution
If the instrument stays the same, we compare values and signal timing directly. If it changes, 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.
What you receive
- C# source code — the full code of the strategy or indicator
- Everything needed to run it in Quantower; we help with installation if you need it
- Settings agreed with you before work starts
- Fixes for bugs and differences from the agreed specification after delivery
Process
How a cTrader to Quantower Conversion Works
Send the cTrader code
Share the cBot or indicator source — the .cs files or an .algo file saved with source — any libraries it uses and your settings, plus a short description.
You sendSource + dependenciesReview and fixed quote
We analyse the code, agree the Quantower connection, symbols and sessions — the same market or a new one — and where the strategy will run, then agree acceptance criteria, price and timeline.
You getFixed price + criteriaRebuild for Quantower
The cBot or indicator is rebuilt on Quantower’s C# API, including any extra features you asked for.
We buildThe Quantower versionCheck against the criteria
The Quantower version is checked against the acceptance criteria agreed in step 2.
We checkValues, signals, tradesDelivery and support
Bugs and differences from the agreed specification are fixed after delivery.
You getSource + files to run
Scope
What Affects the Price and Timeline
Every cBot and indicator is reviewed before we quote. These are the main factors.
Size of the Code
How much logic the code contains and how much of it is platform-independent.
Trade Handling
For cBots: positions, labels, events, scaling and partial closes.
Chart Types & Data
Non-time charts and data requested from other timeframes or symbols.
Visual Elements
Drawings, panels and outputs that change colour.
Libraries & Web Requests
Each .NET library, web request and file the code uses is checked.
Only an .algo File?
Conversion needs the source. An .algo file saved without source can’t be read, so recreating the cBot from your description is assessed separately.
★★★★★
"Alexei did an outstanding job in converting my cBot to an MT4 EA and his communication was brilliant, highly recommend him to anyone."
★★★★★
"Alexei's knowledge of C# is excellent and he was able to code to my exact requirements. Once the strategy was delivered, he was happy to make any adjustments I needed. I've enjoyed working with Alexei and I am sure we will work again."
★★★★★
"Alexei has completed three incremental projects for me. Any clarifications we have required have been well documented and in the debugging process, clear and methodical."
FAQ
cTrader to Quantower Conversion — Common Questions
No. A cBot is C# written against cTrader’s own API, and Quantower has a different API — different events, data access, drawing and order handling. Platform-independent calculations can often be kept, while the code tied to cTrader’s API is rebuilt for Quantower.
Yes. The cBot’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 each symbol’s specification, position size, price type, trading hours and execution rules are still checked. If you move to another market, 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.
Yes — Quantower has these chart types too, so logic built on them carries over. Bars can still be formed slightly differently on each platform, so values are checked.
Quantower has no cloud equivalent: a Quantower strategy runs in the terminal, on your computer or a VPS. Where the strategy will run is agreed before work starts.
On the same market, values can come close but not always match exactly: your cTrader 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 cTrader’s backtest exactly: the platforms use different data and model fills differently.
It depends on the size of the code, the trade handling, chart types, visual elements and any libraries or web requests. After reviewing your cTrader code we give you a fixed price and an estimated timeline before work starts.
Send Your cTrader Code for a Quote
Share the cBot or indicator source with the libraries it uses, and a short description of what it should do in Quantower and which connection it should trade through. We will review it and give you a fixed price and timeline before work starts.
Free Technical Assessment
Fixed Price Before Work
Source Code Ownership