TVControl : l’outil gratuit qui permet à l’IA de piloter TradingView

TVControl IA TradingView Pine Script backtest tutoriel — TVControl permet de piloter TradingView Desktop avec une IA compatible MCP. Attention : on parle d’analyse, de Pine Script, de replay et de backtests, pas de trading live automatisé.

TVControl fait beaucoup parler de lui parce qu’il connecte une IA à TradingView Desktop. En clair : tu peux demander à ton agent IA d’analyser un graphique, d’écrire du Pine Script, de compiler une stratégie, de corriger les erreurs et de lancer des tests.

Mais soyons précis dès le départ : ce n’est pas un robot magique, et ce n’est pas un système à brancher à ton argent. TVControl est un outil technique pour travailler plus vite sur l’analyse, le code, le backtest et l’entraînement.

À retenir : TVControl est un serveur MCP open source compatible avec des agents IA comme Claude Code, Codex, Cursor ou Gemini CLI. Il pilote TradingView Desktop localement via Chrome DevTools Protocol.

C’est quoi TVControl ?

TVControl est un projet open source publié par Ferrox Labs. Techniquement, c’est un serveur MCP. MCP signifie Model Context Protocol : c’est un protocole qui permet à une IA de communiquer avec des outils externes.

Dans ce cas, l’outil externe, c’est TradingView Desktop. L’IA ne regarde pas une simple capture d’écran : elle peut interagir avec l’application locale, lire le graphique, manipuler certains éléments, injecter du Pine Script, compiler, récupérer les erreurs et produire des screenshots.

Le repo officiel indique que TVControl expose 88 outils MCP pour contrôler les graphiques, les indicateurs, le replay, les alertes, les watchlists, les stratégies et le Pine Script.

Comment ça fonctionne ?

TVControl utilise l’interface de debug intégrée aux applications Chromium/Electron. TradingView Desktop étant basé sur Electron, il peut être lancé avec un port de debug local.

IA compatible MCP
      ↓
Serveur MCP TVControl
      ↓
Chrome DevTools Protocol localhost:9222
      ↓
TradingView Desktop
      ↓
Graphique, Pine Script, replay, backtest

Le point important, c’est que tout se passe sur ta machine. TVControl parle à ton application TradingView Desktop locale. Le repo indique qu’il ne réalise pas d’appel cloud externe pour fonctionner.

Ce que TVControl peut faire

Lire le graphique affiché : symbole, timeframe, indicateurs, prix, contexte.
Changer de symbole ou d’unité de temps.
Faire des screenshots du graphique.
Créer, lire, modifier et compiler du Pine Script.
Récupérer les erreurs Pine Script et aider à les corriger.
Lancer des tests de paramètres sur une stratégie.
Utiliser le replay pour s’entraîner bougie par bougie.
Scanner une watchlist et classer des actifs selon des critères.
Sauvegarder et restaurer des configurations de graphiques.

Ce que TVControl ne doit pas faire

Il faut être très clair : TVControl ne doit pas être utilisé pour exécuter des trades réels automatisés. Le repo officiel précise que l’outil est destiné à un usage personnel, éducatif et de recherche.

Ne laisse pas l’IA passer des ordres réels.
Ne branche pas TVControl à un broker pour trader en live.
Ne scrape pas massivement les données TradingView.
Ne redistribue pas les données de marché.
Ne contourne pas les restrictions ou paywalls de TradingView.

Le bon usage : analyser, apprendre, coder, backtester, documenter et s’entraîner.

Pourquoi c’est intéressant pour les traders ?

Beaucoup de traders ont des idées de stratégie, mais restent bloqués au moment de les tester.

“Je veux tester une stratégie qui achète quand l’EMA 20 croise l’EMA 50, mais seulement si le RSI est au-dessus de 50.”

Sans outil, tu dois écrire le Pine Script, corriger les erreurs, ajouter les paramètres, lancer le backtest, comparer les résultats et recommencer. Avec TVControl, tu peux demander à l’IA de t’aider à transformer cette idée en code testable. Ça ne rend pas la stratégie rentable. Ça rend le test plus rapide.

Pré-requis avant installation

TradingView Desktop installé ;
Node.js 18.14.1 ou plus ;
Git ;
un client IA compatible MCP : Claude Code, Codex, Cursor, Gemini CLI ou équivalent ;
un terminal.

node -v
npm -v

Étape 1 : installer TVControl

git clone https://github.com/ferroxlabs/tvcontrol.git
cd tvcontrol
npm install

Le projet est aussi disponible via npm :

npm install -g @ferroxlabs/tvcontrol

Pour un premier test, la méthode GitHub est plus transparente : tu peux lire les fichiers, les exemples, les prompts et la configuration MCP.

Étape 2 : lancer TradingView avec le port debug

TVControl a besoin que TradingView Desktop soit lancé avec le port debug activé.

scriptslaunch_tv_debug.bat

À la main, le principe est :

TradingView.exe --remote-debugging-port=9222

Exemple possible sur Windows :

"C:UsersTON_NOMAppDataLocalProgramsTradingViewTradingView.exe" --remote-debugging-port=9222

Étape 3 : ajouter TVControl à ton client IA

{
  "mcpServers": {
    "tvcontrol": {
      "command": "node",
      "args": ["C:/chemin/vers/tvcontrol/src/server.js"]
    }
  }
}

Remplace le chemin par ton vrai chemin local, puis redémarre ton client IA.

Étape 4 : vérifier la connexion

