DEV Community: itrade icu

Episode 11: Futures or Spot? Master Freqtrade's Trading Modes and Leverage Settings in One Go!

itrade icu — Sat, 08 Nov 2025 02:32:18 +0000

Episode 11: ⚔️ Futures or Spot? Master Freqtrade's Trading Modes and Leverage Settings in One Go!

When using Freqtrade, the choice of trading mode directly impacts your strategy logic, risk management, and order execution. You can opt for spot trading or leverage-enabled futures trading. Different modes come with distinct configuration parameters, such as margin_mode, leverage, and liquidation_buffer.

This episode systematically explains the roles, use cases, and practical considerations of these settings to help you build a robust risk control framework.

🚀 Want to Learn Quantitative Trading?

👉 Click to visit: https://www.itrade.icu

Here you'll find Freqtrade beginner tutorials, real-world strategy guides, indicator breakdowns, and more — helping you master quant trading skills with ease!

💱 trading_mode — Trading Mode Setting

"trading_mode": "spot"

Determines whether Freqtrade operates in the spot or futures market.
Available options:
- "spot": Spot mode — only buy low, sell high; no shorting.
- "futures": Futures mode — supports leverage, long/short positions; more flexible but higher risk.

🟢 Spot Mode Features

Only profits from price increases (buy low, sell high) — ideal for bull markets.
Simple logic, no leverage management needed.
Best for beginners or stable strategies.

🔴 Futures Mode Features

Supports long and short positions — suits volatile or bearish markets.
Leverage amplifies both profits and losses.
Requires advanced risk controls like position sizing, liquidation buffers, and isolated margin.

✅ Practical Tip:

Beginners should start with "spot".
Switch to "futures" only after gaining experience and enabling proper risk controls.

🧮 margin_mode — Futures Margin Mode

margin_mode is only effective when trading_mode: "futures" — it is ignored in spot mode. It defines the margin type for each futures trade.

"trading_mode": "futures", // Futures mode
"margin_mode": "isolated"

Available values:

Value	Meaning	Explanation
`"isolated"`	Isolated Margin (Recommended)	Each position bears its own risk — liquidation of one trade won't affect others. Recommended for futures beginners.
`"cross"`	Cross Margin	All positions share account balance — high risk; poor management can lead to full account liquidation.

✅ Recommended Setting:

Use "isolated" — even if one position gets liquidated, it won’t drag down the entire account. Safer and more stable.

💥 leverage — Leverage Multiplier Setting

Freqtrade allows dynamic leverage setting within strategies, and you can customize it per trading pair.

📌 Example in Strategy Code:

def leverage(self, pair: str, current_time: datetime, current_rate: float,
             current_profit: float, current_cost: float, **kwargs) -> float:
    return 3.0  # Set to 3x leverage

⚠️ Key Notes:

Leverage is only available in trading_mode = futures.
Return value must be a float.
If the leverage() method is not implemented, Freqtrade won’t set leverage — it defaults to the exchange’s account setting.
Some exchanges cap max leverage (e.g., Binance: 20–125x).

✅ Practical Advice:

Start with 2–5x leverage.
Leverage magnifies both gains and losses — always pair with stop-loss and buffer mechanisms.

🛡️ liquidation_buffer — Liquidation Buffer

"liquidation_buffer": 0.05

Only applies in futures mode.
Reduces the usable balance to prevent full allocation, avoiding inability to add margin — indirectly lowers liquidation risk.
Set to 5% → reserves 5% of account balance, limiting "available funds" for trading.

📌 Example:

Total Account	`liquidation_buffer`	Max Usable Funds
1000 USDT	0.05 (5%)	950 USDT
1000 USDT	0.2 (20%)	800 USDT

✅ Recommended Values:

Beginners: 0.05 ~ 0.1
High-leverage strategies: 0.2 or higher

✅ Recommended Configuration Combo

"trading_mode": "futures",
"margin_mode": "isolated",
"liquidation_buffer": 0.05

📌 Add to strategy:

def leverage(self, pair, current_time, current_rate, current_profit, current_cost, **kwargs):
    return 3.0  # Set 3x leverage

📊 Mode Comparison Summary

Setting	Spot Mode	Futures Mode
Short Selling	❌ Not supported	✅ Supported
Leverage	❌ Not supported	✅ Supported
Risk Management Needs	Low	High (stop-loss, position control, etc.)
Recommended Margin Mode	-	`"isolated"`
Leverage Logic Required?	❌ No	✅ Recommended (dynamic)
`liquidation_buffer` Supported?	❌ Ignored	✅ Strongly recommended

🔐 Live Trading Risk Control Tips

Control Item	Recommended Practice
`margin_mode`	Set to `"isolated"` to prevent cascade liquidations
`leverage`	Start with 2–3x, validate via backtest/live comparison before increasing
`liquidation_buffer`	Set 0.05–0.2 to avoid full exposure
Stop-Loss	Use `stoploss` or `custom_stoploss` for forced exits
Position Limit	Combine with `max_open_trades` to cap open positions

🧠 Summary Checklist

Parameter	Description	Recommended Value
`trading_mode`	Sets trading mode (spot/futures)	`"spot"` or `"futures"`
`margin_mode`	Sets margin type (futures only)	`"isolated"`
`liquidation_buffer`	Reserves % of balance in futures	`0.05 ~ 0.2`
`leverage()`	Strategy function to set leverage	`2.0 ~ 5.0`

Episode 10: 💥 Stop Going All-In and Getting Liquidated! Master Freqtrade's Capital Allocation to Survive Longer

itrade icu — Sat, 08 Nov 2025 02:27:42 +0000

Episode 10: 💥 Stop Going All-In and Getting Liquidated! Master Freqtrade's Capital Allocation to Survive Longer

In Freqtrade, capital allocation is the foundation of all strategy operations. Whether in spot or futures trading, parameters like stake_currency, stake_amount, and tradable_balance_ratio determine the currency used per trade, the amount of funds allocated, and how account risk is controlled.

Proper configuration ensures stable and safe strategy execution; poor setup can lead to order failures or liquidation, impacting live trading.

🚀 Want to Learn Quantitative Trading?

👉 Click to visit: https://www.itrade.icu

Here you'll find Freqtrade beginner tutorials, real-world strategy guides, indicator breakdowns, and more — helping you master quant trading skills with ease!

🪙 stake_currency — The Trading Currency Used

"stake_currency": "USDT"

Specifies the base currency used for buying in each trade.
Common options: "USDT", "BTC", "ETH", etc.
In spot trading, this determines the asset type you need in your account.
In futures mode, it sets the denomination for contract margin. ✅ Practical Tip:
Most strategies use "USDT" as stake_currency — it's more universal and stable.
If you only hold BTC and want to trade other pairs directly with it, switch to "BTC".

💵 stake_amount — Investment Amount Per Trade

Can be set as:

1️⃣ Fixed Value (Recommended for Beginners)

"stake_amount": 100

Each trade uses up to 100 USDT; actual order size may vary slightly due to price/position adjustments.
Easier risk control with higher consistency between backtests and live trading.

2️⃣ Dynamic Value "unlimited"

"stake_amount": "unlimited"

The system automatically uses available account balance (limited by tradable_balance_ratio below).
More flexible, ideal for larger capital or complex strategy scheduling. ⚠️ Note:
In futures accounts, ensure proper leverage is set on the exchange — Freqtrade's stake_amount does not auto-manage leverage.
When using multi-pair or multi-position strategies, pay close attention to position management to avoid depleting the entire balance.

🧮 tradable_balance_ratio — Balance Usage Ratio Limit

"tradable_balance_ratio": 0.95

