contact@nordman-algorithms.com
EN / ES
Request A Free Quote
NinjaTrader → cTrader Conversion

Convert NinjaTrader Strategies & Indicators to cTrader

Both platforms use C#, but NinjaScript doesn’t run in cTrader as it is. We keep the platform-independent logic, rebuild strategies as cBots and indicators as cTrader indicators, and check the result against criteria agreed with you.

NinjaTrader Strategy to cBotNinjaTrader Indicator to cTraderNinjaScript to cTrader C#Rewritten by Hand
Send Your NinjaScript CodeHow Conversion Works
3,000+ Projects Delivered
Fixed Scope & Price Before Work
C# Source Code & .algo File
Checked Against Agreed Criteria
Overview

What NinjaTrader to cTrader Conversion Means

NinjaTrader to cTrader conversion means rebuilding NinjaScript on cTrader’s C# API: a strategy becomes a cBot and an indicator becomes a cTrader indicator. Both platforms use C#, so platform-independent calculations can often be kept, while code tied to NinjaTrader’s API is rebuilt. The move can keep the same market or change it — NinjaTrader is mostly used for futures, cTrader brokers mostly offer forex and CFDs — and if the instrument changes, sizes, price distances and sessions are adapted as well.

From
NinjaScript (C#) on NinjaTrader 8
To
C# on cTrader
Strategy
cBot
Indicator
cTrader indicator
You receive
C# source code and .algo file
Method
Independent logic kept, platform code rebuilt by hand

NinjaTrader features and how they work in cTrader

NinjaTrader featureIn NinjaTraderIn cTrader
Tick, Renko and range barsYesYescTrader chart types
Volume barsYesPartlyNeed a traded-volume data source; feasibility assessed before conversion
ATM strategiesYesPartlyRebuilt as the cBot’s own rules
Custom SharpDX renderingYesPartlyRedrawn with chart objects and controls
Volumetric order-flow dataYesPartlyAssessed separately — depends on your broker’s tick data
.NET librariesYesYesChecked for modern .NET compatibility
Strategies

Convert a NinjaScript Strategy to a cBot

A NinjaScript strategy and a cBot both trade automatically, but they react to data, size trades and track positions differently. Converting a strategy keeps its rules and rebuilds its trade handling for cTrader.

Entries & Exits

Managed or unmanaged NinjaScript order logic is rebuilt with cTrader’s trading methods — including scaling in, partial closes, exits tied to entries through labels, and reversals: a managed entry against an open position reverses it in NinjaScript — unmanaged logic follows its own orders — while a plain market order in cTrader can open a separate opposite position on a hedging account. How long pending orders stay active, and when they are changed or cancelled, is rebuilt too: managed orders may need resubmitting each bar to stay active, unmanaged ones stay until cancelled or expired.

Positions & Account Type

cBots find their positions by label. On a hedging account each entry can stay a separate position; on a netting account all trades on a symbol make one shared position, so the cBot keeps its own record of entries. How it works alongside other cBots, manual trades and positions already open at start is agreed in advance.

Contracts to Volume

Contract or unit sizing becomes volume in units, calculated from the cTrader symbol’s lot size and volume step and checked against your risk rules.

Stops & Targets

Stops and targets set in ticks become pip or price distances on the position. cBot stops can trigger on the opposite side of the price or after two consecutive quotes, so the trigger rule is chosen to match NinjaTrader and stop behaviour is checked, not only the distance. ATM-based management is rebuilt as the cBot’s own rules.

Calculation & Events

On-bar-close, on-each-tick and on-price-change logic is mapped to the cBot’s OnBar, OnBarClosed and OnTick events: OnBar runs as a new bar opens and OnBarClosed reads the last closed bar — both wait for the next bar’s first tick. We match which bar each piece of logic reads and when orders are sent. On-price-change logic gets an explicit filter that skips updates at an unchanged price.

Sessions & Time Zone

A trading hours template decides which data the chart uses and how intraday bars and the trading day are formed — not only when trades may open. We check the RTH or ETH data set, bar and trading-day boundaries and session resets, and set the cBot’s time zone so bar timestamps line up.

cTrader backtest results won’t match the Strategy Analyzer 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. ATM-based logic doesn’t run on history in NinjaTrader, so its original behaviour is compared on Simulation or Playback.

Indicators

Convert a NinjaTrader Indicator to cTrader

Converting a NinjaTrader indicator to cTrader means rebuilding its calculations, data series and drawing on cTrader’s API. We convert standard, custom, multi-series and bar-type-specific indicators, as well as panels and dashboards.

Calculations & Plots

Plots become indicator outputs, and regions between lines become clouds. Platform-independent calculations are kept where possible. Any visual differences are agreed in advance.

Custom Rendering

Charts drawn with SharpDX are redrawn with cTrader chart objects and controls; the agreed information is kept and the look is agreed separately.

Additional Data Series

Extra data series become bars requested per symbol and timeframe, keeping the original’s behaviour — forming or confirmed values. We also check the original for future-data leakage and agree any corrections before conversion.

Bar Types

Tick, Renko and range bars carry over as cTrader chart types, and values are checked since bars can form slightly differently. Volume bars need a source of traded volume, which cTrader’s quote ticks don’t include, so their feasibility is assessed before conversion; building them from quote ticks instead would change the original logic and is agreed separately.

Order-Flow Data

Indicators built on volumetric data need trade-level tick data — trade prices, volumes and trade direction — which many cTrader brokers don’t provide for forex and CFDs; this is assessed before work starts.

Built-In Indicators & Alerts

Calls to NinjaTrader’s built-in indicators use cTrader’s own where their values match — otherwise we write the calculation — and alerts become cTrader notifications.

Platform differences

NinjaScript to cTrader C#: What Changes and How We Handle It

NinjaTrader and cTrader 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.

Language and API

NinjaScript — C# on NinjaTrader’s API

C# on cTrader’s Automate API

Platform-independent calculations and classes can often be kept; code tied to NinjaTrader’s API, events, data and trading is rebuilt for cTrader.

Instruments

Futures, forex or stocks from your NinjaTrader connection

Forex, CFDs and other symbols from your cTrader broker

If the instrument changes, we agree which one replaces each NinjaTrader instrument and adapt sizes, price distances and sessions.

Trade size

Contracts or units

Volume in units, from the symbol’s lot size and volume step

Sizes are recalculated for the cTrader symbol and checked against your risk rules.

Positions

The strategy’s own position, tracked separately from the account’s

Positions on a hedging or netting account, found by label

We map each entry and its exits for your account type — on netting, with the cBot’s own record of entries — and agree how it works alongside other cBots, manual trades and positions already open at start.

Calculation

Calculation mode per script; history on bar close unless intrabar data is added

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

We match which bar each piece of logic reads — forming or closed — and when orders are sent, and check intrabar behaviour.

Additional data

Extra data series, handled through BarsInProgress

Bars requested per symbol and timeframe, each with its own events

Values from other series are aligned with the chart’s bars, as in the original.

.NET

Runs on .NET Framework

Runs on modern .NET

Libraries are checked for compatibility and retargeted or replaced where needed.

What may not carry over one to one

Some things depend on the platform itself: volumetric order-flow data needs trade-level tick data that many cTrader brokers don’t provide; NinjaTrader add-ons and third-party indicators the code relies on need their source or a replacement; and cTrader Cloud limits some cBot features, so if the cBot should run there, this is checked. We point these out before work starts and agree the closest cTrader 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 positions, sizes and orders differently. We start from how the NinjaTrader version behaves, keep the platform-independent logic and rebuild what depends on NinjaTrader’s API.

Automatic conversionManual conversion at Nordman Algorithms
Starting pointOften the C# code copied across, with NinjaScript calls swappedHow the NinjaTrader version behaves
Platform differencesOften found later, if at allIdentified before work starts and agreed with you
Orders and sizesSignal names, contracts and ATM logic carried over as they areRebuilt for cTrader positions, volume and your account type

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 don’t map one to one to NinjaScript’s calculation modes.
  • Contracts copied as volumeOne contract copied as one unit — or as one lot — is a completely different size; volume has to be recalculated from the cTrader symbol’s lot size.
  • Reversals that open a second positionA managed NinjaScript entry against an open position reverses it; a plain market order in cTrader on a hedging account opens a separate opposite position instead.
  • Ticks copied as pipsIf EURUSD is quoted with a tick of 0.00001 and a pip of 0.0001, a 200-tick stop is 20 pips; copied as 200 pips, it sits ten times further from the price — distances are converted with each symbol’s tick and pip size.
  • ATM management lostStops, targets and trailing left to an ATM strategy disappear unless they are rebuilt as the cBot’s own rules.
  • Signals on the wrong data seriesNinjaScript logic that switches on BarsInProgress has to be rebuilt when other series are requested separately; missed, values come from the wrong series.

Have a NinjaTrader strategy or indicator you want in cTrader?

Send it to us — we review it and give you a fixed price and timeline before work starts.

Discuss Your Project
Checking the result

How We Check the Converted Script

We run the NinjaTrader original and the cTrader version on the same timeframe, with matching 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 — say, from a futures contract to a CFD — 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 cBot or indicator
  • .algo file — ready to install in cTrader; 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 NinjaTrader to cTrader Conversion Works

  1. Send the NinjaScript code

    Share the .cs files, any custom indicators or add-ons the code uses, and your strategy settings or ATM templates — plus a short description.

    You sendSource + dependencies

  2. Review and fixed quote

    We analyse the code, agree your cTrader broker, account type, symbols and sessions — the same market or a new one — and whether the cBot runs locally or in cTrader Cloud, then agree acceptance criteria, price and timeline.

    You getFixed price + criteria

  3. Rebuild for cTrader

    The strategy or indicator is rebuilt as a cBot or cTrader indicator, including any extra features you asked for.

    We buildThe cTrader version

  4. Check against the criteria

    The cTrader version is checked against the acceptance criteria agreed in step 2.

    We checkValues, signals, trades

  5. Delivery and support

    Bugs and differences from the agreed specification are fixed after delivery.

    You getC# source + .algo file
Scope

What Affects the Price and Timeline

Every strategy 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 strategies: order methods, ATM-based management, positions, reversals and partial closes.

Bar Types & Data Series

Non-time bars, additional data series and order-flow data the code relies on.

Custom Rendering

Charts drawn with SharpDX that need cTrader chart objects and controls.

Add-Ons & Libraries

NinjaTrader add-ons, third-party indicators and .NET libraries — each is checked for compatibility or replaced.

Only a Compiled Assembly?

Conversion needs the .cs source. Without it, recreating the strategy or indicator from your description is assessed separately.

reviews

What Clients Say

★★★★★
Trustpilot
4.7
★★★★★
"I cannot recommend Nordman Algorithms/Alexei highly enough!!! I have had the pleasure of working with Alexei on a very, very complex program for Ninja Trader for a couple of months and he has made the whole experience extremely pleasurable and seamless. …"
B
Brenden
Trustpilot review
★★★★★
"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."
SH
Stuart H.
Freelancer review
★★★★★
"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."
BL
Brendan L.
Freelancer review
View All Reviews →
FAQ

NinjaTrader to cTrader Conversion — Common Questions

No. NinjaScript is C# written against NinjaTrader’s own API, and cTrader has a different API — different events, data access, drawing and order handling. Platform-independent calculations can often be kept, while the code tied to NinjaTrader’s API is rebuilt for cTrader.

Yes. The strategy’s rules are kept and its trade handling is rebuilt for cTrader — volume, positions on your account type, stops and any extra trade management — with sizing and risk agreed with you.

If your cTrader broker offers the same instruments, the market stays the same, but each symbol’s specification, volume, sessions and execution are still checked. If you move to another market — say, from ES futures to a US500 CFD — sizes, price distances and sessions are adapted, and how the cBot behaves there is checked against the agreed rules.

cTrader has no ATM strategies. Trade management that relies on them — stops, targets, trailing and scaling out — is rebuilt as the cBot’s own rules. Because ATM strategies don’t run on history in NinjaTrader, the original behaviour is compared on Simulation or Playback.

Tick, Renko and range bars do — cTrader has these chart types of its own — though bars can form slightly differently, so values are checked. Volume bars need traded volume, which cTrader’s quote ticks don’t include; their feasibility is assessed before work starts, and building them from quote ticks instead is a change to the logic that is agreed separately.

Indicators built on NinjaTrader’s volumetric data need trade-level tick data — trade prices, volumes and trade direction. Many cTrader brokers provide only bid and ask ticks for forex and CFDs, so this is assessed before work starts.

On the same market, values can come close but not always match exactly: your NinjaTrader connection and your cTrader broker 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, in cTrader’s backtesting. Results won’t match the Strategy Analyzer exactly — the platforms use different data and model fills differently — so we check that entries and exits follow the agreed rules.

It depends on the size of the code, the trade handling, custom rendering, bar types and data series, and any add-ons the code relies on. After reviewing your NinjaScript code we give you a fixed price and an estimated timeline before work starts.

Send Your NinjaScript Code for a Quote

Share the .cs files with any custom indicators or add-ons they use, and a short description of what the strategy or indicator does and which cTrader symbol it should trade. We will review it and give you a fixed price and timeline before work starts.

Request A Free QuoteAll Conversion Routes
Free Technical Assessment
Fixed Price Before Work
Source Code Ownership
Get Free Technical Assessment
Guaranteed response within one business day