Hi everyone,

I just started using Freqtrade and I'm really enjoying experimenting with it. I was wondering what strategies you all are using and if anyone is willing to share or offer advice. Currently I’m using NASOSv4 and would greatly appreciate any insights you may have!

Thank you!

Hey, i want to test automated trading following a really specific strategy. My objective is to learn, not to become rich in ten min. What i plan to do : i'll start with a really small amount of money (10/20$) that i don't fear to loose. Then apply or mix those two strategies :
1- aim for brand new crypto coins that are gonna gain 60% in a day and then disappear for ever -> agressive but more profitable with a so small amount of money.
2- aim for a lot of mini trades per days (like 15 trades at 2%) -> way safer.
So, what should i do ? Should i go for freqtrade or should i make my own bot ? Im asking the question because after some researches, i learnt that usually, automated bot are for strategies with a bigger amount of money, and probably won't be optimized for my personal use.
IMPORTANT : pls, don't say "it is not gonna work come back later", it won't help at all. I wanna try, don't care if it fails or not. Also, for a teen like me, +50$ is already big.
Thanks !

A month or two ago, I wrote a strategy in Freqtrade and it managed to double the initial capital. In backtesting in 5 years timeframe. If I remember correctly, it was either on the 1-hour or 4-hour timeframes where the profit came in. At the time, I thought I had posted about what to do next, but it seems that post got deleted. Since I got busy with other projects, I completely forgot about it. Anyway, I'm sharing the strategy below in case anyone wants to test it or build on it. Cheers!

"""
Enhanced 4-Hour Futures Trading Strategy with Focused Hyperopt Optimization
Optimizing only trailing stop and risk-based custom stoploss.
Other parameters use default values.

Author: Freqtrade Development Team (Modified by User, with community advice)
Version: 2.4 - Focused Optimization
Timeframe: 4h
Trading Mode: Futures with Dynamic Leverage
"""

import logging
from datetime import datetime

import numpy as np
import talib.abstract as ta
from pandas import DataFrame 
# pd olarak import etmeye gerek yok, DataFrame yeterli

import freqtrade.vendor.qtpylib.indicators as qtpylib
from freqtrade.persistence import Trade
from freqtrade.strategy import IStrategy, DecimalParameter, IntParameter

logger = logging.getLogger(__name__)


class AdvancedStrategyHyperopt_4h(IStrategy):
    
# Strategy interface version
    interface_version = 3

    timeframe = '4h'
    use_custom_stoploss = True
    can_short = True
    stoploss = -0.99  
# Emergency fallback

    
# --- HYPEROPT PARAMETERS ---
    
# Sadece trailing ve stoploss uzaylarındaki parametreler optimize edilecek.
    
# Diğerleri default değerlerini kullanacak (optimize=False).

    
# Trades space (OPTİMİZE EDİLMEYECEK)
    max_open_trades = IntParameter(3, 10, default=8, space="trades", load=True, optimize=False)

    
# ROI space (OPTİMİZE EDİLMEYECEK - Class seviyesinde sabitlenecek)
    
# Bu parametreler optimize edilmeyeceği için, minimal_roi'yi doğrudan tanımlayacağız.
    
# roi_t0 = DecimalParameter(0.01, 0.10, default=0.08, space="roi", decimals=3, load=True, optimize=False)
    
# roi_t240 = DecimalParameter(0.01, 0.08, default=0.06, space="roi", decimals=3, load=True, optimize=False)
    
# roi_t480 = DecimalParameter(0.005, 0.06, default=0.04, space="roi", decimals=3, load=True, optimize=False)
    
# roi_t720 = DecimalParameter(0.005, 0.05, default=0.03, space="roi", decimals=3, load=True, optimize=False)
    
# roi_t1440 = DecimalParameter(0.005, 0.04, default=0.02, space="roi", decimals=3, load=True, optimize=False)

    
# Trailing space (OPTİMİZE EDİLECEK)
    hp_trailing_stop_positive = DecimalParameter(0.005, 0.03, default=0.015, space="trailing", decimals=3, load=True, optimize=True)
    hp_trailing_stop_positive_offset = DecimalParameter(0.01, 0.05, default=0.025, space="trailing", decimals=3, load=True, optimize=True)
    
    