Only effective when stake_amount: "unlimited".
Caps usage at 95% of account balance for opening positions, reserving 5% as a buffer.
Prevents "running out of funds," avoiding failed subsequent orders.
📌 Example:
- Account balance: 1000 USDT, ratio = 0.95 → strategy uses at most 950 USDT for positions.
✅ Recommended Values:
- Generally 0.90 ~ 0.98;
- The more conservative, the better protection against liquidation or insufficient margin.

🛡️ Live Trading Risk Control Recommendations

Control Point	Suggested Config	Reason
Initial Testing	`"stake_amount": 50~100`	Fixed amounts are more stable for observing strategy performance
Batch Trading	Pair with `"max_open_trades"` limit	Prevents too many simultaneous positions, avoiding fund dispersion and risk runaway
Account Safety	Set `tradable_balance_ratio < 1.0`	Reserves buffer for fees or emergencies
Leverage Mode	Dynamically control position size or enable `liquidation_buffer`	Avoids full-margin leverage liquidation and liquidity crashes

✅ Example Configuration Combo

"stake_currency": "USDT",
"stake_amount": "unlimited",
"tradable_balance_ratio": 0.9,

This means:

Trade using USDT;
No fixed per-trade amount, but never exceed 90% of total balance;
Skip trades under 10 USDT;
Best for intermediate/advanced users with integrated risk controls.

✅ Summary Checklist

Parameter	Description	Recommended Value / Tip
`stake_currency`	Currency used for trading (buying)	`"USDT"` most common
`stake_amount`	Per-trade amount: fixed or `"unlimited"`	Beginners: fixed; Experts: dynamic
`tradable_balance_ratio`	Caps max account usage to avoid full balance or margin exhaustion	`0.9 ~ 0.98`

Treat these settings as your baseline capital safety net before going live. No matter how good the strategy, always defend the "bottom line" of fund control.

Episode 10: 💥 Stop Going All-In and Getting Liquidated! Master Freqtrade's Capital Allocation to Survive Longer

itrade icu — Fri, 31 Oct 2025 10:59:02 +0000

Episode 10: 💥 Stop Going All-In and Getting Liquidated! Master Freqtrade's Capital Allocation to Survive Longer

Proper configuration ensures stable and safe strategy execution; poor setup can lead to order failures or liquidation, impacting live trading.

🚀 Want to Learn Quantitative Trading?

👉 Click to visit: https://www.itrade.icu
Here you'll find Freqtrade beginner tutorials, strategy combat, indicator analysis, and more rich content to help you easily master quantitative trading skills!

🪙 stake_currency — The Trading Currency Used

"stake_currency": "USDT"

Specifies the base currency used for buying in each trade.
Common options: "USDT", "BTC", "ETH", etc.
In spot trading, this determines the asset type you need to prepare in your account.
In futures mode, it also determines the pricing unit for contract margins. ✅ Practical Advice:
Most strategies use "USDT" as stake_currency—it's more universal and stable.
If you only hold BTC and want to trade other coins directly with BTC, switch to "BTC".

💵 stake_amount — Investment Amount per Trade

Can be set as:

1️⃣ Fixed Value (Recommended for Beginners)

"stake_amount": 100

Each trade uses up to 100 USDT; actual order amounts may vary slightly due to price/position adjustments.
Easier risk control with higher consistency between backtesting and live results.

2️⃣ Dynamic Value "unlimited"

"stake_amount": "unlimited"

The system automatically uses available account balance (limited by tradable_balance_ratio below).
More flexible, suitable for larger funds or complex strategy scheduling. ⚠️ Note:
For futures accounts, ensure reasonable leverage is set on the exchange—Freqtrade's stake_amount does not automatically control leverage.
When using multi-pair or multi-position strategies, pay special attention to position management to avoid depleting account balance.

🧮 tradable_balance_ratio — Balance Usage Ratio Limit

"tradable_balance_ratio": 0.95

Only effective when stake_amount: "unlimited".
Means at most 95% of account balance is used for opening positions, reserving 5% as buffer.
Primary role: Prevent "using up balance" to avoid subsequent signal order failures.
📌 Example:
- Account balance 1000 USDT, ratio = 0.95 → Strategy uses at most 950 USDT for positions.
✅ Recommended Values:
- Generally set to 0.90 ~ 0.98;
- The more conservative, the better it prevents liquidation or insufficient margin.

🛡️ Live Trading Risk Control Recommendations

Control Point	Suggested Configuration	Reason
Initial Testing	`"stake_amount": 50~100`	Fixed amounts are more stable, easier to observe strategy performance
Batch Trading	Pair with `"max_open_trades"` to limit positions	Prevent too many simultaneous positions, fund dispersion, and risk out of control
Account Safety	Set `tradable_balance_ratio < 1.0`	Reserve buffer balance to prevent liquidation or insufficient fees
Leverage Mode	Dynamically control positions or enable `liquidation_buffer`	Prevent full-margin leverage liquidation and liquidity crashes

✅ Example Configuration Combination

"stake_currency": "USDT",
"stake_amount": "unlimited",
"tradable_balance_ratio": 0.9,

This configuration means:

Trade using USDT;
No fixed amount per order, but not exceeding 90% of total balance;
Skip orders below 10 USDT;
More suitable for intermediate/advanced users with flexible risk control strategies.

✅ Summary Checklist

Parameter Name	Description	Recommended Value / Advice
`stake_currency`	Currency used for trading (buying)	`"USDT"` most common
`stake_amount`	Amount per trade: fixed or `"unlimited"`	Beginners use fixed value; experts use dynamic
`tradable_balance_ratio`	Limits max account usage ratio to avoid full positions or depleting margin	`0.9 ~ 0.98`

Use these configurations as your basic capital safety line before going live. No matter how good the strategy, always guard the "bottom line" of capital control.

Article 9: Freqtrade Quantitative Trading - config.json Basics and Initialization

itrade icu — Wed, 29 Oct 2025 12:59:39 +0000

Article 9: Freqtrade Quantitative Trading - config.json Basics and Initialization

📁 Complete Breakdown of Freqtrade's Most Critical File: config.json (With Practical Tips)
Before using Freqtrade for strategy backtesting, data downloading, or live trading, the most essential preparation is creating and configuring the config.json file. It serves as the "command center" of the entire trading framework, determining which exchange to connect to, how to trade, how strategies run, how much trading capital to use, and how to allocate balances.

This article will systematically guide you through the role of config.json, how to generate it, its file structure, and editing tips to help you get started quickly and avoid common pitfalls.

🚀 Want to Learn Quantitative Trading?

👉 Click to visit: https://www.itrade.icu

Here you'll find Freqtrade beginner tutorials, real-world strategy examples, indicator breakdowns, and more to help you master quantitative trading techniques with ease!

🧱 What is config.json?

config.json is Freqtrade's main configuration file, used to centrally manage all runtime parameters of the project. It is a standard JSON-formatted text file containing the following information:

Exchange account details (API Key/Secret)
Trading pairs and amount settings
Strategy execution rules (e.g., maximum open positions, shorting allowed, etc.)
Data timeframes and backtesting settings
Limit/market order control logic
Risk management configurations (stop-loss, take-profit, slippage control, etc.)
Webhook/Telegram notification channels (optional) Whether you're doing data analysis, backtest optimization, or live deployment, this configuration file is an indispensable foundation. --- ## 🆕 How to Generate config.json? Freqtrade provides a command-line tool to generate a default configuration template with one click—perfect for beginners to get started quickly.

freqtrade new-config --config user_data/config.json

