Gekko Strategy customization

Now that we’ve briefly seen how to install gekko and how to use its main functionalities, we will try to customize a first strategy.

As a first step, you need to review Gekko’s excellent standard documentation:

I won’t explain here all the functions used, since it is explained in the standard documentation, and you have links above. Neither will I explain how to code. Testing your strategy was explained before but here is a quick recap:

From the UI or from the CLI you can backtest a strategy or use a live traderPaper bot:

  • With the UI, the strategies in <gekko_installdir>/strategies will be proposed in the strategies dropdown list in the backtest page in the UI; also you need a .toml file with the parameters for your strategy in <gekko_installdir>/config/strategies
  • With UI and CLI, if you want to backtest, you need to have populated your database with datasets downloaded from markets
  • You may also want to run a livebot with the paperTrader activated to simulate a real trading bot on the live market; but I strongly suggest to backtest your strategy before as it will be much faster to test it on a huge amount of data, ie. a large timeframe of markets variations.

As we saw, strategies are stored in <gekko_installdir>/strategies, those are .js files. As we started previously by testing the MACD strategy, let’s take a look at it.

The out of the box MACD Gekko’s strategy

First we will work on a copy of the MACD, but we won’t modify it for now.

cp <gekko_installdir>/strategies/MACD.js <gekko_installdir>/strategies/MyMACD.js

In the init function, we can see a few variables being initialized:

  • A trend structure, which will be used by the strat to “remember” the past
  • The requiredHistory which is read from the configuration file config.js in the tradingAdvisor section
  • A call to the MACD indicator, which is by default stored in

Now, let’s have a look at the MACD indicator: open

  • As we can see it will use the EMA.js indicator
  • It will define three EMAs, one with the short value defined in the configuration file config.js, another one with the long value, and the last one as the signal
  • The MACD indicator will:
    • Update the short and long EMAs with the market price (the last candle closure value, provided by the MACD strategy calling the MACD indicator)
    • Calculate the difference between them
    • Update the signal EMA by using the diff between short and long EMAs as input
    • Return the difference between the short/long EMA’s and the signal EMA to our strategy

Please, check some MACD documentation to better understand this logic.

Now that we know the basics of the MACD indicator (it takes 3 inputs and returns one value) let’s come back to our MyMACD strategy.

The log function will display some information in Gekko’s log at each candle update.

We can see that it creates an macd variable which will “point” to our macd indicator defined in the init function, and it will display the various results for the 3 EMA’s by using macd.short, macd.long, macd.signal, macd.diff, and macd.result which is the real output of the MACD indicator.

Now, the check function. This is the function where all the trading rules are implemented. What is does, basically:

  • If the MACD is upper than the up trend threshold in config.js, then (in a short way):
    • It checks if the number of iterations of up trend is superior to the historySize (which comes from config.js)
    • If yes and if we didn’t yet asked to BUY, it tries to BUY (long order)
  • Else, if the MACD is lower than the down trend threshold in config.js, then:
    • It checks if the number of iterations of low trend is superior to the historySize (which also comes from config.js)
    • If yes and if we didn’t yet asked to SELL, it tries to SELL (short order)
  • Else, and it means that the MACD result is between the down threshold and the up threshold, it does NOTHING.

This is how it performs on a long term Kraken/EUR/ETH dataset, with the standard parameters. I still use the MACD and not MyMACD as we didn’t modify MyMACD yet, nor we modified the config.js to use it.

Backtest Parameters


As we can see, with some quick estimation of the parameters (6 hours candles + higher thresholds than for shorter candles), if we made no trades at all, we would have benefit 984% of evolution straight from the market, but with our 168 trades we earned less: 835% of gain.

Now let’s try to tweak it a little bit …



Quick analysis

Just by adjusting two or three parameters we gained in profit. Remember that this can’t be considered as a guarantee you will indeed earn assets or currency in “real life” on a live market; as here we tweak the model with data from the past. We have time to tweak it “as we want to see the result”. But we don’t know if the same parameters will perform well in the future.