# Stoploss space (OPTİMİZE EDİLECEK - YENİ RİSK TABANLI MANTIK İÇİN)
    hp_max_risk_per_trade = DecimalParameter(0.005, 0.03, default=0.015, space="stoploss", decimals=3, load=True, optimize=True) 
# %0.5 ile %3 arası

    
# Indicator Parameters (OPTİMİZE EDİLMEYECEK - Sabit değerler kullanılacak)
    
# Bu parametreler populate_indicators içinde doğrudan sabit değer olarak atanacak.
    
# ema_f = IntParameter(10, 20, default=12, space="indicators", load=True, optimize=False)
    
# ema_s = IntParameter(20, 40, default=26, space="indicators", load=True, optimize=False)
    
# rsi_p = IntParameter(10, 20, default=14, space="indicators", load=True, optimize=False)
    
# atr_p = IntParameter(10, 20, default=14, space="indicators", load=True, optimize=False)
    
# ob_exp = IntParameter(30, 80, default=50, space="indicators", load=True, optimize=False) # Bu da sabit olacak
    
# vwap_win = IntParameter(30, 70, default=50, space="indicators", load=True, optimize=False)

    
# Logic & Threshold Parameters (OPTİMİZE EDİLMEYECEK - Sabit değerler kullanılacak)
    
# Bu parametreler populate_indicators veya entry/exit trend içinde doğrudan sabit değer olarak atanacak.
    
# hp_impulse_atr_mult = DecimalParameter(1.2, 2.0, default=1.5, decimals=1, space="logic", load=True, optimize=False)
    
# ... (tüm logic parametreleri için optimize=False ve populate_xyz içinde sabit değerler)

    
# --- END OF HYPEROPT PARAMETERS ---

    
# Sabit (optimize edilmeyen) değerler doğrudan class seviyesinde tanımlanır
    trailing_stop = True 
    trailing_only_offset_is_reached = True
    trailing_stop_positive = 0.015
    trailing_stop_positive_offset = 0.025
    
# trailing_stop_positive ve offset bot_loop_start'ta atanacak (Hyperopt'tan)

    minimal_roi = { 
# Sabit ROI tablosu (optimize edilmiyor)
        "0": 0.08,
        "240": 0.06,
        "480": 0.04,
        "720": 0.03,
        "1440": 0.02
    }
    
    process_only_new_candles = True
    use_exit_signal = True
    exit_profit_only = False
    ignore_roi_if_entry_signal = False

    order_types = {
        'entry': 'limit', 'exit': 'limit',
        'stoploss': 'market', 'stoploss_on_exchange': False
    }
    order_time_in_force = {'entry': 'gtc', 'exit': 'gtc'}

    plot_config = {
        'main_plot': {
            'vwap': {'color': 'purple'}, 'ema_fast': {'color': 'blue'},
            'ema_slow': {'color': 'orange'}
        },
        'subplots': {"RSI": {'rsi': {'color': 'red'}}}
    }

    
# Sabit (optimize edilmeyen) indikatör ve mantık parametreleri
    
# populate_indicators ve diğer fonksiyonlarda bu değerler kullanılacak
    ema_fast_default = 12
    ema_slow_default = 26
    rsi_period_default = 14
    atr_period_default = 14
    ob_expiration_default = 50
    vwap_window_default = 50
    
    impulse_atr_mult_default = 1.5
    ob_penetration_percent_default = 0.005
    ob_volume_multiplier_default = 1.5
    vwap_proximity_threshold_default = 0.01
    
    entry_rsi_long_min_default = 40
    entry_rsi_long_max_default = 65
    entry_rsi_short_min_default = 35
    entry_rsi_short_max_default = 60
    
    exit_rsi_long_default = 70
    exit_rsi_short_default = 30
    
    trend_stop_window_default = 3


    def bot_loop_start(self, **kwargs) -> None:
        super().bot_loop_start(**kwargs)
        