Specify your target path after --config (recommended: user_data/config.json)
The directory will be created automatically if it doesn't exist
After generation, edit the file using any text editor ## 📂 Recommended File Structure The recommended basic directory structure for a Freqtrade project is as follows:

freqtrade/
├── user_data/
│ ├── config.json ← ✅ Main configuration file
│ ├── strategies/ ← Strategy folder (.py files)
│ ├── logs/ ← Log output
│ ├── ...
├── freqtrade/ ← Project source code (or virtual environment)

Placing config.json in the user_data/ folder is the officially recommended practice, which helps maintain path consistency and ease of backup management.

🐳 Directory Structure When Running with Docker

If you're using the officially recommended Docker method to run Freqtrade (highly recommended!), the directory structure is controlled by Docker volume mappings and differs slightly from local execution.

ft_userdata/
├── user_data/
│ ├── config.json ← ✅ Main configuration file (for modifying runtime parameters)
│ ├── strategies/ ← Strategy folder (.py files)
│ ├── hyperopt/ ← Parameter optimization results
│ ├── logs/ ← Log output
│ ├── ...
├── docker-compose.yml ← Service startup entry configuration

🔍 Beginner Preview Example

Below is a preview of the most basic version of a config.json file (showing only the initial part):

{
  "max_open_trades": 3,
  "stake_currency": "USDT",
  "stake_amount": 100,
  "tradable_balance_ratio": 0.95,
  "dry_run": true,
  "exchange": {
    "name": "binance",
    "key": "your_api_key",
    "secret": "your_api_secret",
    "password": "your_api_password" // Required only for certain exchanges like OKX or Kraken
  }
}

Field explanations:

max_open_trades: Maximum number of positions allowed open simultaneously (to prevent overexposure)
stake_currency: Base currency for trading funds, usually USDT
stake_amount: Amount of funds used per trade
dry_run: Whether to enable dry-run mode (true means no real money is used) ## 🛠️ Debugging Tips When Modifying Configuration
✅ After modification, use the following command to check if the EXCHANGE API key is valid:

freqtrade list-markets --config user_data/config.json

API Key Configured?	Can list-markets run?	Can trade?	Notes
✅ Yes	✅ Yes	✅ Yes	Suitable for live trading with full features
❌ No	✅ Depends on exchange	❌ No	Only some exchanges allow anonymous market listing

✅ You can also run a strategy initialization before backtesting to check for errors:

freqtrade backtesting --config user_data/config.json

🧠 Summary

Key Point	Recommendation
Configuration file name	Fixed as `config.json`, recommended in `user_data/`
Generation command	`freqtrade new-config --config <path>`
Error troubleshooting	Use `backtesting` or `list-markets` to verify
Version control	✅ Strongly recommended to include config.json in Git

Article 8: Quantitative Trading - Differences Between tradeUI and webserverUI

itrade icu — Mon, 27 Oct 2025 01:08:35 +0000

🔍 Article 8: Quantitative Trading - Differences Between `tradeUI` and `webserverUI`

Although both are often used together, their roles and startup logic are completely different. Below is a detailed comparison 👇

🚀 Want to learn quantitative trading?

👉 Click to visit: https://itrade.icu
Here you'll find a wealth of content, including Freqtrade Basic Tutorial, Strategy Source Code, Indicator Analysis, and more, to help you easily master quantitative trading techniques!

Item	`freqtrade trade`	`freqtrade webserver`
✅ Startup Content	Starts the trading bot (live or dry-run)	Starts the visualization UI service (for viewing data)
⚙️ Core Function	Executes strategies, places orders, monitors markets	Graphically displays strategy performance/backtest results
🧠 Runs Strategy Logic?	✅ Yes (runs strategy in real-time)	❌ No (only reads and displays data)
📦 Data Source	Real-time market data, order execution	Local SQLite database (or strategy output)
⏱ Use Case	Live trading (simulated or real)	View strategy performance/order info in browser
🔗 Connects to Exchange?	✅ Yes	❌ No
📈 View Backtest Results?	❌ No	✅ Supports backtest visualization
🚀 Browser Access Address	Optional UI, runs in background	http://127.0.0.1:8080 (default)

✅ Use Case Distinction

1. `trade` Runs the Bot

You can choose live trading or dry-run (simulated trading):

freqtrade trade \
  --config user_data/config.json \
  --strategy MyStrategy \
  --dry-run

Continuously fetches real-time market data
Executes strategy logic (e.g., buy/sell signals)
Connects to the exchange, records orders, funds, and profits
Writes all data to a local database (SQLite)

💡 Without this, the bot won't do anything!

2. `webserver` Provides a Graphical Interface

It only reads data and provides a browser-based interface:

freqtrade webserver \
  --config user_data/config.json \
  --username admin --password 123456

Displays current holdings, trade history, and strategy name
Allows viewing of live strategy performance
Can also display backtest result charts (e.g., after running backtesting)

❗ Does not run strategies or connect to exchanges!

🔄 Relationship Summary

trade is the "bot engine"
webserver is the "graphical interface"

You can think of it like this:

trade is the executor that does the actual work
webserver is the observation window

If you only run webserver without running trade, you’ll only see previously recorded data, and no new trades will be generated.

🧩 Practical Advice (Docker Environment)

services:
  trader:
    image: freqtradeorg/freqtrade:stable
    command: >
      trade
      --config /quants/freqtrade/user_data/config.json
      --strategy MyStrategy

  ui:
    image: freqtradeorg/freqtrade:stable
    command: >
      webserver
      --config /quants/freqtrade/user_data/config.json
      --username admin
      --password 123456
    ports:
      - "8080:8080"

Then, open your browser and visit: http://localhost:8080 to access your trading bot's dashboard.

Chapter 7: How to Set Up the Freqtrade Web UI? Installation and Usage Guide

itrade icu — Sun, 26 Oct 2025 00:26:18 +0000

📘 Chapter 7: How to Set Up the Freqtrade Web UI? Installation and Usage Guide

When running Freqtrade for live trading or backtesting, you might want to monitor the strategy's performance, open positions, and profits in real-time. This is where the Web UI (FreqUI) comes in handy.

This article explains how to install and run the Web UI using both command-line and Docker methods, along with common use cases.

🚀 Want to Learn Quantitative Trading?

👉 Visit: https://www.itrade.icu
Find Freqtrade beginner tutorials, strategy guides, indicator analysis, and more to help you master quantitative trading with ease!

🧩 1. Install Web UI Dependencies

Before using the Web UI for the first time, you need to install the required dependencies with the following command:

freqtrade install-ui

This command automatically installs the necessary modules for running the Web interface.

🚀 2. Start the Webserver Service

The webserver is the backend entry point for the UI, listening on a port (default: 8080).

freqtrade webserver \
  --config user_data/config.json

By default, you can access the Web UI via a browser at:

http://localhost:8080

⚙️ 3. Common Parameters Explained

Parameter	Description
`--config`	Specify the configuration file path
`--port`	Specify the listening port (default: 8080)
`--username` / `--password`	Set login username and password
`--api-server`	Enable REST API service
`--webserver`	Enable UI Web service (enabled by default)

🧱 Example: Start with a custom port and login credentials

freqtrade webserver \
  --config user_data/config.json \
  --port 8888 \
  --username admin \
  --password 123456

🐳 4. Docker Setup for Web UI

If you're using Docker, you can configure it with the following docker-compose.yml file:

⚠️ Note: When using Docker, ensure the api_server.listen_port in config.json matches the ports setting in docker-compose.yml, otherwise, the UI won't be accessible.

    "api_server": {
        "enabled": true,
        "listen_ip_address": "127.0.0.1",
        "listen_port": 7777,
        "verbosity": "error",
        "enable_openapi": false,
        "jwt_secret_key": "",
        "ws_token": "",
        "CORS_origins": [],
        "username": "1",
        "password": "1"
    },

