Freqtrade : un bot de trading crypto open source en Python

Introduction

Freqtrade est un bot de trading automatisé de crypto-monnaies, gratuit et open source, écrit en Python. Initialement publié en 2018 (et continuellement amélioré depuis), il a été conçu pour fonctionner sur la plupart des grandes plateformes d’échange de cryptos via l’API unifiée CCXT. Le projet s’est rapidement imposé dans l’écosystème open source grâce à sa communauté active et ses contributions régulières : il compte plus de 38 000 étoiles sur GitHub en 2025, témoignant de sa popularité auprès des développeurs et traders.

Freqtrade s’inscrit dans la lignée des bots de trading algorithmiques accessibles, offrant une alternative transparente aux solutions propriétaires, et se destine aussi bien aux utilisateurs avancés qu’aux développeurs débutants souhaitant expérimenter le trading automatique de crypto-monnaies.

En pratique, Freqtrade permet d’automatiser des stratégies de trading définies par l’utilisateur. Il prend en charge :

Backtesting (tests rétroactifs sur données historiques)
Paper trading (simulation sans argent réel)
Live trading (exécution sur le marché réel)
Optimisation automatique des paramètres (hyperoptimisation)
Apprentissage automatique via le module FreqAI

Grâce à ces outils, un utilisateur peut concevoir, tester, améliorer et déployer une stratégie de trading de bout en bout, le tout dans un cadre open source maîtrisable et auditable.

Fiche technique de Freqtrade

Marchés pris en charge : Crypto‑monnaies sur plus de 100 exchanges via CCXT (Binance, Kraken, Coinbase Pro, etc.), avec support expérimental des futures.
Langage : Python ≥ 3.10 (multiplateforme, écosystème riche : pandas, NumPy…).
Licence : GPLv3 (copyleft, code librement modifiable).
Cas d’usage : Backtesting, live trading, paper trading, hyperoptimisation, apprentissage automatique (FreqAI).
Dépôt officiel : github.com/freqtrade/freqtrade (28 000 commits, dizaines de contributeurs).
Maturité : Très actif (38 000 ★, 7 000 forks, mises à jour fréquentes).
Fonctionnalités :
- Interface web (FreqUI)
- Notifications et pilotage via Telegram
- Gestion avancée des ordres (stop-loss, take-profit, trailing stop)
- API REST intégrée
- Visualisation des performances, notebooks Jupyter

Installation du bot Freqtrade

Résumé des commandes :

Initial (une fois) : Prérequis, clone du dépôt, freqtrade create-userdir, freqtrade new-config, freqtrade install-ui (local) ou docker compose pull (Docker).
Usage quotidien : docker compose up -d (Docker) ou freqtrade webserver --config user_data/config.json (local), puis freqtrade trade ou freqtrade hyperopt.

1. Installation via Docker (recommandée)

Installer Docker : Installez Docker et docker-compose.

Créer un dossier :

mkdir freqtrade_bot && cd freqtrade_bot
curl -o docker-compose.yml \
  https://raw.githubusercontent.com/freqtrade/freqtrade/stable/docker-compose.yml
docker compose pull

Initialiser l’environnement :

docker compose run --rm freqtrade create-userdir --userdir user_data
docker compose run --rm freqtrade new-config --config user_data/config.json

Ajouter une stratégie (optionnel) : Copier votre fichier Python dans user_data/strategies.
Démarrer le bot :
```
docker compose up -d
```
Le bot tourne en mode dry-run ou live selon config.json. Web UI accessible sur http://localhost:8080 si activé.

2. Installation manuelle (locale)

Prérequis : Python 3.10+, git, compilateur C pour TA‑Lib.

Cloner le dépôt :

git clone https://github.com/freqtrade/freqtrade.git
cd freqtrade

Créer un virtualenv et installer les dépendances :

python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install --upgrade pip
python3 -m pip install -r requirements.txt
python3 -m pip install -e .

Initialiser user_data :

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

Lancer le bot :

freqtrade trade -c user_data/config.json --strategy SampleStrategy

Interface Web (FreqUI) et outils intégrés

Installation de l’UI (FreqUI)

freqtrade install-ui

Puis lancez le serveur Web :

freqtrade webserver -c user_data/config.json

Ensuite, ouvrez http://localhost:8080 dans votre navigateur.

Connexion à l’interface Web (FreqUI)

Bot Name : correspond à la clé bot_name dans user_data/config.json (ex : freqtrade).
API Url : laissez http://localhost:8080 si vous êtes en local.
Username / Password : définis dans la section api_server du fichier user_data/config.json.

Pensez à relancer le serveur web après modification :

freqtrade webserver -c user_data/config.json

Visualiser en temps réel les indicateurs, trades et P&L
Démarrer/stopper le bot et forcer des entrées/sorties
Lancer des backtests visuels et comparer plusieurs configurations
Configurer l’affichage (thème, fuseau horaire)

Accessible sur localhost:8080. Notifications et pilotage via Telegram disponibles.

freqtrade download-data – récupérer des OHLCV
freqtrade plot-dataframe – tracer vos indicateurs
Exports vers SQLite, Prometheus/Grafana, etc.