If we zoom a little bit on the timeline, we can see that the strategy won’t perform so bad during high uptrends or downtrends. We can also see that it could be tweaked as we often see some LONG (buy) orders appearing just before a loss on the market, but followed by a SHORT (sell) orders. Or SELL orders just before a BUY, despite an uptrend market.

Conclusion: I’m not an expert, and I don’t know if we can rely on only one indicator. Litterature tends to prove that every market analysis needs to be double or triple checked with other indicators.

What is sure is that every indicator needs to be tweaked, and you need to analyse the market with other tools, more accurate, with a visual display of the indicators. I personally use kraken’s new Trading & Charting tool as well as other sites as I first play globally with one indicator at a time, adjust the short/long parameters, study their crosses, and then study the difference between both, so that I can report what I think are good triggers in Gekko’s config.js thresholds. Then I backtest, as we will see much longer in another article.

Cloning the MACD strategy

So we copied <gekko_installdir>/strategies/MACD.js to <gekko_installdir>/strategies/MyMACD.js

For now we will just modify it a little bit, to later check we are using this strategy and not the stock MACD strat. Edit MyMACD.js and jump to line 51:

log.debug(‘calculated MyMACD properties for candle:’);
log.debug(‘\t’, ‘short:’, macd.short.result.toFixed(digits));
log.debug(‘\t’, ‘long:’, macd.long.result.toFixed(digits));

Save it, and thats all.

We also need to copy
<gekko_installdir>/config/strategies/MACD.toml to
<gekko_installdir>/config/strategies/MyMACD.toml so that the backtest UI can display customized parameters for the MyMACD settings.

Now we need to modify
<gekko_installdir>/config.js so that Gekko will use it.

First the trading.advisor plugin needs to be modified to call the right strategy. It’s just the name of your strategy.js file, without the .js extension.