services:
  freqtrade:
    image: freqtradeorg/freqtrade:stable
    volumes:
      - ./user_data:/quants/freqtrade/user_data
    ports:
      - "8888:7777" # Access externally via http://localhost:8888
    command: >
      webserver
      --config /quants/freqtrade/user_data/config.json
      --username admin
      --password 123456

Start the service:

docker compose up -d

📊 6. Web UI Modules Explained

Freqtrade provides two Web UI interfaces for different scenarios:

✅ 1. Live Trading Web UI (enabled with `freqtrade trade`)

Used for real-time monitoring of trading bot performance:

View current strategy, open positions, and profit/loss
Manage open orders, close positions, or create manual trades (requires API enabled)
Browse historical trade records and profit/loss charts

Start command:

freqtrade trade --config user_data/config.json

🧪 2. Backtesting Web UI

Used for visualizing backtesting results:

Graphical display of profit/loss curves, indicator lines, and buy/sell points
Overview of strategy performance and trade statistics
Requires running freqtrade backtesting to generate results first

Start command:

freqtrade webserver --config user_data/config.json

🔧 7. Notes and Common Issues

Issue	Solution
Unable to access UI	Ensure the correct webserver mode is running and the port is open
Blank page / style issues	Run `freqtrade install-ui` to install frontend dependencies
Docker UI inaccessible	Check `docker-compose.yml` for `ports: 8888:8080` mapping
UI doesn't recognize strategy	Ensure the strategy file name is correct and matches the `"strategy"` field in `config.json`
Backtesting UI shows no data	Ensure `freqtrade backtesting` has been run to generate results before starting `webserver`

📌 Summary

The Freqtrade Web UI is a lightweight and practical visualization tool that can be used to:

Monitor trading status in real-time
View backtesting or live trading performance
Manually intervene in trading actions

If you're familiar with the CLI but want a more intuitive way to manage strategies and assets, the Web UI is highly recommended!

Article 6: Freqtrade - "Visualize Your Data with Charts! Plot-Dataframe Visualization Tutorial"

itrade icu — Fri, 24 Oct 2025 06:49:40 +0000

📘 Article 6: Freqtrade - "Visualize Your Data with Charts! Plot-Dataframe Visualization Tutorial"

During strategy development, backtest results are often presented in tabular form, making it hard to quickly identify issues. The plot-dataframe command visualizes buy/sell points, indicator lines, and price trends as charts, helping you instantly understand strategy performance.

🚀 Want to Learn Quantitative Trading?

👉 Visit: https://www.itrade.icu
Find Freqtrade Basics, Strategy Practices, Indicator Analysis, and more to help you master quantitative trading skills effortlessly!

🎯 1. Basic Usage: Generating Charts

freqtrade plot-dataframe \
  --config user_data/config.json \
  --strategy MyStrategy \
  --timerange 20230101-20230201

This command generates an .html file in the user_data/plot/ directory, which you can open in a browser to view:

Candlestick price trends
Buy/Sell points (marked with arrows)
Technical indicators (e.g., EMA, MACD)

🧾 2. Parameter Breakdown

Parameter	Description
`--config`	Path to the configuration file (includes trading pairs, timeframes, etc.)
`--strategy`	Strategy class name (e.g., `MyStrategy`)
`--timerange`	Time range for the chart (e.g., `20230101-20230201`)
`--indicators1`	Indicators for the main chart (e.g., EMA, close)
`--indicators2`	Indicators for the subplot (e.g., RSI, MACD)
`--exportfilename`	Output file path (supports `.html` or `.png`)
`--userdir`	Custom `user_data` directory (default is fine)

📐 3. Adding Custom Indicators

You can include additional indicators in the chart to validate signal logic:

Code Example:

def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
    dataframe['ema'] = ta.EMA(dataframe['close'], timeperiod=20)
    dataframe['fast_ema'] = ta.EMA(dataframe['close'], timeperiod=10)
    dataframe['slow_ema'] = ta.EMA(dataframe['close'], timeperiod=50)
    dataframe['rsi'] = ta.RSI(dataframe['close'], timeperiod=14)
    macd, macdsignal, macdhist = ta.MACD(dataframe['close'])
    dataframe['macd'] = macd
    return dataframe

--indicators1 plots on the main chart (price chart), e.g., EMA lines.
--indicators2 plots on the subplot, e.g., RSI, MACD.

Complete Example:

freqtrade plot-dataframe \
  --config user_data/config.json \
  --strategy MyStrategy \
  --timerange 20230101-20230201 \
  --indicators1 close ema fast_ema slow_ema \
  --indicators2 rsi macd

❗ Note:

Indicator names must match the column names in the DataFrame created in the populate_indicators() method of your strategy.
Mismatched names won’t cause errors, but the indicators won’t appear on the chart.
Indicators must be defined in populate_indicators() to take effect.

💾 4. Exporting to HTML / PNG

By default, the output is an HTML file. To specify:

--exportfilename user_data/plot/myplot.html

To export as PNG (static image):

--exportfilename user_data/plot/myplot.png

📌 Note: Exporting to PNG requires additional tools like Puppeteer or headless Chrome. Beginners should stick to HTML format.

🐳 5. Running in a Docker Environment

To use the command in Docker:

docker compose run --rm freqtrade plot-dataframe \
  --config /quants/freqtrade/user_data/config.json \
  --strategy MyStrategy \
  --timerange 20230101-20230201

Ensure the /quants/freqtrade/user_data directory is correctly mounted in docker-compose.yml.

✅ 6. Usage Tips

Purpose	Method
Verify strategy logic	Check if buy/sell points are correctly positioned
Debugging	Compare indicators with signal logic
Strategy sharing	Export charts as HTML for easy presentation
Evaluate indicator performance	Plot multiple indicators to check for redundancy

📌 Summary

plot-dataframe is a powerful visualization tool in Freqtrade, ideal for debugging complex strategies and validating buy/sell logic.

Recommended Workflow:

Run Backtest:

freqtrade backtesting \
  --config user_data/config.json \
  --strategy MyStrategy \
  --timeframe 15m \
  --timerange 20220101-20230101

Generate Chart:

freqtrade plot-dataframe \
  --config user_data/config.json \
  --strategy MyStrategy \
  --timerange 20250601-20250626

Analyze Chart:
Are buy signals triggered too early or too late?
Are there frequent false signals?
Are the indicators effective?

Master plot-dataframe to optimize strategies efficiently with data-driven insights!

Chapter 5: How to Optimize Strategy Parameters? Freqtrade Hyperopt Quick Start

itrade icu — Fri, 24 Oct 2025 01:55:19 +0000

📘 Chapter 5: How to Optimize Strategy Parameters? Freqtrade Hyperopt Quick Start

In strategy development, besides building the buy and sell logic, parameter settings often determine the final return-to-risk ratio.

Freqtrade provides a powerful hyperopt feature for automatically searching for the optimal parameter combinations, greatly accelerating the strategy iteration speed.

🧠 1. What is Hyperopt? What is it suitable for?

Hyperopt is an automatic parameter optimization tool that can:

Help you find the best threshold for RSI?
Test which stop-profit/stop-loss level is optimal?
Automatically run multiple parameter combinations → Compare results → Find the best configuration

✅ Suitable for the following scenarios:

Strategies with multiple numerical parameters (e.g., RSI, MACD, Bollinger Band width, stop-loss ratio)
Want to find the best combination in a specific historical period
Don't want to manually tune parameters