Utilise tv_health_check pour vérifier la connexion à TradingView.

Utilise chart_vision_read pour résumer mon graphique : symbole, timeframe, dernier prix, indicateurs visibles et tendance récente.

Étape 5 : créer une première stratégie Pine Script

Voici une stratégie simple pour débuter : croisement EMA 20 / EMA 50 avec filtre RSI et stop ATR.

//@version=6
strategy("Imprimante - EMA RSI Backtest", overlay=true, initial_capital=10000, commission_type=strategy.commission.percent, commission_value=0.05, pyramiding=0)

fastLen = input.int(20, "EMA rapide")
slowLen = input.int(50, "EMA lente")
rsiLen = input.int(14, "RSI")
rsiMin = input.int(50, "RSI minimum")
atrLen = input.int(14, "ATR")
atrMult = input.float(1.5, "Stop ATR")
rr = input.float(2.0, "Risk Reward")

emaFast = ta.ema(close, fastLen)
emaSlow = ta.ema(close, slowLen)
rsi = ta.rsi(close, rsiLen)
atr = ta.atr(atrLen)

longSignal = ta.crossover(emaFast, emaSlow) and rsi > rsiMin

plot(emaFast, color=color.blue, title="EMA rapide")
plot(emaSlow, color=color.orange, title="EMA lente")

if longSignal
    strategy.entry("Long", strategy.long)

if strategy.position_size > 0
    stopPrice = strategy.position_avg_price - atr * atrMult
    takeProfit = strategy.position_avg_price + (strategy.position_avg_price - stopPrice) * rr
    strategy.exit("TP/SL", "Long", stop=stopPrice, limit=takeProfit)

Crée cette stratégie Pine Script dans TradingView, compile-la, corrige les erreurs si besoin, puis résume le rapport de performance.

Étape 6 : lire le backtest intelligemment

Un backtest ne sert pas à rêver. Il sert à poser les bonnes questions : nombre de trades, taux de réussite, profit factor, drawdown maximum, période testée, frais, slippage et périodes où la stratégie ne fonctionne pas.

Analyse ce backtest. Dis-moi ce qui est solide, ce qui est fragile, et ce qui ressemble à de l’overfitting.

Étape 7 : tester plusieurs paramètres

Teste cette stratégie sur BTCUSDT en 1H avec :
EMA rapide : 10, 20, 30
EMA lente : 50, 100, 200
RSI minimum : 45, 50, 55
Risk Reward : 1.5, 2, 3

Classe les résultats par profit factor, drawdown et nombre de trades.

Attention : optimiser trop fort peut créer une stratégie parfaite dans le passé et inutile dans le futur. Le but n’est pas de trouver le réglage magique. Le but est de vérifier si l’idée tient debout.

Étape 8 : utiliser le replay pour s’entraîner

Lance le replay sur BTCUSDT en 15 minutes à partir du 1er mars 2026. Avance bougie par bougie. À chaque setup EMA/RSI, explique si l’entrée est propre ou non.

Ce type d’exercice t’aide à attendre, à reconnaître les faux signaux, à comprendre le contexte et à arrêter de cliquer partout.

Les meilleurs prompts TVControl pour débuter

Analyse graphique

Analyse le graphique affiché sur TradingView. Donne-moi le symbole, le timeframe, la tendance, les zones clés, les indicateurs visibles et les risques avant d’envisager un trade.

Création de stratégie

Crée une stratégie Pine Script simple basée sur EMA 20 / EMA 50, filtre RSI et stop ATR. Compile-la dans TradingView et corrige les erreurs.

Analyse anti-overfitting

Dis-moi si cette stratégie semble overfit. Propose 5 tests pour vérifier sa robustesse.

Conclusion : un outil puissant, mais pas magique

TVControl est l’un des outils open source les plus intéressants du moment pour mélanger IA, TradingView, Pine Script et backtest. Sa vraie valeur n’est pas de remplacer le trader. Sa vraie valeur, c’est de transformer une idée floue en test concret.

Le but, ce n’est pas de cliquer plus vite. Le but, c’est de savoir pourquoi tu cliques.

FAQ

TVControl permet-il de trader automatiquement ?

Non. La documentation officielle précise que l’outil ne doit pas être utilisé pour exécuter des trades réels automatisés. Il sert surtout à l’analyse, au Pine Script, au backtest, au replay et aux simulations.

TVControl fonctionne-t-il avec Codex ?

Oui. Le repo indique qu’il fonctionne avec des agents compatibles MCP, dont Claude Code, Codex, Gemini CLI, Cursor et d’autres.

TVControl est-il gratuit ?

Oui, le code est open source sous licence MIT. Mais TradingView, ses données et certaines fonctionnalités peuvent dépendre d’un abonnement ou de conditions d’utilisation spécifiques.

Est-ce que TVControl rend une stratégie rentable ?

Non. TVControl accélère le travail technique, mais une stratégie doit être validée avec gestion du risque, frais, slippage, robustesse et tests hors échantillon.

Sources

TVControl par Ferrox Labs : GitHub FerroxLabs/tvcontrol
Package officiel TVControl : package.json
TradingView MCP original : GitHub tradesdontlie/tradingview-mcp
Documentation Pine Script : TradingView Pine Script Docs
Conditions d’utilisation TradingView : TradingView policies

Avertissement : cet article est pédagogique et ne constitue pas un conseil en investissement. Le trading comporte un risque de perte en capital. Aucun outil IA ne garantit un résultat financier.