Utiliser des stratégies communautaires

Freqtrade propose un dépôt officiel de stratégies prêtes à l’emploi : freqtrade-strategies.

git clone https://github.com/freqtrade/freqtrade-strategies.git

cp freqtrade-strategies/user_data/strategies/NomDeLaStrategie.py user_data/strategies/

freqtrade trade -c user_data/config.json --strategy NomDeLaStrategie

En savoir plus sur les stratégies

Présentation du module FreqAI (machine learning)

FreqAI est l’extension ML de Freqtrade qui transforme vos stratégies en véritables pipelines de data science automatisés : extraction de variables, entraînement de modèles et génération de signaux en temps réel.

Feature engineering automatisé – génération et normalisation de centaines de variables techniques (indicateurs, timeframes, décalages…)
Entraînement optimisé – prise en charge de GBDT (CatBoost, LightGBM, XGBoost) et de réseaux de neurones (TensorFlow, PyTorch)
Inférence en direct – prédiction instantanée de signaux d’achat/vente avec estimation de confiance
Gestion avancée des outliers – détection et filtrage adaptatif pour garantir la robustesse des décisions

Destiné aux traders et développeurs familiers du machine learning, ce module expérimental nécessite des ressources CPU/GPU et un historique de données conséquent. Il est documenté dans JoSS pour valider son apport scientifique et sa reproductibilité. En savoir plus sur FreqAI

Hyperopt avec Freqtrade

Hyperopt est l’outil d’optimisation intégré à Freqtrade, basé sur l’optimisation bayésienne, qui automatise la recherche des meilleurs paramètres de votre stratégie (buy, sell, stoploss, roi, trailing…). En quelques commandes, vous lancez :


freqtrade hyperopt \
  --strategy MaStrategie \
  --hyperopt-loss SharpeHyperOptLossDaily \
  --spaces buy sell roi stoploss trailing \
  --timerange 20220101-20220301 \
  -e 100

Hyperopt explore efficacement l’espace de paramètres et renvoie la combinaison optimale selon la fonction de perte choisie (Sharpe, Sortino, drawdown…). Pratique pour gagner du temps et améliorer la robustesse de vos backtests avant déploiement en live. En savoir plus sur Hyperopt

Déploiement recommandé (Docker, CI/CD, Cloud)

Docker en production : Isolation des dépendances, mises à jour triviales (docker compose pull + restart).
CI/CD : GitHub Actions pour rebuild et déployer votre image à chaque commit de stratégie.
Orchestration : Kubernetes/ECS/EKS/GKE pour haute disponibilité et scalabilité.
Versioning : Conservez vos stratégies en dépôt Git privé, déployez depuis ce repo.

Sécurité : gestion des clés API et bonnes pratiques

Injecter les clés via variables d’environnement (pas en clair dans config.json).
Limiter les permissions API (trade only, pas de retrait).
Restreindre l’accès par IP sur l’exchange.
Protéger l’API REST/Web UI avec JWT ou proxy HTTPS.
Vérifier le code des stratégies tierces avant usage.
Maintenir Freqtrade et ses dépendances à jour.

Performance et benchmarks

Latence : ~ 100 ms par cycle d’analyse (bougies minute+).
Throughput : Jusqu’à 50 ordres/s en backtest, soumis aux limites exchange.
Ressources : Quelques centaines de Mo de RAM, CPU modéré en live, plus intense en backtest et hyperopt.

Pour suivre > 50 paires 1m avec indicateurs lourds, envisagez plusieurs instances ou sharding. Hyperoptimisation supporte le multiprocessing.

Exemples concrets d’utilisation

Stratégie de croisement de moyennes mobiles :
- Créer MaCrossStrategy dans user_data/strategies.
- Backtest : freqtrade backtesting --strategy MaCrossStrategy -p BTC/USDT -t 1h --timerange=20210101-20211231.
- Optimisation : freqtrade hyperopt --strategy MaCrossStrategy -e 100.
- Dry-run : freqtrade trade --strategy MaCrossStrategy (simulation).
- Live : configurer dry_run: false, clés réelles, et docker compose up -d.
Gestion du workflow : du développement et backtest à la mise en production, avec supervision via Telegram/Web UI.

Avantages de Freqtrade

Open source et gratuit (transparence totale).
Multi-exchanges standardisé via CCXT.
Personnalisable en Python (stratégies infinies).
Outils intégrés pour tout le cycle de vie du trading.
Interfaces conviviales (Web UI, Telegram).
Communauté active et support réactif (Discord, GitHub).
Développement actif et fiabilité éprouvée.

Limites de Freqtrade

Courbe d’apprentissage technique (programmation, CLI).
Pas de “stratégie parfaite” fournie par défaut – l’utilisateur doit coder et tester.
Non adapté au HFT/micro-latence (Python/GIL).
Gestion multitraiding lourde si trop de paires.
FreqAI encore expérimental, risque de sur-optimisation.
Surveillance nécessaire – pas un “fire & forget”.
Responsabilité de l’utilisateur en cas de pertes.