Both platforms use C#, but a cBot doesn’t run in NinjaTrader as it is. We keep the platform-independent logic, rebuild cBots as NinjaScript strategies and cTrader indicators as NinjaScript indicators, and check the result against criteria agreed with you.
Indicators.ExponentialMovingAverage(…, 21)EMA(Close, 21)[0][Output("EMA")] IndicatorDataSeries EmaAddPlot(Brushes.DodgerBlue, "EMA")[Cloud("Fast", "Slow")]Draw.Region(this, "Cloud", …)MarketData.GetBars(TimeFrame.Hour)AddDataSeries(BarsPeriodType.Minute, 60)Renko chart with the cTrader cloud rebuilt as a NinjaTrader region
cTrader to NinjaTrader conversion means rebuilding cTrader’s C# code on NinjaTrader’s NinjaScript API: a cBot becomes a NinjaScript strategy and an indicator becomes a NinjaScript indicator. Both platforms use C#, so platform-independent calculations can often be kept, while code tied to cTrader’s API is rebuilt. cTrader brokers mostly offer forex and CFDs, while NinjaTrader is used mostly for futures, so a cBot often moves to a different market; sizes, price distances and sessions are then adapted as well.
| cTrader feature | In cTrader | In NinjaTrader |
|---|---|---|
| Renko, range, tick and Heikin-Ashi charts | Yes | YesNinjaTrader bar types; bars are checked |
| Clouds between lines | Yes | YesRegions between plots |
| Position events | Yes | YesStrategy order, execution and position updates; manual trades tracked at account level |
| Positions found by label | Yes | PartlyEntries named within the strategy’s own position |
| Chart buttons and panels | Yes | PartlyWPF controls on the chart or custom rendering |
| .NET libraries | Yes | PartlyChecked for .NET Framework compatibility |
| cTrader Cloud | Yes | NoThe strategy runs in NinjaTrader on your computer or a VPS |
A cBot and a NinjaScript strategy both trade automatically, but they react to data, size trades and track positions differently. Converting a cBot keeps its trading rules and rebuilds its trade handling for NinjaTrader.
Market and pending orders, modifications and closes are rebuilt with NinjaScript order methods — the managed approach, or the unmanaged one where the logic needs it — including scaling in, partial exits, exits tied to named entries and reversals. A plain market order in the opposite direction opens a second position on a cTrader hedging account, while a managed NinjaScript entry reverses the strategy’s position, so that logic is redesigned and agreed with you.
cTrader pending orders stay until filled, cancelled or expired. In the managed approach, NinjaScript orders are cancelled at the end of the bar unless they are submitted again or kept live until cancelled; unmanaged orders remain active until filled, cancelled or expired under their time-in-force settings. When each order becomes active and is cancelled is rebuilt and checked against the agreed criteria.
Stop-loss and take-profit set in pips become stop and target orders in ticks or prices. cBot stops can trigger on the opposite side of the price or after two consecutive quotes; these rules are checked separately and, where needed, rebuilt in the code or agreed as a deviation, so stop behaviour is checked, not only the distance. Trailing stops and breakeven are rebuilt as the strategy’s own rules.
Volume in units becomes contracts — or units, on forex connections — for the NinjaTrader instrument, calculated from its specification and checked against your risk rules. If the market changes, say from a US500 CFD to ES futures, the size is recalculated for the new contract rather than copied.
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 — and OnTick runs on every tick. In NinjaScript, OnBarUpdate runs on bar close, on each tick or on price change, and history is calculated on bar close unless intrabar data is added, so which bar each piece of logic reads and when orders are sent is matched and checked.
The strategy’s own orders and fills — a position opening, or closing at a stop or target — are handled through NinjaScript’s order, execution and position updates. These don’t report manual trades or other strategies’ orders, so if the cBot reacts to manual trades, account-level tracking is added where needed. Timers keep running as timers, with any code that touches bars or orders called through NinjaScript’s custom-event mechanism.
Strategy Analyzer results won’t match cTrader’s backtest exactly: the platforms use different data — sometimes for a different instrument — and model fills differently. We choose how intrabar history is calculated and filled for each strategy and check that entries and exits follow the agreed rules.
Converting a cTrader indicator to NinjaTrader means rebuilding its calculations, data access and drawing on NinjaTrader’s API. We convert standard, custom and multi-timeframe indicators, as well as panels and dashboards.
Outputs become plots, colours that change from bar to bar are set plot by plot, and clouds between two lines become regions. Platform-independent calculations are kept where possible. Any visual differences are agreed in advance.
cTrader series count from the oldest bar, while NinjaScript reads values back from the current bar — Close[1] is the previous bar — so every index is rewritten and checked, and starting values and warm-up history are rebuilt so calculations line up.
Bars requested for other timeframes or symbols become additional data series, handled through BarsInProgress, keeping the original’s behaviour — forming or confirmed values. We also check the original for future-data leakage and agree any corrections before conversion.
Icons, text and lines drawn on the chart become NinjaTrader drawing objects, and buttons and panels become WPF controls on the chart or custom rendering; the agreed information is kept and the look is agreed separately.
Indicators built for Renko, range, tick or Heikin-Ashi charts use NinjaTrader’s own bar types; bars can form slightly differently, so values are checked. Market depth logic is rebuilt on NinjaTrader’s depth updates, where your connection provides them.
Calls to cTrader’s built-in indicators use NinjaTrader’s own where their values match — otherwise we write the calculation — and alerts become NinjaTrader alerts.
cTrader and NinjaTrader run C# code in different ways, and can trade different instruments. These are the differences that decide whether a converted script behaves like the original — and what we do about each of them.
C# on cTrader’s Automate API
NinjaScript — C# on NinjaTrader’s API
Platform-independent calculations and classes can often be kept; code tied to cTrader’s API, events, data and trading is rebuilt in NinjaScript.
Forex, CFDs and other symbols from your cTrader broker
Futures, and forex or stocks on some connections
If the instrument changes, we agree which one replaces each cTrader symbol and adapt sizes, price distances and sessions.
Volume in units, from the symbol’s lot size and volume step
Contracts, or units on forex connections
Sizes are recalculated for the NinjaTrader instrument and checked against your risk rules.
Positions found by label, on a hedging or netting account
The strategy’s own position in an instrument, tracked separately from the account’s
Each entry and its exits are mapped to the strategy’s position; hedged positions are redesigned, and the strategy’s start behaviour and how it works alongside manual trades and other strategies are agreed.
OnBar as a new bar opens and OnBarClosed for the last closed bar — both wait for the next bar’s first tick; OnTick for each tick
OnBarUpdate on bar close, on each tick or on price change; history on bar close unless intrabar data is added
We match which bar each piece of logic reads — forming or closed — and when orders are sent, and check historical and real-time behaviour separately.
The cBot’s time zone setting and the symbol’s sessions
The trading hours template, such as RTH or ETH, and the platform time zone
We compare sessions, bar timestamps and the time zone each version’s logic uses — matching chart clocks alone isn’t enough.
Runs on modern .NET
Runs on .NET Framework
Libraries are checked for compatibility and retargeted or replaced where needed.
Some things depend on the platform itself: cTrader Cloud has no NinjaTrader counterpart; forex and CFD symbols your NinjaTrader connection doesn’t offer; and libraries built for modern .NET, web requests and file access, which are checked one by one. A NinjaScript strategy can trade several instruments added as extra data series: a cBot that trades symbols independently can run as separate strategies, while cross-market signals or a shared risk limit can be kept in one multi-instrument strategy — which approach fits, and how it is tested, is agreed before work starts. We point these out before work starts and agree the closest NinjaTrader equivalent with you.
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 positions, sizes and orders 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 |
| Orders and positions | Units, pips and labelled positions carried over as they are | Rebuilt for NinjaScript orders, contracts and the strategy’s position |
Send it to us — we review it and give you a fixed price and timeline before work starts.
We run the cTrader original and the NinjaTrader version on the same timeframe, with matching 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 CFD 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 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 + dependenciesWe analyse the code, check it for future-data leakage, agree your NinjaTrader connection, instruments and trading hours — the same market or a new one — and how hedged positions will work, then agree settings, acceptance criteria, price and timeline.
You getFixed price + criteriaThe cBot or indicator is rebuilt as a NinjaScript strategy or indicator, including any extra features you asked for.
We buildThe NinjaTrader versionThe NinjaTrader 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 cBot and indicator is reviewed before we quote. These are the main factors.
How much logic the code contains and how much of it is platform-independent.
For cBots: pending orders, labels, hedged positions, position events, scaling and partial closes.
Non-time charts and data requested from other timeframes or symbols.
Outputs, clouds, drawings, buttons and panels on the chart.
Each .NET library, web request and file the code uses is checked for .NET Framework compatibility or replaced.
Conversion needs the source. An .algo file saved without source can’t be read, so recreating the cBot from your description is assessed separately.
No. A cBot is C# written against cTrader’s own API, and NinjaTrader 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 in NinjaScript.
Yes. The cBot’s trading rules are kept and its trade handling is rebuilt in NinjaScript — quantity, the strategy’s position, protective orders and any extra trade management — with sizing and risk agreed with you.
NinjaTrader is used mostly for futures, and forex is available through some connections. If your connection offers the same instruments, the market stays the same, but each instrument’s specification, size, sessions and execution are still checked. If you move to another market — say, from a US500 CFD to ES futures — sizes, price distances and sessions are adapted, and how the strategy behaves there is checked against the agreed rules.
Not as it is. A NinjaScript strategy holds one position in an instrument — long, short or flat — and in the managed approach an opposite entry reverses it, so logic that keeps long and short positions open together on a cTrader hedging account has to be redesigned. How is agreed before work starts.
Clouds between two lines become regions, icons and text drawn on bars become NinjaTrader drawing objects, and buttons and panels become WPF controls on the chart or custom rendering. The agreed information is kept, and the look is agreed separately.
A NinjaScript strategy runs in NinjaTrader on your computer or a VPS, so where it 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 NinjaTrader 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.
Yes — that’s the reverse route, NinjaTrader to cTrader conversion. The same approach applies, with events, positions and sizes mapped the other way.
It depends on the size of the code, the trade handling, chart types and data series, 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.
Share the cBot or indicator source with the libraries it uses, and a short description of what it should do in NinjaTrader and which instruments it should trade. We will review it and give you a fixed price and timeline before work starts.