🚀 Want to learn quantitative trading?

👉 Click to visit: https://www.itrade.icu

Here you can find Freqtrade basics tutorials, strategy practice, indicator analysis, and other rich content to help you master quantitative trading skills effortlessly!

🚀 2. Basic Commands and Parameter Explanation

freqtrade hyperopt \
  --config user_data/config.json \
  --strategy MyStrategy \
  --hyperopt-loss SharpeHyperOptLoss \
  --timerange 20230101-20230701 \
  --epochs 100

Parameter	Meaning
`--config`	Config file path
`--strategy`	Strategy class name to optimize
`--hyperopt-loss`	Optimization objective function (see below)
`--timerange`	Backtest time range
`--epochs`	Number of iterations, more = more precise but more time-consuming
`--spaces`	Which parameter spaces to optimize (default: buy, sell)

🎯 3. Common Optimization Objectives (Hyperopt Loss Functions)

Different objective functions represent different optimization directions. Common ones include:

Function Name	Meaning	Suitable Scenarios
`SharpeHyperOptLoss`	Optimize Sharpe Ratio	Balance of return and volatility
`SortinoHyperOptLoss`	Optimize Sortino Ratio	Focus on downside risk
`ProfitHyperOptLoss`	Maximize total profit	Aggressive return-driven strategies
`CalmarHyperOptLoss`	Return / Max Drawdown ratio	Risk control preference
`TrailingBuyHyperOptLoss`	Specifically for trailing buy strategies

🧩 4. How to Define Hyperparameters?

Use the @parameter decorator in the strategy class, for example:

from freqtrade.strategy import IStrategy, IntParameter, DecimalParameter

class MyStrategy(IStrategy):
    rsi_period = IntParameter(10, 30, default=14, space="buy")
    stoploss_value = DecimalParameter(-0.10, -0.01, default=-0.05, space="sell")

Freqtrade will automatically search for the best combination within the specified range.

⚠️ 5. Common Hyperopt Pitfalls (Must Avoid)

❗ Overfitting Historical Data

Backtest period too short or single sample may lead to strategies that only perform well in specific market conditions but poorly in live trading.

Suggestions:

Use longer time periods, such as more than 6 months
Run Hyperopt multiple times → Check if parameters converge
Reserve some data for forward testing

❗ Objective Function Bias

Choosing unreasonable optimization objectives (e.g., only optimizing profit) while ignoring risk can lead to extreme strategies.

Suggestions:

Generally use Sharpe or Sortino as the first choice
If risk tolerance is low, recommend CalmarHyperOptLoss

❗ Search Space Too Large / Parameter Conflicts

Too many parameter combinations will greatly extend search time and may even cause conflicts.

Suggestions:

Keep the number of parameters between 3-6
Use effective ranges as much as possible, e.g., RSI doesn't need to search from 1-100

🛠️ 6. Running Example (Including Docker)

Strategy file:

from freqtrade.strategy.interface import IStrategy
from pandas import DataFrame
from freqtrade.strategy import IntParameter, DecimalParameter
import talib.abstract as ta

class MySimpleStrategy(IStrategy):
    # Backtest default timeframe
    timeframe = '15m'

    # Parameter spaces allowed (for hyperopt optimization)
    rsi_buy = IntParameter(10, 50, default=30, space="buy")
    stoploss_value = DecimalParameter(-0.1, -0.01, default=-0.05, space="sell")

    # Default stoploss (for dry-run or live trading)
    stoploss = -0.05

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # Add RSI indicator
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
        return dataframe

    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # Buy when RSI is below specified threshold
        dataframe.loc[
            (dataframe['rsi'] < self.rsi_buy.value),
            'buy'
        ] = 1
        return dataframe

    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # No explicit sell signal (exit via take-profit/stop-loss)
        dataframe['sell'] = 0
        return dataframe

Local run:

freqtrade hyperopt \
  --config user_data/config.json \
  --strategy MySimpleStrategy \
  --hyperopt-loss SharpeHyperOptLoss \
  --timerange 20230101-20230630 \
  --epochs 100

Docker run:

docker compose run --rm freqtrade hyperopt \
  --config /quants/freqtrade/user_data/config.json \
  --strategy MyStrategy \
  --hyperopt-loss SharpeHyperOptLoss \
  --timerange 20230101-20230630

🎯 Current Strategy Tunable Parameters

Parameter Name	Type	Description
`rsi_buy`	`IntParameter(10, 50)`	Adjust RSI buy threshold
`stoploss_value`	`DecimalParameter(-0.1, -0.01)`	Control stop-loss ratio

📌 Tips

To optimize a parameter, must use .value to get the actual value
space="buy", space="sell" controls the parameter range for hyperopt
default=... is your manually set default value
Before optimization, it's recommended to run backtesting first to confirm the strategy logic is working properly

📊 7. Hyperopt Supported Evaluation Metrics

You can view all available Loss functions in freqtrade/optimize/losses.py. Common metrics include:

Metric Name	Description
`Sharpe Ratio`	Annualized return / Annualized volatility
`Sortino Ratio`	Annualized return / Annualized downside volatility
`Calmar Ratio`	Annualized return / Maximum drawdown
`Total Profit`	Total profit
`Drawdown`	Maximum drawdown
`Avg Trade Duration`	Average trade duration

You can also customize evaluation functions to extend optimization objectives that best suit your needs.

✅ 8. Recommended Practice Workflow

1. Use new-strategy to write strategy and define parameters
2. Run backtesting to initially verify strategy rationality
3. Use hyperopt for automatic parameter tuning
4. Replace optimal parameters into the strategy
5. Run backtest again for verification
6. Visualize analysis results → Decide whether to go live

📌 Summary

Freqtrade's Hyperopt system provides strong support for strategy parameter tuning, but the premise is that you can reasonably set the parameter space, objective function, and data period.

The most important thing is not finding the "highest profit" parameters, but finding configurations that are stable, risk-resistant, and have strong generalization ability!

Chapter 4: "How to Test Strategies Reliably? Freqtrade Backtesting Command Full Guide"

itrade icu — Wed, 22 Oct 2025 11:46:54 +0000

📘 Chapter 4: "How to Test Strategies Reliably? Freqtrade Backtesting Command Full Guide"

Backtesting is one of the most critical steps in strategy development.

By simulating strategies on historical market data, you can effectively evaluate their performance and determine if they are worth deploying to live trading.

This article provides a detailed guide to Freqtrade's backtesting command, including usage, common parameters, data handling, result analysis, multi-process acceleration, Docker usage, and more.

🚀 Want to Learn Quantitative Trading?

👉 Click to visit: https://www.itrade.icu
Here you'll find Freqtrade beginner tutorials, strategy case studies, indicator analysis, and more to help you master quantitative trading skills effortlessly!

🔁 1. What is Backtesting? Why is it Important?

Backtesting is the process of running your strategy through historical data to simulate "hypothetical trades", with the goal of understanding how it would have performed in past market conditions.

A quality backtest can answer these key questions:

Is the profit-loss ratio reasonable?
Is the win rate sufficiently stable?
Is there overfitting? (May fail in the future)
Which parameters have the most significant impact on returns?

🚀 2. Basic Backtesting Command Structure

freqtrade backtesting \
  --config user_data/config.json \
  --strategy MyStrategy \
  --timeframe 15m \
  --timerange 20220101-20230701

Parameter Breakdown:

Parameter	Description
`--config`	Specify config file path (contains pairs, timeframes, etc.)
`--strategy`	Strategy class name to use
`--timeframe`	Timeframe (e.g., 15m, 1h)
`--timerange`	Backtest period (format: YYYYMMDD-YYYYMMDD)

