TradingView MCP — EzyDubs

Personal AI assistant and execution agent for your TradingView Desktop charts. Connects your AI to a locally running TradingView app via Chrome DevTools Protocol for AI-assisted chart analysis, Pine Script development, workflow automation — and live order execution with any connected TradingView broker (native Paper or BlackBull cTrader). This is the EzyDubs fork: hardened broker trading with fail-closed mutations, order-history-based confirmation, and a strict two-indicator resource plan for cleaner charts.

How It Works (and why it's safe to run)

This tool does not connect to TradingView's servers, modify any TradingView files, or intercept any network traffic. It communicates exclusively with your locally running TradingView Desktop instance via Chrome DevTools Protocol (CDP) — a standard debugging interface built into all Chromium/Electron applications by Google, including VS Code, Slack, and Discord.

The debug port is disabled by default and must be explicitly enabled by you using a standard Chromium flag (--remote-debugging-port=9222). Nothing happens without that deliberate step.

Related MCP server: TradingView MCP Bridge

What This Tool Does Not Do

• Connect to TradingView's servers or APIs

• Store, transmit, or redistribute any market data

• Work without a valid TradingView subscription and installed Desktop app

• Bypass any TradingView paywall or access restriction

• Move markets or gain better-than-market fills (fills always come from the broker's live feed)

• Work if TradingView changes their internal Electron structure

Research Context

This project explores an open research question: how can LLM-based agents interact with professional trading interfaces to support human decision-making?

Specifically it investigates:

• How structured tool APIs (MCP) can bridge LLMs and stateful desktop financial applications

• What latency, context, and reliability constraints emerge when an agent operates on live chart data

• How agents handle ambiguous financial UI state (e.g. interpreting Pine Script output, reading indicator tables)

• Whether natural language is an effective interface for chart navigation and Pine Script development

• The failure modes of LLM agents operating in real-time data environments

This is not a trading bot. It is an interface layer that makes a trading application legible to an LLM agent, allowing researchers and developers to study human-AI collaboration in financial workflows.

See RESEARCH.md for open questions, findings, and related work.

Prerequisites

• TradingView Desktop app (paid subscription required for real-time data)

• Node.js 18+

• Claude Code with MCP support (for MCP tools) or any terminal (for CLI)

• macOS, Windows, or Linux

What It Does

Gives your AI assistant eyes and hands on your own chart:

• Pine Script development — write, inject, compile, debug, and iterate on scripts with AI assistance

• Chart navigation — change symbols, timeframes, zoom to dates, add/remove indicators

• Visual analysis — read your chart's indicator values, price levels, and annotations

• Draw on charts — trend lines, horizontal lines, rectangles, text annotations

• Manage alerts — create, list, and delete price alerts

• Replay practice — step through historical bars, practice entries/exits

• Screenshots — capture chart state for AI visual analysis

• Multi-pane layouts — set up 2x2, 3x1, etc. grids with different symbols per pane

• Place and manage orders — market/limit/stop/stop-limit with stop-loss and take-profit brackets, TIF, on any connected TradingView broker (native Paper or BlackBull)

• Order confirmation — verifies fills/resting orders/rejections against the broker's order history instead of trusting an empty placeOrder resolve, so rejections surface as actionable errors

• Monitor your chart — stream JSONL from your locally running chart for local monitoring scripts

• CLI access — every MCP tool is also a tv CLI command, pipe-friendly with JSON output

• Launch TradingView — auto-detect and launch with debug mode from any platform

Install with Claude Code

Paste this into Claude Code and it will handle the rest:

Install the TradingView MCP server. Clone https://github.com/ezydubs/tradingview-mcp.git, run npm install, add it to my MCP config at ~/.claude/.mcp.json, and launch TradingView with the debug port. Then verify the connection with tv_health_check.

Or follow the manual steps below.

Quick Start

1. Install

git clone https://github.com/ezydubs/tradingview-mcp.git
cd tradingview-mcp
npm install

2. Launch TradingView with CDP

TradingView Desktop must be running with Chrome DevTools Protocol enabled on port 9222.

Mac:

./scripts/launch_tv_debug_mac.sh

Windows:

scripts\launch_tv_debug.bat

Linux:

./scripts/launch_tv_debug_linux.sh

Or launch manually on any platform:

/path/to/TradingView --remote-debugging-port=9222

Or use the MCP tool (auto-detects your install):

"Use tv_launch to start TradingView in debug mode"

3. Add to Claude Code

Add to your Claude Code MCP config (~/.claude/.mcp.json or project .mcp.json):

{
  "mcpServers": {
    "tradingview": {
      "command": "node",
      "args": ["/path/to/tradingview-mcp/src/server.js"]
    }
  }
}

Replace /path/to/tradingview-mcp with your actual path.

4. Verify

Ask Claude: "Use tv_health_check to verify TradingView is connected"

CLI

Every MCP tool is also accessible as a tv CLI command. All output is JSON for piping with jq.

# Install globally (optional)
npm link

# Or run directly
node src/cli/index.js <command>

Quick Examples

tv status                          # check connection
tv quote                           # current price
tv symbol AAPL                     # change symbol
tv ohlcv --summary                 # price summary
tv screenshot -r chart             # capture chart
tv pine compile                    # compile Pine Script
tv pane layout 2x2                 # 4-chart grid
tv pane symbol 1 ES1!              # set pane symbol
tv stream quote | jq '.close'      # monitor price changes

All Commands

tv status / launch / state / symbol / timeframe / type / info / search
tv quote / ohlcv / values
tv data lines/labels/tables/boxes/strategy/trades/equity/depth/indicator
tv pine get/set/compile/analyze/check/save/new/open/list/errors/console
tv draw shape/list/get/remove/clear
tv alert list/create/delete
tv watchlist get/add
tv indicator add/remove/toggle/set/get
tv layout list/switch
tv pane list/layout/focus/symbol
tv tab list/new/close/switch
tv replay start/step/stop/status/autoplay/trade
tv stream quote/bars/values/lines/labels/tables/all
tv ui click/keyboard/hover/scroll/find/eval/type/panel/fullscreen/mouse
tv screenshot / discover / ui-state / range / scroll

Streaming

The tv stream commands poll your locally running TradingView Desktop instance at regular intervals via Chrome DevTools Protocol on localhost.

No connection is made to TradingView's servers. All data stays on your machine.

tv stream quote                          # price tick monitoring
tv stream bars                           # bar-by-bar updates
tv stream values                         # indicator value monitoring
tv stream lines --filter "NY Levels"     # price level monitoring
tv stream tables --filter Profiler       # table data monitoring
tv stream all                            # all panes at once (multi-symbol)

How Claude Knows Which Tool to Use

Claude reads CLAUDE.md automatically when working in this project. It contains a complete decision tree:

Tool Reference (97 MCP tools)

Chart Reading

Custom Indicator Data (Pine Drawings)

Read line.new(), label.new(), table.new(), box.new() output from any visible Pine indicator.

Always use study_filter to target a specific indicator: study_filter: "Profiler".

Chart Control

Multi-Pane Layouts

Tab Management

Pine Script Development

Replay Mode

Drawing, Alerts, UI Automation

Trading / Order Placement (any connected broker)

Place and manage real orders with any connected TradingView broker (native Paper or BlackBull cTrader). Mutations are fail-closed — they refuse to run unless a broker is actively connected (no more Paper-only gate). Evidence and paths: docs/PAPER_TRADING_DISCOVERY.md (native Paper) and docs/BLACKBULL_CTRADER_ORDER_API.md (BlackBull cTrader order-API validation surface).

How order placement was hardened. TradingView's placeOrder() broker call often resolves to an empty object (BlackBull's cTrader adapter delivers failures as UI toasts instead of throwing). Rather than trust that empty resolve, the adapter now:

• Snapshots the broker's order history before submitting, then polls for a new order on the same symbol/side and classifies it by status (filled/working = success; rejected/cancelled = rejection).

• Reads "Order rejected" toasts only to enrich the reason — never as the success/failure decision.

• Rejects orders that fail to confirm (market orders fail closed, resting orders surface a "verify with list_orders" note).

• Serializes concurrent submissions to avoid the parallel-place "phantom confirm" bug.

• Correctly parses account rows by on-screen label (not array index), handling broker-specific ordering and %-suffixed formatted strings.

• Adds margin_level and per-broker account summary fields.

CLI: tv paper status|panel|connect|account|accounts|switch-account|positions|orders|place|cancel|modify|close|brackets.

If the MCP/CLI points at the wrong Desktop instance, set TV_CDP_PORT (and optionally TV_CDP_HOST) to the process launched with --remote-debugging-port.

Context Management

Tools return compact output by default to minimize context usage. For a typical "analyze my chart" workflow, total context is ~5-10KB instead of ~80KB.

Finding TradingView on Your System

Launch scripts and tv_launch auto-detect TradingView. If auto-detection fails:

The key flag: --remote-debugging-port=9222

Testing

# Requires TradingView running with --remote-debugging-port=9222
npm test

29 tests covering: Pine Script static analysis, server-side compilation, and CLI routing.

Architecture

Claude Code  ←→  MCP Server (stdio)  ←→  CDP (port 9222)  ←→  TradingView Desktop (Electron)

• Transport: MCP over stdio (97 tools) + CLI (tv command, 31 commands with 67 subcommands)

• Connection: Chrome DevTools Protocol on localhost:9222

• Streaming: Poll-and-diff loop with deduplication, JSONL output to stdout

• No dependencies beyond @modelcontextprotocol/sdk and chrome-remote-interface

Attributions

This project is not affiliated with, endorsed by, or associated with:

• TradingView Inc. — TradingView is a trademark of TradingView Inc.

• Anthropic — Claude and Claude Code are trademarks of Anthropic, PBC.

This tool is an independent MCP server that connects to Claude Code via the standard MCP protocol. It does not contain or modify any Anthropic software.

Disclaimer

This project is provided for personal, educational, and research purposes only.

How this tool works: This tool uses Chrome DevTools Protocol (CDP), the standard debugging interface built into Chromium-based applications. It does not reverse engineer any proprietary TradingView protocol, connect to TradingView's servers, or bypass any access controls. The debug port must be explicitly enabled by the user via a standard Chromium command-line flag (--remote-debugging-port=9222).

By using this software, you acknowledge and agree that:

1. You are solely responsible for ensuring your use of this tool complies with TradingView's Terms of Use and all applicable laws.

2. TradingView's Terms of Use restrict automated data collection, scraping, and non-display usage of their platform and data. This tool uses Chrome DevTools Protocol to programmatically interact with the TradingView Desktop app, which may conflict with those terms.

3. You assume all risk associated with using this tool. The authors are not responsible for any account bans, suspensions, legal actions, or other consequences resulting from its use.

4. This tool must not be used for, including but not limited to:

   • Redistributing, reselling, or commercially exploiting TradingView's market data

   • Circumventing TradingView's access controls or subscription restrictions

   • Performing automated trading or algorithmic decision-making using extracted data

   • Violating the intellectual property rights of Pine Script indicator authors

   • Connecting to TradingView's servers or infrastructure (all access is via the locally running Desktop app)

5. The streaming functionality monitors your locally running TradingView Desktop instance only. It does not connect to TradingView's servers or extract data from TradingView's infrastructure.

6. Market data accessed through this tool remains subject to exchange and data provider licensing terms. Do not redistribute, store, or commercially exploit any data obtained through this tool.

7. This tool accesses internal, undocumented TradingView application interfaces that may change or break at any time without notice.

Use at your own risk. If you are unsure whether your intended use complies with TradingView's terms, do not use this tool.

License

MIT — see LICENSE for details.

The MIT license applies to the source code of this project only. It does not grant any rights to TradingView's software, data, trademarks, or intellectual property.