How To Use Freqtrade

May 22, 2026

Freqtrade is an advanced, open-source cryptocurrency trading bot that allows traders to automate their strategies, manage risk, and trade across multiple exchanges with precision. Built in Python, it offers a flexible framework for developing, testing, and executing algorithmic trading strategies. Whether you are new to automated trading or an experienced quant, Freqtrade provides the tools needed to trade in a structured, disciplined way.

Introduction to Freqtrade

At its core, Freqtrade connects to supported cryptocurrency exchanges via API, analyzes market data in real time, and places buy or sell orders based on rules you define in your strategy. It can:

Run on your local machine, a dedicated server, or cloud services.
Operate in dry-run mode for simulation.
Use backtesting to test strategies on historical data.
Optimize parameters automatically with hyperopt.
Support a wide range of indicators and custom trading logic.

Its open-source nature means it’s constantly evolving, and you can customize almost every aspect of its functionality.

Setting Up the Environment

Before you install Freqtrade, ensure you have the following:

Python 3.8+ if installing directly.
Docker if using containerized deployment (recommended for simplicity).
A cryptocurrency exchange account with API trading enabled.
An operating system such as Linux, macOS, or Windows.
Basic familiarity with the terminal and Python programming.

Installing Freqtrade

Using Docker (Recommended)

Docker simplifies installation and avoids dependency conflicts.

Install Docker and Docker Compose.
Create a folder for the bot: mkdir freqtrade && cd freqtrade
Pull the latest stable Freqtrade image: docker pull freqtradeorg/freqtrade:stable
Generate a configuration file: docker run -it --rm -v $(pwd):/freqtrade freqtradeorg/freqtrade:stable new-config

Installing Without Docker

If you prefer direct installation:

Install Python 3.8 or newer.
Clone the Freqtrade repository: git clone https://github.com/freqtrade/freqtrade.git cd freqtrade
Create and activate a virtual environment: python3 -m venv .env source .env/bin/activate
Install dependencies: pip install -r requirements.txt
Initialize configuration: freqtrade new-config

Configuring Freqtrade

Your configuration file (config.json) controls how the bot behaves.

Main parameters include:

Exchange settings: API key, API secret, and exchange name.
Stake settings: Currency (USDT, BTC, etc.) and trade amount.
Timeframe: Chart interval such as 1m, 5m, or 1h.
Max open trades: Limits concurrent exposure.
Risk controls: Stop-loss and take-profit percentages.

Example:

{
    "exchange": {
        "name": "binance",
        "key": "YOUR_API_KEY",
        "secret": "YOUR_API_SECRET"
    },
    "stake_currency": "USDT",
    "stake_amount": 50,
    "timeframe": "5m",
    "max_open_trades": 5,
    "dry_run": true
}

Writing a Strategy

Strategies in Freqtrade are Python classes that define:

Indicators (EMA, RSI, Bollinger Bands, etc.)
Buy conditions
Sell conditions

Example EMA crossover strategy:

from freqtrade.strategy import IStrategy
from pandas import DataFrame
class EmaCrossStrategy(IStrategy):
    timeframe = '5m'
    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe['ema_short'] = dataframe['close'].ewm(span=12).mean()
        dataframe['ema_long'] = dataframe['close'].ewm(span=26).mean()
        return dataframe
    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[(dataframe['ema_short'] > dataframe['ema_long']), 'buy'] = 1
        return dataframe
    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[(dataframe['ema_short'] < dataframe['ema_long']), 'sell'] = 1
        return dataframe

Backtesting Your Strategy

Backtesting evaluates your strategy’s past performance using historical data.

Download data: freqtrade download-data --exchange binance --timeframe 5m --days 30
Run backtest: freqtrade backtesting --strategy EmaCrossStrategy
Review metrics: profit percentage, win rate, drawdown, and trade count.

Paper Trading

Paper trading lets you simulate live trading without risking funds.

Run:

freqtrade trade --strategy EmaCrossStrategy --dry-run

Monitor trades in the terminal or enable the Freqtrade web UI for visual dashboards.

Live Trading

When ready to trade with real capital:

Set "dry_run": false in config.json.
Use API keys with trading permissions.
Start: freqtrade trade --strategy EmaCrossStrategy
Monitor performance and be prepared to stop the bot if needed.

Hyperopt for Optimization

Hyperopt finds optimal parameters for your strategy.

Example:

freqtrade hyperopt --strategy EmaCrossStrategy --timeframe 5m --epochs 100

This tests multiple parameter combinations and outputs the best set.

Risk Management Best Practices

Limit position size per trade.
Use conservative stop-loss settings.
Avoid trading too many pairs at once.
Keep capital allocation balanced.
Regularly monitor bot performance.

Monitoring and Updating

Check logs for warnings or errors.
Update to the latest Freqtrade version for security and performance improvements.
Adjust strategies if market conditions shift.
Use the web UI for easier oversight.

Security Recommendations

Store API keys securely and avoid storing them in public repositories.
Restrict withdrawal rights on exchange API keys.
If using a remote server, secure it with firewalls and SSH authentication.

Conclusion

Freqtrade empowers traders to take a structured, automated approach to cryptocurrency trading. By combining solid strategy design, careful backtesting, safe paper trading, and disciplined live execution, it is possible to create a robust trading system that works consistently. The key to success is continuous monitoring, optimization, and adherence to risk management principles, ensuring your bot can adapt to ever-changing market conditions while protecting your capital.