Optional Parameters:
| Parameter | Description |
|-------------------|--------------------------|
| --export | Export detailed trades to CSV |
| --stats-file | Output results stats to JSON file |
| --processes | Launch multiple processes for parallel backtesting (improves performance) |

💡 3. Pre-Backtesting Checklist

Backtesting isn't just about running a command. Ensure these items are ready:

✅ Historical data for the corresponding timeframe has been downloaded:

freqtrade download-data --timeframes 15m --timerange 20220101-20230701

✅ Strategy file is placed in user_data/strategies/ directory with correct class name.
✅ config.json settings are correct, including:
- Correct trading pairs
- Correct exchange settings
- stake_currency set to USDT, BTC, etc.

🧪 4. Backtesting Results Output Explanation

After backtesting completes, Freqtrade outputs logs containing the following information:

Metric	Description
`Total profit`	Strategy's final total return (net value)
`Total trades`	Total number of trades during backtest
`Win / loss ratio`	Win rate (profitable/loss trades ratio)
`Sharpe Ratio`	Risk-adjusted return
`Avg trade duration`	Average holding time
`Drawdown`	Maximum drawdown
`Profit factor`	Profit factor (profits/losses)

🖼️ 5. Graphical Backtest Display (backtesting-show)

Freqtrade provides a visualization tool backtesting-show to view entry/exit points and strategy behavior:

freqtrade backtesting-show \
  --config user_data/config.json

📍 Displays profit curves, trade markers, position information, etc.

🧩 6. Common Backtesting Issues and Solutions

Issue	Possible Causes
No trades in backtest	Strategy signal conditions too strict, or missing data
Data not available	Data not downloaded or timerange not covered
Indicators is NaN	Indicator parameters incorrect / incompatible with timeframe
Suspected overfitting	Extremely high backtest returns but live losses; use forward testing to verify

🧠 7. Multi-Process Backtesting Acceleration (--processes)

For multiple pairs or complex strategies, use the --processes parameter to improve backtesting efficiency:

freqtrade backtesting \
  --config user_data/config.json \
  --strategy MyStrategy \
  --processes 4

🧪 Generally set to half to all of your CPU cores. For an 8-core CPU, 4-8 processes work well.

🐳 8. Backtesting Commands in Docker Environment

If running Freqtrade in Docker:

docker compose run --rm freqtrade backtesting \
  --config /quants/freqtrade/user_data/config.json \
  --strategy MyStrategy \
  --timeframe 15m \
  --timerange 20220101-20230701

Ensure user_data/ is mounted to /quants/freqtrade/user_data/ inside the container.

📊 9. Exporting Backtest Results

To save detailed trade information, add:

--export user_data/backtest_result.csv

To export strategy performance results as JSON:

--stats-file user_data/backtest_stats.json

✅ 10. Recommended Analysis Dimensions

After backtesting, focus on these key metrics:

Cumulative return (Total profit): Core indicator
Maximum drawdown (Drawdown): Risk exposure
Win rate / Profit-loss ratio: Stability assessment
Average profit per trade: Value per trade
Profit factor: Whether trading is worthwhile

Also use charting tools for analysis:

freqtrade plot-dataframe --config user_data/config.json --strategy MyStrategy --timerange 20220101-20230101

📌 Summary

Freqtrade's backtesting system is powerful and flexible, perfect for building a complete strategy research and validation workflow.

Step	Tool
Download historical data	`download-data`
Write strategy class	`new-strategy`
Run backtest	`backtesting`
Graphical display	`backtesting-show` / `plot-dataframe`
Performance acceleration	`--processes` multi-process support
Containerized usage	Docker commands

Article 3: 🛠️ Starting from Scratch! A Detailed Guide to the Freqtrade `download-data` Command and Docker Usage

itrade icu — Tue, 21 Oct 2025 08:04:00 +0000

Article 3: 🛠️ Starting from Scratch! A Detailed Guide to the Freqtrade `download-data` Command and Docker Usage

In Freqtrade, K-line data is the foundation for backtesting, optimization, and trading.

Whether you're a strategy developer or a researcher, mastering the download-data command is the first step toward quantitative trading.

This article explains how to use the freqtrade download-data command to download historical market data, covering common parameters, Docker usage, download recommendations, and supported exchanges.

🚀 Want to Learn Quantitative Trading?

👉 Visit: https://www.itrade.icu

Find Freqtrade tutorials, strategy guides, indicator analysis, and more to help you master quantitative trading with ease!

📥 1. Basic Command Format

Download data for a specific trading pair:

freqtrade download-data \
  --exchange binance \
  --pairs BTC/USDT \
  --timeframes 1h \
  --timerange 20230101-20230701

Download using a config.json file:

freqtrade download-data \
  --config user_data/config.json \
  --timeframes 15m \
  --timerange 20200101-20250626

Common Parameters Explained:

Parameter	Description
`--exchange`	Specify the exchange (e.g., binance, bybit, kucoin)
`--pairs`	Specify trading pairs, e.g., `BTC/USDT`, separated by commas
`--timeframes`	Timeframes to download, e.g., `1m`, `15m`, `1h`, `1d`
`--timerange`	Data time range, format: `YYYYMMDD-YYYYMMDD`
`--days`	Download data for the last N days (alternative to `--timerange`)
`--config`	(Optional) Use an existing config file to specify the exchange

📊 2. Downloading Multiple Pairs / Timeframes

Multiple trading pairs (e.g., BTC, ETH, BNB):

--pairs BTC/USDT,ETH/USDT,BNB/USDT

Multiple timeframes (e.g., 15m and 1h):

--timeframes 15m,1h

Best Practice: Download each timeframe separately for easier management:

freqtrade download-data --timeframes 15m
freqtrade download-data --timeframes 1h

🐳 3. Using Docker to Download Data

If you're using Docker, the command is slightly different:

docker compose run --rm freqtrade download-data \
  --config /quants/freqtrade/user_data/config.json \
  --timeframes 15m \
  --timerange 20220101-20230701

Ensure the user_data/ directory is properly mounted in your docker-compose.yml:

volumes:
  - "./user_data:/quants/freqtrade/user_data"

📂 4. Where is the Data Stored?

Downloaded K-line data is stored in:

user_data/data/<exchange>/<pair><timeframe>-<type>.feather

For example:

user_data/data/binance/BTC_USDT_USDT-5m-futures.feather

Freqtrade automatically detects and uses this data for backtesting and optimization.

🔍 5. Which Exchanges Does Freqtrade Support?

Run the following command to view currently supported exchanges:

freqtrade list-exchanges

Commonly supported exchanges (may vary by version):

Binance (spot and futures)
Bybit
KuCoin
Huobi
Kraken
OKX
Coinbase Pro
Gate, etc. > ⚠️ Some exchanges require an API key to download historical data.

✅ 6. Tips and Recommendations

Item	Recommendation
Time Range	Download at least 3–6 months of data
Timeframe	Use `1h` or `15m` for strategy development; `1m` for high-frequency strategies
Longer Data = Better?	Very old data may mislead due to changing market conditions
Storage Space	1m data is large; ensure sufficient disk space

📌 7. Summary

The freqtrade download-data command is the starting point for all strategy development.

This article covered:

Parameter usage: exchange, pairs, timeframes, timerange
Techniques for downloading multiple pairs and timeframes
Downloading data in a Docker environment
Data storage paths and supported exchanges

Article 2: Start Live Trading or Paper Trading? Freqtrade trade Command Explained

itrade icu — Sun, 19 Oct 2025 06:42:24 +0000

Article 2: 📘 Start Live Trading or Paper Trading? Freqtrade trade Command Explained

The freqtrade trade command is the core command for starting live or simulated trading bots, and it's the key step for implementing automated trading.

This article will guide you through understanding the usage, common parameters, configuration tips, and Docker-based startup methods of the trade command. It's suitable for those preparing for live deployment or who have just completed strategy backtesting.

🚀 Want to Learn Quantitative Trading?

👉 Click to visit: https://www.itrade.icu
Here you'll find Freqtrade Basics Tutorials, Strategy Practice, Indicator Analysis, and more rich content to help you easily master quantitative trading skills!

🚀 I. Basic Syntax

freqtrade trade \
  --config user_data/config.json \
  --strategy MyStrategy \
  --dry-run

Parameter Explanation
| Parameter | Description |
| ---------------- | ------------------------------- |
| --config | Specify the configuration file path |
| --strategy | Start with the specified strategy class name |
| --dry-run | Enable dry-run (simulated trading) mode, recommended to enable by default |
| --logfile | Specify the log output location |
| --db-url | Specify the database file or connection (to record trading history) |
| --userdir | Set the user directory path (default user_data/) |

🧪 II. What is Dry-run Mode?

Dry-run mode = No actual orders are placed; only simulated orders and logs are recorded.

Applicable to:

✅ Strategy validation phase (ensure logic is error-free)
✅ Testing run before live deployment
✅ Avoid real losses due to parameter configuration errors Once ready for live deployment, disable this parameter:

freqtrade trade --config user_data/config.json --strategy MyStrategy

⚠️ It is recommended to run dry-run tests for at least 7 days before going live with real trading!

🧩 III. Support for Multi-Strategy Execution

Multiple strategies or strategy paths can be loaded via command-line parameters:

freqtrade trade \
  --config user_data/config.json \
  --strategy-path user_data/strategies \
  --strategy MyStrategyA MyStrategyB

Or combine multiple config files (suitable for multi-account / multi-platform):

freqtrade trade -c spot_config.json -c futures_config.json

Notes for multi-strategy:

All strategies must be importable in the specified directory
Use --strategy-path to specify additional paths

🐳 IV. Starting the trade Command with Docker

Running in a Docker container is safer and easier to deploy. It's recommended to use docker-compose:

docker compose run --rm freqtrade trade \
  --config /freqtrade/user_data/config.json \
  --strategy MyStrategy \
  --dry-run

Sample docker-compose.yml:

services:
  freqtrade:
    image: freqtradeorg/freqtrade:stable
    volumes:
      - ./user_data:/freqtrade/user_data
    ports:
      - "127.0.0.1:8080:8080"
    command: >
      trade
      --config /freqtrade/user_data/config.json
      --strategy MyStrategy
      --logfile /freqtrade/user_data/logs/freqtrade.log

After starting, access the Web UI to view trading status in real-time:

http://localhost:8080

🧷 V. Some Recommended Configuration Items

In config.json, it is recommended to enable the following configuration items to ensure safety:

{
  "dry_run_wallet": 1000,
  "dry_run": true,  //  Enable dry mode
  "max_open_trades": 3,
  "stake_currency": "USDT",
  "tradable_balance_ratio": 0.9,
  "timeframe": "15m"
}

It is also recommended to configure:

exchange → key/secret: Real trading requires providing actual API keys
logging → logfile: Log output
db_url: Connect to SQLite/Postgres etc. to store trading records

✅ VI. Live Trading Startup Checklist

Checklist Item	Recommendation
Has the strategy passed backtesting?	✅ At least cover 6 months or more of history
Has it been run in Dry-run mode?	✅ Simulated run for 7 days or more
Is the config.json configuration complete?	✅ Includes risk control, coins, leverage, etc.
Has the API Key been set?	✅ And recommend setting IP whitelist
Have logs and error outputs been monitored?	✅ Use `--logfile` to save records

📌 Summary

The trade command is the "final step" command in Freqtrade and the link closest to live trading profits.
This article covers:

Basic syntax and parameters of the trade command
Advantages and recommended practices of Dry-run
Ways to combine multi-strategy / multi-config
Full process of starting live trading with Docker After mastering these techniques, you can transition from a strategy developer to a true automated trading live deployment expert.

Freqtrade Comprehensive Command Manual! Master Quantitative Trading from Beginner to Live Trading in One Article

itrade icu — Fri, 17 Oct 2025 08:12:29 +0000

🚀 Freqtrade Comprehensive Command Manual! Master Quantitative Trading from Beginner to Live Trading in One Article

Master the key commands for a quantitative trading bot from beginner to live trading in one article!

Freqtrade is a powerful and open-source cryptocurrency automated trading framework that supports strategy development, historical backtesting, parameter optimization, data analysis, and live trading.

However, for beginners, the functionality and usage of various commands may not be intuitive. This article categorizes, explains, and provides practical examples of all core Freqtrade commands.

🚀 Want to Learn Quantitative Trading?

👉 Visit: https://www.itrade.icu

Here you'll find Freqtrade beginner tutorials, strategy walkthroughs, indicator explanations, and more to help you easily master quantitative trading skills!

🎯 Command Structure Overview

Freqtrade’s command-line tool uses freqtrade as the main command, with different subcommands to perform various tasks:

freqtrade <subcommand> [options]

You can use freqtrade -h to view the main command help or freqtrade <subcommand> -h to see detailed parameters for a specific subcommand.

📦 Command Categories Quick Reference Table

Category	Command Examples	Purpose Overview
Data Processing	`download-data`, `convert-data`	Download/process historical market data
Strategy Development & Testing	`new-strategy`, `backtesting`, `hyperopt`	Create and test trading strategies
Live Trading	`trade`, `webserver`	Start the bot for trading or dry-run
System Configuration	`new-config`, `create-userdir`	Initialize configuration and project structure
Query & Diagnostics	`show-trades`, `list-data`, `list-pairs`	Query strategies, data, and trade records
Visualization	`plot-dataframe`	Visualize strategy behavior with charts

🚀 1. Live and Simulated Trading Commands

`trade` - Start the Trading Bot (Live or Dry-run)

freqtrade trade \
  --config user_data/config.json \
  --strategy MyStrategy \
  --dry-run

--dry-run: Simulate trading without placing real orders (recommended by default)
--db-url: Specify the database (for storing trade history)
--logfile: Specify the log output location > ⚠️ Ensure the strategy has been backtested and config.json is correctly configured before starting!

📥 2. Data Download and Processing Commands

`download-data` - Download Historical Market Data

freqtrade download-data \
  --exchange binance \
  --pairs BTC/USDT \
  --timeframes 1h \
  --timerange 20230101-20230301

--exchange: Supports exchanges like Binance, Bybit, etc.
--pairs: Specify multiple trading pairs at once
--timeframes: Download data for timeframes like 1m, 5m, 15m, 1h, 1d, etc.

`convert-data` - Convert Data Format (CSV → JSON)

Convert external data sources (e.g., CCXT, Kaggle) into Freqtrade’s format.

🧪 3. Strategy Development and Backtesting Commands

`new-strategy` - Create a Strategy Template

freqtrade new-strategy --strategy MyNewStrategy

Creates a .py file with structured comments in the user_data/strategies/ directory.

`backtesting` - Backtest Strategy Performance

freqtrade backtesting \
  --config user_data/config.json \
  --strategy MyStrategy \
  --timeframe 15m \
  --timerange 20220101-20230101

Simulates historical trades to evaluate strategy profitability
Allows setting timeframes, trading pairs, etc.
Use with backtesting-show to view chart results

`hyperopt` - Parameter Optimization

freqtrade hyperopt \
  --config user_data/config.json \
  --strategy MyStrategy \
  --hyperopt-loss SharpeHyperOptLoss

Automatically searches for optimal parameter combinations (e.g., RSI thresholds, take-profit ratios)
Supports multiple evaluation metrics (Sharpe, Sortino, pure profit, etc.)

📊 4. Data Visualization Commands

`plot-dataframe` - Visualize Strategy Behavior

freqtrade plot-dataframe \
  --config user_data/config.json \
  --strategy MyStrategy \
  --timerange 20230101-20230201

Generates HTML charts showing buy/sell points, candlesticks, indicators, etc.
Charts are saved in the user_data/plot/ directory

⚙️ 5. Configuration and Project Initialization Commands

`new-config` - Create Configuration File

freqtrade new-config --config user_data/config.json

Includes trading pairs, strategy name, risk management, and capital management settings.

`create-userdir` - Initialize Project Structure

freqtrade create-userdir --userdir user_data

Creates a standard directory structure (logs, data, strategies, configs).

🔍 6. Query and Utility Commands

Command	Functionality
`show-trades`	Display trade records/backtest results
`list-data`	View available local historical data
`list-pairs`	Show supported trading pairs in the current config
`list-exchanges`	List exchanges supported by Freqtrade
`list-strategies`	List strategies in the `strategies` directory
`list-timeframes`	Show supported timeframe formats

✅ Recommended Commands to Master for Daily Use:

freqtrade download-data
freqtrade backtesting
freqtrade hyperopt
freqtrade trade
freqtrade show-trades

🐳 Using Docker

Most commands work in Docker as well:

docker compose run --rm freqtrade trade \
  --config /freqtrade/user_data/config.json \
  --strategy MyStrategy

Ensure the docker-compose.yml file has correctly mounted paths.

📌 Summary

Freqtrade’s command-line tools cover the entire quantitative trading workflow: from data to backtesting, optimization, and live trading, making it ideal for developers and strategy researchers.

Recommended steps to get started:

Download data (download-data)
Write a strategy (new-strategy)
Backtest and optimize (backtesting + hyperopt)
Run live trading (trade + Web UI)
Visualize analysis (plot-dataframe)

Master these commands, and you’ll be able to independently manage a cryptocurrency automated trading system!

DEV Community: itrade icu

Episode 11: Futures or Spot? Master Freqtrade's Trading Modes and Leverage Settings in One Go!

Episode 11: ⚔️ Futures or Spot? Master Freqtrade's Trading Modes and Leverage Settings in One Go!

🚀 Want to Learn Quantitative Trading?

Here you'll find Freqtrade beginner tutorials, real-world strategy guides, indicator breakdowns, and more — helping you master quant trading skills with ease!

💱 trading_mode — Trading Mode Setting

🟢 Spot Mode Features

🔴 Futures Mode Features

🧮 margin_mode — Futures Margin Mode

💥 leverage — Leverage Multiplier Setting

📌 Example in Strategy Code:

⚠️ Key Notes:

🛡️ liquidation_buffer — Liquidation Buffer

📌 Example:

✅ Recommended Configuration Combo

📊 Mode Comparison Summary

🔐 Live Trading Risk Control Tips

🧠 Summary Checklist

Episode 10: 💥 Stop Going All-In and Getting Liquidated! Master Freqtrade's Capital Allocation to Survive Longer

Episode 10: 💥 Stop Going All-In and Getting Liquidated! Master Freqtrade's Capital Allocation to Survive Longer

🚀 Want to Learn Quantitative Trading?

Here you'll find Freqtrade beginner tutorials, real-world strategy guides, indicator breakdowns, and more — helping you master quant trading skills with ease!

🪙 stake_currency — The Trading Currency Used

💵 stake_amount — Investment Amount Per Trade

1️⃣ Fixed Value (Recommended for Beginners)

2️⃣ Dynamic Value "unlimited"

🧮 tradable_balance_ratio — Balance Usage Ratio Limit

🛡️ Live Trading Risk Control Recommendations

✅ Example Configuration Combo

✅ Summary Checklist

Episode 10: 💥 Stop Going All-In and Getting Liquidated! Master Freqtrade's Capital Allocation to Survive Longer

Episode 10: 💥 Stop Going All-In and Getting Liquidated! Master Freqtrade's Capital Allocation to Survive Longer

🚀 Want to Learn Quantitative Trading?

🪙 stake_currency — The Trading Currency Used

💵 stake_amount — Investment Amount per Trade

1️⃣ Fixed Value (Recommended for Beginners)

2️⃣ Dynamic Value "unlimited"

🧮 tradable_balance_ratio — Balance Usage Ratio Limit

🛡️ Live Trading Risk Control Recommendations

✅ Example Configuration Combination

✅ Summary Checklist

Article 9: Freqtrade Quantitative Trading - config.json Basics and Initialization

Article 9: Freqtrade Quantitative Trading - config.json Basics and Initialization

This article will systematically guide you through the role of config.json, how to generate it, its file structure, and editing tips to help you get started quickly and avoid common pitfalls.

🚀 Want to Learn Quantitative Trading?

Here you'll find Freqtrade beginner tutorials, real-world strategy examples, indicator breakdowns, and more to help you master quantitative trading techniques with ease!

🧱 What is config.json?

🐳 Directory Structure When Running with Docker

🔍 Beginner Preview Example

🧠 Summary

Article 8: Quantitative Trading - Differences Between tradeUI and webserverUI

🔍 Article 8: Quantitative Trading - Differences Between tradeUI and webserverUI

🚀 Want to learn quantitative trading?

✅ Use Case Distinction

1. trade Runs the Bot

2. webserver Provides a Graphical Interface

🔄 Relationship Summary

🧩 Practical Advice (Docker Environment)

Chapter 7: How to Set Up the Freqtrade Web UI? Installation and Usage Guide

📘 Chapter 7: How to Set Up the Freqtrade Web UI? Installation and Usage Guide

🚀 Want to Learn Quantitative Trading?

🧩 1. Install Web UI Dependencies

🚀 2. Start the Webserver Service

⚙️ 3. Common Parameters Explained

🐳 4. Docker Setup for Web UI

📊 6. Web UI Modules Explained

✅ 1. Live Trading Web UI (enabled with freqtrade trade)

🧪 2. Backtesting Web UI

🔧 7. Notes and Common Issues

📌 Summary

Article 6: Freqtrade - "Visualize Your Data with Charts! Plot-Dataframe Visualization Tutorial"

📘 Article 6: Freqtrade - "Visualize Your Data with Charts! Plot-Dataframe Visualization Tutorial"

🚀 Want to Learn Quantitative Trading?

🎯 1. Basic Usage: Generating Charts

🧾 2. Parameter Breakdown

📐 3. Adding Custom Indicators

❗ Note:

💾 4. Exporting to HTML / PNG

🐳 5. Running in a Docker Environment

✅ 6. Usage Tips

🔍 Article 8: Quantitative Trading - Differences Between `tradeUI` and `webserverUI`

1. `trade` Runs the Bot

2. `webserver` Provides a Graphical Interface

✅ 1. Live Trading Web UI (enabled with `freqtrade trade`)

Article 3: 🛠️ Starting from Scratch! A Detailed Guide to the Freqtrade `download-data` Command and Docker Usage

`trade` - Start the Trading Bot (Live or Dry-run)

`download-data` - Download Historical Market Data

`convert-data` - Convert Data Format (CSV → JSON)

`new-strategy` - Create a Strategy Template

`backtesting` - Backtest Strategy Performance

`hyperopt` - Parameter Optimization

`plot-dataframe` - Visualize Strategy Behavior