# Sadece optimize edilen parametreler .value ile okunur.
        self.trailing_stop_positive = self.hp_trailing_stop_positive.value
        self.trailing_stop_positive_offset = self.hp_trailing_stop_positive_offset.value
        
        logger.info(f"Bot loop started. ROI (default): {self.minimal_roi}") 
# ROI artık sabit
        logger.info(f"Trailing (optimized): +{self.trailing_stop_positive:.3f} / {self.trailing_stop_positive_offset:.3f}")
        logger.info(f"Max risk per trade for stoploss (optimized): {self.hp_max_risk_per_trade.value * 100:.2f}%")

    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
                        current_rate: float, current_profit: float, **kwargs) -> float:
        max_risk = self.hp_max_risk_per_trade.value 

        if not hasattr(trade, 'leverage') or trade.leverage is None or trade.leverage == 0:
            logger.warning(f"Leverage is zero/None for trade {trade.id} on {pair}. Using static fallback: {self.stoploss}")
            return self.stoploss
        if trade.open_rate == 0:
            logger.warning(f"Open rate is zero for trade {trade.id} on {pair}. Using static fallback: {self.stoploss}")
            return self.stoploss
        
        dynamic_stop_loss_percentage = -max_risk 
        
# logger.info(f"CustomStop for {pair} (TradeID: {trade.id}): Max Risk: {max_risk*100:.2f}%, SL set to: {dynamic_stop_loss_percentage*100:.2f}%")
        return float(dynamic_stop_loss_percentage)

    def leverage(self, pair: str, current_time: datetime, current_rate: float,
                 proposed_leverage: float, max_leverage: float, entry_tag: str | None,
                 side: str, **kwargs) -> float:
        
# Bu fonksiyon optimize edilmiyor, sabit mantık kullanılıyor.
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        if dataframe.empty or 'atr' not in dataframe.columns or 'close' not in dataframe.columns:
            return min(10.0, max_leverage)
        
        latest_atr = dataframe['atr'].iloc[-1]
        latest_close = dataframe['close'].iloc[-1]
        if latest_close <= 0 or np.isnan(latest_atr) or latest_atr <= 0: 
# pd.isna eklendi
            return min(10.0, max_leverage)
        
        atr_percentage = (latest_atr / latest_close) * 100
        
        base_leverage_val = 20.0 
        mult_tier1 = 0.5; mult_tier2 = 0.7; mult_tier3 = 0.85; mult_tier4 = 1.0; mult_tier5 = 1.0

        if atr_percentage > 5.0: lev = base_leverage_val * mult_tier1
        elif atr_percentage > 3.0: lev = base_leverage_val * mult_tier2
        elif atr_percentage > 2.0: lev = base_leverage_val * mult_tier3
        elif atr_percentage > 1.0: lev = base_leverage_val * mult_tier4
        else: lev = base_leverage_val * mult_tier5
        
        final_leverage = min(max(5.0, lev), max_leverage)
        
# logger.info(f"Leverage for {pair}: ATR% {atr_percentage:.2f} -> Final {final_leverage:.1f}x")
        return final_leverage

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe['ema_fast'] = ta.EMA(dataframe, timeperiod=self.ema_fast_default)
        dataframe['ema_slow'] = ta.EMA(dataframe, timeperiod=self.ema_slow_default)
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=self.rsi_period_default)
        dataframe['vwap'] = qtpylib.rolling_vwap(dataframe, window=self.vwap_window_default)
        dataframe['atr'] = ta.ATR(dataframe, timeperiod=self.atr_period_default)

        dataframe['volume_avg'] = ta.SMA(dataframe['volume'], timeperiod=20) 
# Sabit
        dataframe['volume_spike'] = (dataframe['volume'] >= dataframe['volume'].rolling(20).max()) | (dataframe['volume'] > (dataframe['volume_avg'] * 3.0))
        dataframe['bullish_volume_spike_valid'] = dataframe['volume_spike'] & (dataframe['close'] > dataframe['vwap'])
        dataframe['bearish_volume_spike_valid'] = dataframe['volume_spike'] & (dataframe['close'] < dataframe['vwap'])
        
        dataframe['swing_high'] = dataframe['high'].rolling(window=self.trend_stop_window_default).max() 
# trend_stop_window_default ile uyumlu
        dataframe['swing_low'] = dataframe['low'].rolling(window=self.trend_stop_window_default).min()   
# trend_stop_window_default ile uyumlu
        dataframe['structure_break_bull'] = dataframe['close'] > dataframe['swing_high'].shift(1)
        dataframe['structure_break_bear'] = dataframe['close'] < dataframe['swing_low'].shift(1)

        dataframe['uptrend'] = dataframe['ema_fast'] > dataframe['ema_slow']
        dataframe['downtrend'] = dataframe['ema_fast'] < dataframe['ema_slow']
        dataframe['price_above_vwap'] = dataframe['close'] > dataframe['vwap']
        dataframe['price_below_vwap'] = dataframe['close'] < dataframe['vwap']
        dataframe['vwap_distance'] = abs(dataframe['close'] - dataframe['vwap']) / dataframe['vwap']

        dataframe['bullish_impulse'] = (
            (dataframe['close'] > dataframe['open']) &
            ((dataframe['high'] - dataframe['low']) > dataframe['atr'] * self.impulse_atr_mult_default) &
            dataframe['bullish_volume_spike_valid']
        )
        dataframe['bearish_impulse'] = (
            (dataframe['close'] < dataframe['open']) &
            ((dataframe['high'] - dataframe['low']) > dataframe['atr'] * self.impulse_atr_mult_default) &
            dataframe['bearish_volume_spike_valid']
        )

        ob_bull_cond = dataframe['bullish_impulse'] & (dataframe['close'].shift(1) < dataframe['open'].shift(1))
        dataframe['bullish_ob_high'] = np.where(ob_bull_cond, dataframe['high'].shift(1), np.nan)
        dataframe['bullish_ob_low'] = np.where(ob_bull_cond, dataframe['low'].shift(1), np.nan)

        ob_bear_cond = dataframe['bearish_impulse'] & (dataframe['close'].shift(1) > dataframe['open'].shift(1))
        dataframe['bearish_ob_high'] = np.where(ob_bear_cond, dataframe['high'].shift(1), np.nan)
        dataframe['bearish_ob_low'] = np.where(ob_bear_cond, dataframe['low'].shift(1), np.nan)

        for col_base in ['bullish_ob_high', 'bullish_ob_low', 'bearish_ob_high', 'bearish_ob_low']:
            expire_col = f'{col_base}_expire'
            if expire_col not in dataframe.columns: dataframe[expire_col] = 0 
            for i in range(1, len(dataframe)):
                cur_ob, prev_ob, prev_exp = dataframe.at[i, col_base], dataframe.at[i-1, col_base], dataframe.at[i-1, expire_col]
                if not np.isnan(cur_ob) and np.isnan(prev_ob): dataframe.at[i, expire_col] = 1
                elif not np.isnan(prev_ob):
                    if np.isnan(cur_ob):
                        dataframe.at[i, col_base], dataframe.at[i, expire_col] = prev_ob, prev_exp + 1
                else: dataframe.at[i, expire_col] = 0
                if dataframe.at[i, expire_col] > self.ob_expiration_default: 
# Sabit değer kullanılıyor
                    dataframe.at[i, col_base], dataframe.at[i, expire_col] = np.nan, 0
        
        dataframe['smart_money_signal'] = (dataframe['bullish_volume_spike_valid'] & dataframe['price_above_vwap'] & dataframe['structure_break_bull'] & dataframe['uptrend']).astype(int)
        dataframe['ob_support_test'] = (
            (dataframe['low'] <= dataframe['bullish_ob_high']) &
            (dataframe['close'] > (dataframe['bullish_ob_low'] * (1 + self.ob_penetration_percent_default))) &
            (dataframe['volume'] > dataframe['volume_avg'] * self.ob_volume_multiplier_default) &
            dataframe['uptrend'] & dataframe['price_above_vwap']
        )
        dataframe['near_vwap'] = dataframe['vwap_distance'] < self.vwap_proximity_threshold_default
        dataframe['vwap_pullback'] = (dataframe['uptrend'] & dataframe['near_vwap'] & dataframe['price_above_vwap'] & (dataframe['close'] > dataframe['open'])).astype(int)

        dataframe['smart_money_short'] = (dataframe['bearish_volume_spike_valid'] & dataframe['price_below_vwap'] & dataframe['structure_break_bear'] & dataframe['downtrend']).astype(int)
        dataframe['ob_resistance_test'] = (
            (dataframe['high'] >= dataframe['bearish_ob_low']) &
            (dataframe['close'] < (dataframe['bearish_ob_high'] * (1 - self.ob_penetration_percent_default))) &
            (dataframe['volume'] > dataframe['volume_avg'] * self.ob_volume_multiplier_default) &
            dataframe['downtrend'] & dataframe['price_below_vwap']
        )
        dataframe['trend_stop_long'] = dataframe['low'].rolling(self.trend_stop_window_default).min().shift(1)
        dataframe['trend_stop_short'] = dataframe['high'].rolling(self.trend_stop_window_default).max().shift(1)
        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (dataframe['smart_money_signal'] > 0) & (dataframe['ob_support_test'] > 0) &
            (dataframe['rsi'] > self.entry_rsi_long_min_default) & (dataframe['rsi'] < self.entry_rsi_long_max_default) &
            (dataframe['close'] > dataframe['ema_slow']) & (dataframe['volume'] > 0),
            'enter_long'] = 1
        dataframe.loc[
            (dataframe['smart_money_short'] > 0) & (dataframe['ob_resistance_test'] > 0) &
            (dataframe['rsi'] < self.entry_rsi_short_max_default) & (dataframe['rsi'] > self.entry_rsi_short_min_default) &
            (dataframe['close'] < dataframe['ema_slow']) & (dataframe['volume'] > 0),
            'enter_short'] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            ((dataframe['close'] < dataframe['trend_stop_long']) | (dataframe['rsi'] > self.exit_rsi_long_default)) & 
            (dataframe['volume'] > 0), 'exit_long'] = 1
        dataframe.loc[
            ((dataframe['close'] > dataframe['trend_stop_short']) | (dataframe['rsi'] < self.exit_rsi_short_default)) & 
            (dataframe['volume'] > 0), 'exit_short'] = 1
        return dataframe

Hello traders, hope you are making lots of profits today

TL;DR: I'm exploring freqtrade and offering a free backtesting service for your trading strategies. Share your profitable strategies, and I'll analyze their performance using historical data. You'll receive the backtesting results, plots, and trade details. Your strategy will remain confidential, and if it proves successful, I may share the bot configuration with you and the community (with your permission).

A few ago recently my interest in trading and programming was born so I’m trying a tool named freqtrade.

Freqtrade is an open-source cryptocurrency trading bot framework that enables users to develop, backtest, and deploy automated trading strategies based in technical indicators.

I'm currently looking for trading strategies and I would love to collaborate with you. If you think you have a profitable trading strategy that you would like to share, I'm offering a free backtesting service to validate its performance.

Here's how I think this can work:

1. You provide me with the details of your trading strategy, including the entry and exit conditions, indicators used, risk management rules, and any other relevant information. (And some examples)

2. I'll do a backtesting of your strategy using historical price data to assess its profitability.

3. I'll share the results of the backtesting with you, the plot and an excel with all the trades

4. In return, I kindly ask for permission to include your strategy (anonymously, if preferred) in my collection, which I may use for personal reference or future research.

My goal is to find a profitable strategy and share it with the original owner when the bot is up and running, only if the owner wants to, I’ll can share it with the community.

You will find a basic strategy in the comments, It’s just an example, it’s not profitable enough.

Notes:

• I am not a programmer nor a trader (yet) and this is only a hobby for me, not a job.

• I am NOT asking money for this, maybe later I can offer the backtesting as service, but not now.

• If you don’t want to share your strategy with anybody, you can DM.

• For now, I only use the BTC/USDT pair for backtesting, but we can use anyone.

Trying to get into crypto trading and wondering if you have any thoughts on this package. I've been trying to learn it for the past week or two and am wondering if it's actually worth learning. It seems like you can do guess and check worth with different strategies, but when I started getting into trading I imagined it more with ML.

Will freqtrade allow me to do ML outright or in combination with other packages? Is ML used more for developing a strategy rather than running one? Any good ML packages?

I potentially want to be able to assess things on different time bases such as looking at an indicator at the 15m interval (at least every minute) and another indicator at the same time with the 30m interval. Can freqtrade do this? It doesn't seem to have the flexibility based on the inputs of the config file.

To expand, would I be able to create a RSI30 variable (30m RSI) along with a MFI15 variable in a dataframe and use them for strategy? Is there a limit on disk space for doing this? I imagine I would have to keep [thousands] of rows in memory to get 30m+ indicators for every desired pair. Is that idea feasible in general (16GB RAM), not just with freqtrade?

It seems like the ease of setting up a bot with freqtrade would be worthwhile so I'm wondering if you have any input?

P.S., any tips/articles on efficiently learning a python package and how everything flows together?

I have been using daily ohlc data previously to get used to, but moving on to more precise data. I have found a way of getting the whole order book, with # of shares with the bidded/asked price. I can get this with realistically 10 or 15 min intervals, depending on how often I schedule my script. I store data in MySQL

My question is, if all this is even necessary. Or if 10 min timeframes with ohlc data is preferred for you guys. I can get this at least for crude oil. So another question is, if its a good idea to just trade a single security?? I started this project last summer, so I am not a pro at this.

I havent come up with what strategies I want to use yet. My thinking is regardless «more data, the better results» . I figure I am just gonna make that up as I go. The main discipline I am learning is programming the infrastructure.

Have a great day ahead

Hey fellow traders.. for me, one of the biggest challenges in building an effective, well-tuned trading strategy for bot trading, in my case with open-source FreqTrade, is being able to visually see, in real time, WHAT the indicators are showing. It’s one thing to say “okay, when fastK and fastD are above x number, and RSI is below x, indicate a buy signal” but it’s a game changer to see that happen graphically, AND even overlay indicators I’m not actively using, to see what they’re saying during critical market conditions. I made a short video showing how I do it, I hope you find it useful… check it out!

https://youtu.be/t0m1I_vVsIA

After years of learning, stressing out, doing horrible emotional mistakes, i found my way of dealing with the fear of missing out in trading and the trading itch.

Creating your own bot that does everything automatically for you 24/7.
This way you are free to do whatever else you want with your otherwise wasted time looking and analysing charts and focus on accumulating aswell as having some trading on the side.

I'm not saying this is better/worse, i'm just saying it's the alternative i found for me and has been working out.

The bot is always exposed to the market so if you let it run without interveining (prevent it to stop buying for a period or force sell current positions etc) it will also get losses but from backtesting the strategy and live testing it i noticed it always recovers over time, and better than i would trading anyway.

But it is always under your control.

Also this post is merely representative and only scratches the surface of the bot's capabillities, there's tons more depth to this framework but i linked all the documentation you need :)

My bot results since live trading starting a month ago:

How i made the bot and what can it do?

Using a FOSS Python framework done by Freqtrade, hosting it on a raspberry pi 4, but can also be hosted on a vps for example.

I chose freqtrade because it has great documentation, API and TG integration so you can easily interact and control the bot from telegram and it also supports ML hyperoptimization for your strategy.

You can also plot and visualize your strategy and it has tons more features. You can do pretty much anything with python.

After installing freqtrade, (guide in the webpage), you will have to develop a strategy based on buying signals that you populate using parameters, in my case indicators from TA lib.

They have a git repo with alot of free strategies you can start with and try/change:

free strats :)

Once you develope your strategy you can downlaod data from an exchange through your api keys and backtest the strategy against it and analyse/improve it for different time periods.

You then can use ML and optimize your parameters and Stop loss values and ROI table (rules that the bot uses to take profits according to trade duration) and you also have features like trailing stop loss etc.

After the hyperopt is finished, you get a new set of parameters that improve your strategy based on the data you input. After that it's rinse and repeat until you are satisfied with your strategy.

All you have to do now is run your strategy in dry_run mode for simulating how it would do in Real time and once you're confortable change it to live trading, and enjoy the bot trading for you :)

So you guys may have seen some of my previous posts, where I shared several open sourced crypto trading algorithms that I coded. Many of you asked if they have been backtested and how that would work.

So I created this quick tool to help you assess the profitablity of your trading strategy of trading bot if you're using one.

Backtesting is a way of feeding your current trading strategy to a script that applies it on historical data, in order to determine how successful it could be in the future.

Past performance does not always guarantee future returns, but it's good practice to test your strategy (or trading algorithm) before you go ham.

The script downloads historical data for a coin of your choice, and at an interval of your choosing. This is then used by the script to determine how profitable a strategy can be, and whether it has the potential to beat a buy and hold.

At the end of the testing phase, the tool will generate a plot showing each trade and final balance.

Working with historical data since the start of this year, I fed it a simple strategy - buy if the price is up 1% in the last minute. Sell at 10% gain or 5% loss - but you can customise these parameters yourself. This strategy made a marginal loss on ICPUSDT, but then this is probably not the best coin to test on since it's been in decline ever since it was listed on Binance.

Here's the same strategy on NANOUSDT, seems like we're $800 in profit.

Happy Testing!

Here's the guide on how to implement it:

https://www.cryptomaton.org/2021/05/16/trailing-stop-loss-and-more-improvements-added-to-the-binance-volatility-trading-bot/

And here's the repo if you're a python wizard:

https://github.com/CyberPunkMetalHead/backtesting-for-cryptocurrency-trading

Hi, I got vps running and want try some free bots I was thinking Freqtrade or Hummingbot. Which one is better to stick to? Which one is easier to set up strategy?

Installed both to see GUI and Freqtrade looks better to me on first looks.

Do they works okay and public strats are enough to get started?

Any other bots to look at?

Also is there any SOLana good bots on GitHub? 🙏

Quick disclaimer before some of you insult me in the comments, I'm not looking for an easy way to make money. I'm just a programmer that thinks that cryptocurrencies and blockchain in general are the future and wants to learn from trading experts.

Having said so, I recently discovered Freqtrade and I fell in love with how beautiful its code is. I know something about trading but I'm certainly no expert and I wanted to get some information from people who definitely have more knowledge then me on what is the best trading strategy for the current market state and for other states in general.

I'm new to investing but I am a programmer since 2013. I found Freqtrade on github. It has pretty nice documentation and I was able to successfully write and run my own strategy using it. However, I want to expand from here. Does anyone know a comparable trading bot framework for stocks? Basically I am looking for a trading bot framework like Freqtrade but for stocks that I could use for brokerage accounts like E*Trade. I looked on github but most of the trading bots seem to be focused on crypto trading.

I KNOW people aren't going to post their working algos online. I was curious if there were examples of full systems online. Like I said they could be total failures from a strategy perspective. Basically just trying to look at the general structure of what a full system might look like.

Heya guys,

I don’t know if it’s the right place to ask but i am looking for 30/40€ per month vps that will allow me and have enouph cpu + ram to :

1- run multiple freqtrade bots 2- do complex hyperopt optimizations with like 3 or 5k epochs, several paramaters on hundreds of pairs.

Not at the same time but why not :)

I really need good infra and good company that i can trust

Hyperopts are my top priority :)

Thanks for your help !

Has anyone used Freqtrade? If so please give insight in your experience or share anything. I am looking to Algo trade crypto and this seems to be a reliable platform.