Freqtrade 2026: Build AI-Powered Crypto Trading Strategies with Machine Learning \u2014 Complete Bot Setup Guide

# Create the user_data directory structure
mkdir -p freqtrade/user_data/strategies
mkdir -p freqtrade/user_data/configs

# Download the official docker-compose file
cd freqtrade
curl -o docker-compose.yml https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docker-compose.yml

# Run the init command to create default config
docker compose run --rm freqtrade new-config --config user_data/config.json

{
  "max_open_trades": 3,
  "stake_currency": "USDT",
  "stake_amount": "unlimited",
  "tradable_balance_ratio": 0.99,
  "fiat_display_currency": "USD",
  "dry_run": true,
  "dry_run_wallet": 1000,
  "cancel_open_orders_on_exit": false,
  "trading_mode": "spot",
  "margin_mode": "",
  "unfilledtimeout": {
    "entry": 10,
    "exit": 10,
    "exit_timeout_count": 0,
    "unit": "minutes"
  },
  "entry_pricing": {
    "price_side": "other",
    "use_order_book": true,
    "order_book_top": 1,
    "price_last_balance": 0.0,
    "check_depth_of_market": {
      "enabled": false,
      "bids_to_ask_delta": 1
    }
  },
  "exit_pricing": {
    "price_side": "other",
    "use_order_book": true,
    "order_book_top": 1
  },
  "exchange": {
    "name": "binance",
    "key": "YOUR_API_KEY",
    "secret": "YOUR_API_SECRET",
    "ccxt_config": {},
    "ccxt_async_config": {}
  },
  "pairlists": [
    {
      "method": "VolumePairList",
      "number_assets": 20,
      "sort_key": "quoteVolume",
      "min_value": 0,
      "refresh_period": 1800
    }
  ],
  "telegram": {
    "enabled": true,
    "token": "YOUR_BOT_TOKEN",
    "chat_id": "YOUR_CHAT_ID",
    "notification_settings": {
      "status": "silent",
      "warning": "on",
      "startup": "off",
      "entry": "silent",
      "exit": "on",
      "entry_cancel": "silent",
      "exit_cancel": "silent",
      "protection_trigger": "off",
      "protection_global": "off"
    }
  },
  "api_server": {
    "enabled": true,
    "listen_ip_address": "0.0.0.0",
    "listen_port": 8080,
    "verbosity": "error",
    "enable_openapi": false,
    "jwt_secret_key": "your-secret-key",
    "ws_token": "your-ws-token",
    "CORS_origins": [],
    "username": "admin",
    "password": "your-secure-password"
  },
  "bot_name": "freqtrade-bot",
  "force_entry_enable": false,
  "internals": {
    "process_throttle_secs": 5
  }
}

# user_data/strategies/SampleStrategy.py
import numpy as np
import talib.abstract as ta
from pandas import DataFrame
from freqtrade.strategy import IStrategy

class SampleStrategy(IStrategy):
    """
    A simple RSI-based strategy for Freqtrade.
    """
    minimal_roi = {
        "0": 0.10,     # 10% profit target
        "30": 0.05,    # 5% after 30 min
        "60": 0.02,    # 2% after 60 min
        "120": 0       # Exit after 120 min
    }
    stoploss = -0.10     # 10% stop loss
    trailing_stop = True
    trailing_stop_positive = 0.02
    trailing_stop_positive_offset = 0.03
    timeframe = '5m'     # 5-minute candles
    can_short = False    # Spot trading only

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # RSI indicator
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
        
        # MACD indicators
        macd = ta.MACD(dataframe)
        dataframe['macd'] = macd['macd']
        dataframe['macdsignal'] = macd['macdsignal']
        dataframe['macdhist'] = macd['macdhist']
        
        # Bollinger Bands
        bollinger = ta.BBANDS(dataframe, timeperiod=20, nbdevup=2.0, nbdevdn=2.0)
        dataframe['bb_lower'] = bollinger['lowerband']
        dataframe['bb_middle'] = bollinger['middleband']
        dataframe['bb_upper'] = bollinger['upperband']
        
        # Average True Range for volatility
        dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
        
        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                (dataframe['rsi'] < 30) &                    # Oversold condition
                (dataframe['macd'] > dataframe['macdsignal']) &  # MACD crossover
                (dataframe['close'] < dataframe['bb_lower'])   # Price below BB lower
            ),
            'enter_long'
        ] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                (dataframe['rsi'] > 70) &                    # Overbought condition
                (dataframe['macd'] < dataframe['macdsignal'])  # MACD crossunder
            ),
            'exit_long'
        ] = 1
        return dataframe

# Start Freqtrade with your strategy
docker compose up -d

# Check logs
docker compose logs -f freqtrade

// Add to config.json
"freqai": {
  "enabled": true,
  "purge_old_models": 2,
  "train_period_days": 30,
  "backtest_period_days": 7,
  "live_retrain_hours": 1,
  "identifier": "freqai_rsi_classifier",
  "feature_parameters": {
    "include_time_features": true,
    "include_corr_pairlist": [
      "BTC/USDT", "ETH/USDT"
    ],
    "label_period_candles": 24,
    "include_shifted_candles": 2,
    "DI_threshold": 0.9,
    "weight_factor": 0.9,
    "principal_component_analysis": false,
    "use_SVM_to_remove_outliers": true,
    "indicator_periods_candles": [10, 20, 50]
  },
  "data_split_parameters": {
    "test_size": 0.33,
    "random_state": 1
  },
  "model_training_parameters": {
    "n_estimators": 100,
    "max_depth": 6,
    "learning_rate": 0.1,
    "num_leaves": 32
  }
}

# user_data/strategies/FreqAIStrategy.py
import pandas as pd
from freqtrade.strategy import IStrategy

class FreqAISrategy(IStrategy):
    """
    Strategy using FreqAI ML predictions as entry signals.
    """
    minimal_roi = {"0": 0.15, "60": 0.05, "120": 0}
    stoploss = -0.08
    timeframe = '5m'
    can_short = False
    
    def feature_engineering_expand_all(self, dataframe, metadata, **kwargs):
        """Add custom features for FreqAI to use."""
        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=14)
        dataframe["macdhist"] = ta.MACD(dataframe)['macdhist']
        dataframe["atr"] = ta.ATR(dataframe, timeperiod=14)
        
        # Add volatility features
        dataframe["volatility"] = dataframe["close"].rolling(24).std()
        dataframe["price_change_1h"] = dataframe["close"].pct_change(12)
        
        return dataframe

    def feature_engineering_expand_basic(self, dataframe, metadata, **kwargs):
        return dataframe

    def feature_engineering_standard(self, dataframe, metadata, **kwargs):
        return dataframe

    def set_freqai_targets(self, dataframe, metadata, **kwargs):
        """Define what we want to predict - price goes up or down."""
        dataframe["&-target"] = (
            dataframe["close"].shift(-24) > dataframe["close"]
        ).astype(int)
        return dataframe

    def populate_indicators(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe = self.freqai.start(dataframe, metadata, self)
        return dataframe

    def populate_entry_trend(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        # Enter when ML predicts upward movement with high confidence
        dataframe.loc[
            (
                (dataframe["&-target"] == 1) &           # ML prediction: up
                (dataframe["do_predict"] == 1) &         # Model is confident
                (dataframe["&-target_probability"] > 0.6)  # Probability > 60%
            ),
            "enter_long"
        ] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
        dataframe.loc[
            (
                (dataframe["&-target"] == 0) |           # ML predicts down
                (dataframe["do_predict"] != 1)             # Model uncertain
            ),
            "exit_long"
        ] = 1
        return dataframe

# Run hyperparameter optimization
docker compose run --rm freqtrade hyperopt \
  --strategy SampleStrategy \
  --spaces buy sell roi stoploss trailing \
  --epochs 100 \
  --timerange 20260101-20260331 \
  --hyperopt-loss SharpeHyperOptLossDaily

# Download historical data first
docker compose run --rm freqtrade download-data \
  --exchange binance \
  --pairs BTC/USDT ETH/USDT SOL/USDT BNB/USDT XRP/USDT \
  --timeframes 5m 15m 1h \
  --timerange 20240101-20260331

# Run backtest
docker compose run --rm freqtrade backtesting \
  --strategy SampleStrategy \
  --timerange 20260101-20260331 \
  --pairs BTC/USDT ETH/USDT SOL/USDT \
  --export trades \
  --export-filename user_data/backtest_results.json

# Run inside Freqtrade's Jupyter container
import pandas as pd
from freqtrade.data.history import load_pair_history
from freqtrade.resolvers import StrategyResolver

# Load historical data
pair = "BTC/USDT"
timeframe = "5m"
 timerange = "20260101-20260331"

data = load_pair_history(
    datadir="user_data/data/binance",
    pair=pair,
    timeframe=timeframe,
    timerange=timerange
)

# Load and run strategy
strategy = StrategyResolver.load_strategy("SampleStrategy")
dataframe = strategy.analyze_ticker(data, {'pair': pair})

# View signals
signals = dataframe[dataframe['enter_long'] == 1]
print(f"Found {len(signals)} entry signals")
print(signals[['date', 'close', 'rsi', 'macdhist']].head(10))

# Start the API server (enabled in config.json)
# Query current status
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/status

# Get trade history
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/trades

# Get profit summary
curl -u admin:your-secure-password \
  http://localhost:8080/api/v1/profit

# Force entry
curl -X POST -u admin:your-secure-password \
  -H "Content-Type: application/json" \
  -d '{"pair": "BTC/USDT", "side": "long"}' \
  http://localhost:8080/api/v1/forceentry

// Advanced risk management settings
"max_open_trades": 3,
"stake_amount": "unlimited",
"tradable_balance_ratio": 0.95,
"amend_last_stake_amount": true,
"available_capital": 5000,
"stake_amount_mode": "unlimited",

"order_types": {
  "entry": "limit",
  "exit": "limit",
  "emergency_exit": "market",
  "stoploss": "market",
  "stoploss_on_exchange": true,
  "stoploss_on_exchange_interval": 60
},

"protections": [
  {
    "method": "CooldownPeriod",
    "stop_duration_candles": 2
  },
  {
    "method": "MaxDrawdown",
    "lookback_period_candles": 48,
    "trade_limit": 20,
    "stop_duration_candles": 4,
    "max_allowed_drawdown": 0.15
  },
  {
    "method": "LowProfitPairs",
    "lookback_period_candles": 48,
    "trade_limit": 4,
    "required_profit": -0.05,
    "stop_duration": 60
  }
]

# Add to your strategy for dynamic stoploss
def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
                    current_rate: float, current_profit: float, **kwargs) -> float:
    """Dynamic stoploss based on ATR."""
    dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
    if dataframe.empty:
        return self.stoploss
    
    last_candle = dataframe.iloc[-1]
    atr = last_candle['atr']
    
    # Stoploss at 2x ATR
    stoploss_price = trade.open_rate - (2 * atr)
    
    # Convert to percentage from current rate
    return stoploss_from_absolute(stoploss_price, current_rate, is_short=trade.is_short)

def informative_pairs(self):
    """Define higher timeframe pairs for analysis."""
    return [
        ("BTC/USDT", "1h"),
        ("ETH/USDT", "1h"),
    ]

def populate_indicators(self, dataframe: pd.DataFrame, metadata: dict) -> pd.DataFrame:
    # Get 1h data for BTC
    inf_pair, inf_timeframe = self.informative_pairs()[0]
    informative = self.dp.get_pair_dataframe(inf_pair, inf_timeframe)
    
    # Calculate 1h trend
    informative['ema50_1h'] = ta.EMA(informative, timeperiod=50)
    informative['ema200_1h'] = ta.EMA(informative, timeperiod=200)
    informative['trend_1h'] = np.where(
        informative['ema50_1h'] > informative['ema200_1h'], 1, -1
    )
    
    # Merge into 5m dataframe
    dataframe = merge_informative_pair(dataframe, informative, self.timeframe, inf_timeframe)
    
    # Only trade in direction of 1h trend
    dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
    
    return dataframe

# docker-compose.yml with GPU support for FreqAI
version: '3.8'

services:
  freqtrade:
    image: freqtradeorg/freqtrade:stable
    container_name: freqtrade_gpu
    restart: unless-stopped
    volumes:
      - ./user_data:/freqtrade/user_data
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - FREQTRADE__FREQAI__MODEL_TRAINING__DEVICE=cuda
    command: >
      trade --strategy FreqAIStrategy --config user_data/config.json

# docker-compose.yml
version: '3.8'

services:
  freqtrade:
    image: freqtradeorg/freqtrade:stable
    container_name: freqtrade_prod
    restart: unless-stopped
    volumes:
      - ./user_data:/freqtrade/user_data
    ports:
      - "127.0.0.1:8080:8080"
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3"
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: '2.0'
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/api/v1/ping"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    command: >
      trade --strategy SampleStrategy --config user_data/config.json

  # Optional: Add Grafana for monitoring
  grafana:
    image: grafana/grafana:latest
    container_name: freqtrade_grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards
    depends_on:
      - freqtrade

volumes:
  grafana_data:

# Custom model example
from freqtrade.freqai.base_models import BaseRegressionModel
from sklearn.ensemble import RandomForestRegressor

class MyCustomModel(BaseRegressionModel):
    def fit(self, data_dictionary: dict, **kwargs):
        model = RandomForestRegressor(n_estimators=200, max_depth=10)
        model.fit(data_dictionary["train_features"], data_dictionary["train_labels"])
        return model