config.tradingAdvisor = {
enabled: true,
method: ‘MyMACD‘,
candleSize: 360, //to reflect the 6 hours candle I used in previous backtest
historySize: 6, //to reflect the 6 candles of warmup period in backtest UI

Then we need to provide the tradingAdvisor some parameters:

// MACD settings:
config.MyMACD = {
// EMA weight (α)
// the higher the weight, the more smooth (and delayed) the line
short: 10,
long: 21,
signal: 9,
// the difference between the EMAs (to act as triggers)
thresholds: {
down: -0.7,
up: 0.3,
// How many candle intervals should a trend persist
// before we consider it real?
persistence: 0

Those 2 modifications will allow use to use our strat with Gekko’s CLI.

Next, in case we want to use the UI to backtest or run a livebot, we also edit <gekko_installdir>/config/strategies/MyMACD.toml

short = 10
long = 21
signal = 9


down = -0.7
up = 0.3
persistence = 0

Let’s test it on the UI.

Woohoo, same result :] Just to be absolutely sure we now use MyMACD and not MACD, let’s run it through the CLI and check the console or logs:

gekko@HP850G3:~/gekko$ node gekko –config config.js –backtest

2019-01-09 14:07:52 (DEBUG): calculated MyMACD properties for candle:
2019-01-09 14:07:52 (DEBUG): short: 247.91113481
2019-01-09 14:07:52 (DEBUG): long: 253.43444971
2019-01-09 14:07:52 (DEBUG): macd: -5.52331490
2019-01-09 14:07:52 (DEBUG): signal: -4.87686289
2019-01-09 14:07:52 (DEBUG): macdiff: -0.64645201
2019-01-09 14:07:52 (DEBUG): In no trend
2019-01-09 14:07:52 (DEBUG): calculated MyMACD properties for candle:
2019-01-09 14:07:52 (DEBUG): short: 249.96729212
2019-01-09 14:07:52 (DEBUG): long: 253.96040883
2019-01-09 14:07:52 (DEBUG): macd: -3.99311671
2019-01-09 14:07:52 (DEBUG): signal: -4.70011365
2019-01-09 14:07:52 (DEBUG): macdiff: 0.70699694
2019-01-09 14:07:52 (DEBUG): In uptrend since 1 candle(s)
2019-01-09 14:07:52 (INFO): 2017-10-24 07:29:00: Paper trader simulated a BUY 0.00000000 EUR => 3.39807550 ETH

As you already figured out, we can see the modification we made in MyMACD.js, so YES, this is the right strategy we are using. Now we can try to modify it, as a quick example.

Customizing our strategy

One thing which is not covered in this strategy is the “notrend” possibility. When the MACD result stalls for a long time between our down and up thresholds, it doesn’t mean that the market and currency/asset rates are stables. It means that it is not moving enough up or down to be used by our strategy.

But, the market can still decrease (or increase) and maybe after a few candles we should sell, to keep our gains by converting back our assets in currency. This is called a stoploss.

So basically we should and will:

  1. Introduce a new parameter in the conf, called stoploss
  2. Add the handling of the stoploss in the “notrend” section of the strategy: if the closing price of the candle we are reviewing is below our “last buy price” then we order Gekko to advice a short position (sell).
  3. So we will also need to modify the uptrend section, to update the stoploss price if the market is uptrend.

Note that there are other ways to do that, we could also add a OR condition to the downtrend section, to check if (MACD diff is below down_threshold OR if candle.price < stoploss_price).

Adding a new parameter in conf

Edit <gekko_installdir>/config.js

config.MyMACD = {
// EMA weight (α)
// the higher the weight, the more smooth (and delayed) the line
short: 10,
long: 21,
signal: 9,
// the difference between the EMAs (to act as triggers)
thresholds: {
down: -0.7,
up: 0.3,
stoploss: 10,
// How many candle intervals should a trend persist
// before we consider it real?
persistence: 0

Now edit

In the init block, we add this. Note that if you define a variable or const in the init() block, it won’t be persisted in the check() block. So we use “this” object to store data.

//get the stoploss rate from conf
this.stoploss_rate = this.settings.thresholds.stoploss;
//reset the stoploss_price
this.stoploss_price = “”;

We need to modify the check function so that it will receive the candle description as input, as we will need to use it to get the candle.price we try to buy, or the candle.price to update the stoploss if the market is uptrend.

method.check = function(candle) {

In the uptrend section, we add this, to update the new stoploss price each time we sell and each time the market is increasing if it’s new price is higher than our stoploss_price:

log.debug(‘In uptrend since’, this.trend.duration, ‘candle(s)’);

if (this.stoploss_price != “” && candle.close > this.stoploss_price)
this.stoploss_price = candle.close-candle.close*this.stoploss_rate/100;‘===> New computed stoploss price is:’, this.stoploss_price,'<===’);

if(this.trend.persisted && !this.trend.adviced) {
this.trend.adviced = true;
this.stoploss_price = candle.close-candle.close*this.stoploss_rate/100;‘===> We BOUGHT at ~’,candle.close,’ and computed stoploss price is:’, this.stoploss_price,'<===’);
} else

Now in the downtrend section, if we SELL, we should reset the stoploss_price as we don’t own any assets anymore.

if(this.trend.persisted && !this.trend.adviced) {
this.trend.adviced = true;
this.stoploss_price = candle.close-candle.close*this.stoploss_rate/100;‘===> We BOUGHT at ~’,candle.close,’ and computed stoploss price is:’, this.stoploss_price,'<===’);

} else

Let’s give it a try, just to make sure we didn’t break anything yet; and even if we actually did not change anything to the decision tree to sell or buy.

node gekko –config config.js –backtest

So what do we see ?

  • First, that I disabled the debug mode at the beginning of the config.js file and I forgot to write it here 🙂
  • The first BUY displayed has initialized the stoploss_price by computing the stoploss_rate we defined in conf
  • Then the stoploss_price keeps rising, as we took care to not update it if the market price was lower than our stoploss_price
  • When we SELL, the stoploss_price is resetted
  • Seems all good so far !

Now let’s modify the “notrend” block and create a “stall” trend with a SELL if we detect a persistence and a market price lower than our stoploss_price.

} else {
//log.debug(‘In no trend’);

// new trend detected
if(this.trend.direction !== ‘stall’)
// reset the state for the new trend
this.trend = {
duration: 0,
persisted: false,
direction: ‘stall’,
adviced: false


log.debug(‘In stalled trend since’, this.trend.duration, ‘candle(s)’);

if(this.trend.duration >= this.settings.thresholds.persistence)
this.trend.persisted = true;

if (this.trend.persisted && !this.trend.adviced)
if (this.stoploss_price != “” && candle.close < this.stoploss_price) { this.trend.adviced = true; this.advice(‘short’); this.stoploss_price = “”;‘===> We \’Stalled\’ SOLD at ~’,candle.close,’ and reseted stoploss price. <===’);

}‘===> Market not low enough to \’stall\’ sell <===’);


Beware that we also need to modify the downtrend block condition, as we don’t need it to SELL another time if the market is really downtrend, after we already sold earlier thanks to our new “stall trend” code:

} else if(macddiff < this.settings.thresholds.down && this.stoploss_price != “”) {

And we test it (note that I commented out the last line in the Stall block to reduce verbosity):

It seems to work. Don’t forget to copy the MACD.toml file in a new MyMACD.toml file and to add the stoploss parameter, so you can use it in the backtest UI.

Conclusion and other possible improvements


So how does it perform ? Well, not so good 🙂 I will write another post about backtesting, and how to try to tune the parameters. Because, As we already noticed, tweaking the parameters does require a lot of analysis, and a lot of tests.

Here we just introduced a new parameter, and here is the result, knowing that I kept the previous test parameters.

So “out of the box” our new strategy is less efficient than the stock MACD. But we gained control over a new kind of trend on the market watched by the Strat. We need to tune it and find better values for the parameters. Maybe the code also needs to be optimized, I don’t pretend AT ALL to have a good knowledge of the good rules to code.

In a next article, I will explain how I managed to launch a massive test with randomized (or not) parameters, in order to track the best results (on past data, again), using public tools from contributors.

For information, one backtest with this strategy, on my i7 “mid class office” laptop approximately runs during 41 seconds, after I modified all the functions we used above to use log.debug() instead; and with debug mode unactivated in config.js.

This was just an example to explain how to instantiate and modify a strategy. I don’t pretend this modification to be a gain. Again, this is at your own risk, from running a non optimized standard gekko’s Strat, to running a customized strategy. You will probably loose your investment as there is no magic possible, it means it is not possible to anticipate the markets without a huge risk, or a very high confidence in your markets knowledge.

Ideas for more improvements

Other possible improvements you could work on are:

  • Add a parameter in conf to provide your strategy the last type of order (buy or sell) with its price so that your strategy will be able to use it for its first decision
  • Calculate the stoploss in the init section if the last action in conf was a buy and you know its price, so that you won’t miss to sell if the very first trend your strategy will have to deal with is a long stall-but-decreasing-market.
  • Deal with more indicators than just the MACD.
  • Port the stoploss principle to buy actions if we are on a long but slow persisted market raise,
  • What is currently not allowed in Gekko is to handle multiple candle size at the same time, so that you could have one indicator working on short terms trends, and another one on long term trends, and take decisions based on the two (or N candle sizes). There are some forks allowing it, but I didn’t give it a try yet.

Gekko trading bot usage

Now that we installed Gekko, we need to feed it with data, and make it useful. Please, keep in mind that a trading bot is in NO WAY an insurance to earn money, as it will depend on the logic of your strategy, and on the markets (currency & asset) you will use.

We will follow 4 simple steps :

  1. Feeding your local Gekko database with market’s data so that we will be able to locally make some tests with strategies
  2. Run a backtest, which means testing a strategy on the local Gekko database we previously populated
  3. Run a livebot with traderPaper plugin, to simulate how a strategy would perform on a live market
  4. Launch the strategy, live, which means we will allow Gekko to really make buy/sell (long/short) orders

Feeding Gekko with market’s data

This part is quite simple and we will first use the UI to do it, click on “Local Data” on the top menu.

If you try to click on “Scan available data”, Gekko will complain, this is normal as we didn’t provision anything yet.

Now click on “Go to the Importer” button below.

For my test I will choose Kraken, the Euro currency, and Ethereum asset, and use the default daterange but you can change it.

Beware, dowloading data from markets as Kraken using -for now- an anonymous access will often trigger some kind of bandwith and access limitations, so the download rate will be low, and if you request a huge period of data, it may take a long time. Also, you could have to relaunch it several time, and reduce the timeframe each time to complete the previous downloaded one.

Now, Click on Import.

Gekko starts to “automagiclly” download the data from Kraken, and records it in its local database.

To use Gekko’s CLI (Command Line Interface, ie. without the UI) to make the same thing is quite easy:

  • Modify Gekko’s config file

cd <gekko_installdir>

cp sample-config.js config.js

edit config.js with your favorite editor

  • Now, as explained in official documentation, make sure the candleWriter plugin is enabled (around line 263 in the out-of-the-box config.js file), so that gekko will be able to record the data

config.candleWriter = {
enabled: true

  • Now check the conf around line 345, and configure what daterange you need to import

config.importer = {
daterange: {
// NOTE: these dates are in UTC
from: “2017-11-01 00:00:00”,
to: “2017-11-20 00:00:00”

  • Now run gekko and tell him to import data

node gekko –config config.js –import

Now, if we take a look back in gekko’s UI, we can see that it detects 2 importations:

The first one, is the one we imported using the UI and from Kraken. The second one is from binance (I stopped it before it reached 2017-11-20). This is because we didn’t modify the section in config.js: = {

// see
exchange: ‘binance’,
currency: ‘USDT’,
asset: ‘BTC’,

// You can set your own tickrate (refresh rate).
// If you don’t set it, the defaults are 2 sec for
// okcoin and 20 sec for all other exchanges.
// tickrate: 20

You are free to modify it, just make sure that you use an allowed combination market/currency/asset. Checking the console logs when you lanch the CLI will help you to analyze any error Gekko could encounter.

Backtesting a strategy on local data

Now that we have a populated database, let’s give a try on a strategy. The goal here is not to explain you what’s the best strategy or how to tune it. We just want to check how it works.

First, we use the UI: in the Backtest menu, click “Scan available data” button.

We can once again see the two series of data we imported previously, good. Now, below on the same screen, let’s choose the MACD strategy. This is a quite standard indicator (as well as the other ones out-of-the-gekko-box) and the strategy implementing it is also quite simple as we will see in a next article.

Note that what is displayed on this screen can be changed:

  1. The strategy in the drop-down list are the ones in
    <gekko_installdir>/strategies/*.js files (eg. MACD.js for the MACD strategy)
  2. The parameters on the right are from the <strategy_name>.toml files in
  3. The paperTrader settings we will review below are stored in the
    <gekko_installdir>/config/plugins/paperTrader.toml file

We change the candle size to 3 hours, and use 4 candles of history to “warmup” the strategy and provide the indicator some historical data.

Now let’s have a look at the paperTrader settings and change it to reflect Kraken fees:

And we launch the backtest ! Wait .. no Launch button ? Oh we forgot to select a dataset. Go back to the top of the page and click on Kraken box. Scroll down and click “Backtest”.

After a very short time, because of a simple strategy and a very short timeframe in the dataset, you will see 3 sections of results:

Those are the general statistics. Simulated profit here may sound bad (-24%), but actually it is better than the standard performance of the market if you did no actions with your 1 asset and 100 currency configured in the paperTrader settings (-41%). We can see here that the strategy actually performed 38 trades.

Here we can see the whole timeframe with BUY/LONG orders (green dots) and SELL/SHORT orders (red dots). You can zoom in. As you can guess, when you see a green dot just before a big market fall, this is not so good.

Finally you can see here a detailled view of each roundtrip (a buy+sell or sell+buy so that a PnL can be calculated).

If you want to use the CLI this is not so complicated.

Edit your config file (remember ?
<gekko_installdir>/config.js) and:

  • Make sur the config.tradingAdvisor section (tip: around line 33) is configured as you expect. Basically, this is were you provide the same parameters as we saw in the UI to the strategy you choose. Here we still use the MACD.

config.tradingAdvisor = {
enabled: true,
method: ‘MACD‘,
candleSize: 180, //unit is minutes
historySize: 4, //this is the historySize in the UI

// MACD settings:
config.MACD = {
// EMA weight (α)
// the higher the weight, the more smooth (and delayed) the line
short: 10,
long: 21,
signal: 9,
// the difference between the EMAs (to act as triggers)
thresholds: {
down: -0.025,
up: 0.025,
// How many candle intervals should a trend persist
// before we consider it real?
persistence: 1

Make sure the paperTrader is enabled, to actually simulate orders (tip: around line 65).

config.paperTrader = {
enabled: true,
// report the profit in the currency or the asset?
reportInCurrency: true,
// start balance, on what the current balance is compared with
simulationBalance: {
// these are in the unit types configured in the watcher.
asset: 1,
currency: 100,
// how much fee in % does each trade cost?
feeMaker: 0.16,
feeTaker: 0.26,
feeUsing: ‘taker’,
// how much slippage/spread should Gekko assume per trade?
slippage: 0.05,

And the performanceAnalyser should also be enabled, line 100.

config.performanceAnalyzer = {
enabled: true,
riskFreeReturn: 5

Remember ? Gekko will use the market, currency and asset defined at the beginning of the file, as we saw when we imported data using the CLI. I want to use the dataset from Kraken, so I’ll edit it: = {

// see
exchange: ‘kraken’,
currency: ‘EUR’,
asset: ‘ETH’,

// You can set your own tickrate (refresh rate).
// If you don’t set it, the defaults are 2 sec for
// okcoin and 20 sec for all other exchanges.
// tickrate: 20

Now scroll down to line 332 to edit the timerange we want to use. I’ll stick with the ‘scan’ option as I have only one dataset for kraken, so no conflict or choice to do, and kraken will use the whole timeframe available. If I want to reduce the timefram, I just have to comment out the daterange: ‘scan’ line, and uncomment and modify the 4 next lines.

config.backtest = {
daterange: ‘scan’,
// daterange: {
// from: “2018-03-01”,
// to: “2018-04-28”
batchSize: 50

Now, we launch it with

node gekko –config config.js –backtest

As you can see we get the same feedback as the one we had on the UI, without the graphical timeline of course.

Testing your strategy on a live market with a Live “paperTrader” Gekko

On the UI, click on the “Live Gekkos” top menu. The Market watchers are modules launched to gather live data from the markets you will configure for each Live Gekko. The strat runners are the paperTraders module: they analyze the market and use the STRATegy you defined on those data, to provide you feedback about what orders were simulated, and their results.

Here I choosed the MACD strategy, and configured it with 5 minutes candles, for this example, as I didn’t want to wait for hours to take screenshots 🙂

Note that on the right, we choose the PAper Trader option, as we want to simulate the strategy on the live market.

Now let’s configure Kraken’s fees on the paper Trader options below.

And we start it. A lot of things will change on the screen, but during the 10 first minutes we won’t see anything interesting as Gekko is gathering data, then it needs 1 candle of 5 minutes of history to start to eventually take decisions, depending on the market and your strategy and your strategy’s settings.

While we are waiting for the first information to appear, let’s try to come back on the “Live Gekkos” page.

So here I think we can see a little bug in the UI, as it says the duration since we launched the Market Watcher (which was automatically launched by Gekko) is 2h32mn which is wrong. I think there is a mismatch between UTC times and local time to calculate the duration. Not a big issue.

The Strat runner we launched is running, we can see that it did nothing yet: 0 trade, PnL (Profit and Loss) is 0, etc. You can click on its line to come back to the detailled view of this Strat runner.

After a few warmup minutes …

But we still can’t see any roundtrip, as Gekko only performed one trade for now (Amount of trades: 1 in the Runtime section). While we are waiting, please note that you can also manually check Gekko’s logs on the filesystem:

cd <gecko_installdir>/logs

ls -al

tail -f *

Now, I will stop this test (just click on the big red button inside the Strat runner section), and switch to the CLI to launch it manually, as I prefer to not depend on a CLI to perform operations.

To use the CLI is easy, as we already configured the appropriate sections in config.js and especially we enabled the config.paperTrader. IF we want to launch a real live Gekko on a market, the paperTrader will need to be disabled in the conf.

We just have to launch:

node gekko –config config.js

As running a livebot is supposed to be a very long activity, I don’t want to depend on my terminal (which could be unfortunately closed) and want it to run in the background. I’ll still be able to check and analyze the logs to understand what happened.

So we will create a small shell script to launch our livebot through PM2 as explained in the Gekko Installation page, and in PM2 documentation.

gekko@bitbot:~/gekko$ cat


rm logs/*
pm2 start gekko.js –name TESTBOT_MACD -e logs/err.log -o logs/out.log — –config config-livetestbot.js


Now when we use to launch our livebot, it will run in the background until you stop it with pm2 <id> stop, and you can check its logs in <gekko_installdir>/logs

Running a “real live” tradebot

In the UI, let’s try to run a real Gekko on Kraken. Please note that we choosed “tradebot” on the right, and that there is no more paperTrader settings, with your amount of currency, assets, etc.

This is normal as a live tradebot will gather your amount of assets and available currency directly from your trading portal (Kraken, Binance, etc.). Yes … we want real trading with real money !

But please remember our quick test with the stock MACD strategy was not so good ! So you need a lot of tests, and to understand the strategies and how to improve them, if you want to really go “live”. And even with good backtesting results, those results will only be good on PAST data, not incoming data from the markets. Therefore, even with a very good strategy on past data, you could have a very bad strategy with new data (this is called overfitting).

After this gentle reminder, let’s try to click on theblue “Start” button.

Yes, this is normal, we want to go live, so we need to configure our trading platform’s credentials somewhere.

You can do it through the UI once again:

Let’s try to add junk data, and see where it ends. I won’t explain how to create an account on a trading platform, I suppose you already know how to do it and already have one. Otherwise, search a little bit.

gekko@bitbot:~/gekko_test/gekko$ cat SECRET-api-keys.json

Okay so the fake data I used for the test ended up in <gekko_installdir>/SECRET-api-keys.json. This is a file you can edit without the UI to add several keys, for several accounts you may have on several platforms. The keys are then used by Gekko to connect to the platforms under your account and perform potential real buy/sell operations. Once again, take care and be warned ! You will most probably loose money !

Another needed step is to reviw a little bit our config.js file:

  • config.paperTrader needs to be disabled for the real trading plugin to work.

config.paperTrader = {
enabled: false,

  • You will also need to enable the config.trader section (I need to check if the keys in SECRET-api-keys.json are still mandatory if also put here:

config.trader = {
enabled: true,
username: ”, // your username, only required for specific exchanges.
passphrase: ” // GDAX, requires a passphrase.

Now you can launch your trading bot through the UI. OR by the CLI, exactly the same way we did for the paperTrader as there was no option on the command line, we just modified the configuration do disable a module and enable another one:

node gekko –config your-config-file.js

Or with PM2 as we saw before.

Please, remember this is a very risky game. You will most probably loose money or assets. Standards strategies are provided by Gekko’s creator as examples, they need to be tweaked and this is not easy. Also, at tartup, Gekko may directly try to sell or buy, even if the market is not good. This needs to be controled and fixed by coding in the strategies. You need to understand what you do, and when to do it. I CAN NOT BE RESPONSIBLE FOR YOUR LOSSES.

Gekko Trading bot installation

Gekko installation (Linux)

Installing gekko is quite simple, everything is described on its homepage, thanks to Mike von Rossum, Gekko’s creator & maintainer.

On a standard Linux distro (I use a small Debian VM on an Intel NUC running vSphere acting as a personal server at home):

Install nodejs:

sudo apt-get install nodejs

Install git:

sudo apt-get install git

Install Pm2 (not mandatory but I like to use it to keep track of my various Gekko’s instances running):

sudo npm install pm2 -g 

Download Gekko:

git clone git:// -b stable
cd gekko

Install Gekko’s dependancies (note: after installation, do NOT run npm audit with –force as suggested by npm, I can confirm it will break Gekko and you will have to redo previous operations):

npm install --only=production

Install Gekko’s broker module dependancies:

cd exchange
npm install --only=production && cd ..

Now, as I want to access Gekko’s UI from other computers in my home network, I need to configure a few things. Edit & change:

  • <your_gekko_install_dir>/web/vue/dist/UIconfig.js

api: {

host: ‘‘,

port: 3000,

timeout: 120000 // 2 minutes



api: {

host: ‘‘,

port: 3000,

timeout: 600000 // 10 minutes



ui: {

ssl: false,

host: ‘localhost‘,

port: 3000,

path: ‘/’



ui: {

ssl: false,

host: ‘x.x.x.x‘, // Set this to the IP of the machine that will run Gekko

port: 3000,

path: ‘/’


  • <your_gekko_install_dir>/web/vue/public/UIconfig.js and only change:

api: {

host: ‘’,

port: 3000,

timeout: 120000 // 2 minutes



api: {

host: ‘’,

port: 3000,

timeout: 600000 // 10 minutes


Hint: modifying the timeout is not in standard Gekko’s documentation. But it will be useful later.

As explained in standard Gekko’s configuration, this will allow you to access the Gekko UI by going to http://x.x.x.x:3000 in a web browser (of course change x.x.x.x with the IP of the machine that will run Gekko and that you defined in
<your_gekko_install_dir>/web/vue/dist/UIconfig.js as seen above).

Beware, Gekko is absolutely NOT secured. There is no authentication mecanisms in Gekko. This configuration should ONLY be activated in a trusted internal network. If you launch it this way on a computer/server reachable from Internet, especially on port 3000, then ANYONE can access your Gekko.

Now launch gekko UI:

node gekko --ui

On http://x.x.x.x:3000 you should see something like that. Congratulations you’ve just achieved the easiest part !

Now we will make it launchable through pm2:

  • In <your_gekko_install_dir>, create a new file called
  • Put this inside and save it
rm ui_logs/*
pm2 start gekko.js --name gekko_ui --log-date-format="YYYY-MM-DD HH:mm Z" -e ui_logs/ui_err.log -o ui_logs/ui_out.log -- --ui max_old_space_size=8096

Make it executable:

chmod 755


  • When you want to launch Gekko’s UI you have to use
  • If you want to check Gekko’s UI state you can use: pm2 ls

If you want to check Gekko’s UI logs you can use
(and note its id in the second column, and that is is also displaying the name we gave (gekko_ui) to this instance in the shell script) :

pm2 log <id>
  • If you want to stop it you can use:
pm2 stop <id>
  • If you want to remove a stopped instance from pm2 list of process, you can use:
pm2 delete <id>

There are plenty more things available with pm2, please check its documentation.

Gekko installation (Windows 10)

Well this part will be quite simple as it consists in two short parts:

  1. Use W10 capacity to use a Linux sub-system to deploy a Debian or Ubuntu distro directly “runnable” inside Windows, using this documentation and then this one
  2. Once it is installed and running, you can come back at the beginning of this page and follow the exact same instructions !

%d bloggers like this: