TradingView MCP Bridge

Community

AI-assisted TradingView chart analysis and Pine Script development via Chrome DevTools Protocol

How to install ↓ Compare GitHub source repository ↗

Category: Other #124 of 230
Stars: ★ 6.9k Very popular
Transport: stdio (local process)
Runtime: Node.js 18+
Credentials: No credential needed
License: Other / unspecified
Last commit: 2 months ago
Tools: 62

53FMRS · D

An open-source, personal-use bridge that lets Claude and other AI assistants read and control a locally running TradingView Desktop chart via the standard Chrome DevTools Protocol — covering chart reading, Pine Script development, drawings/alerts, multi-pane layouts, and replay mode. It performs no real trade execution and never contacts TradingView's servers, but it depends on undocumented internal interfaces and places Terms-of-Use compliance risk on the user.

Strongest · Documentation 14/20 Weakest · Reliability 8/20

Reliability

8/20

Security and permissions

11/20

Maintenance

9/20

Documentation

14/20

Setup experience

11/20

Why each score

Reliability 8/20: The README claims 29 tests runnable via npm test, but no CI workflow evidence is present in the repository materials, and those tests themselves require a live, debug-enabled TradingView Desktop instance to run — they cannot be independently verified from static files. More notably, the documentation directly contradicts itself: one heading says 'Tool Reference (78 MCP tools)' while the Architecture section says 'MCP over stdio (84 tools)' — a mismatch indicating docs are out of sync with the actual tool count. The tool also operates via undocumented internal Electron/CDP interfaces, and the README itself warns these 'can change or break without notice in any TradingView update,' which is a self-disclosed reliability risk. Per the static calibration rule (unverifiable execution evidence caps this dimension below 12), combined with the internal inconsistency and uncontrolled external dependency, this is scored 8.
Security and permissions 11/20: The tool communicates only with a locally running TradingView Desktop instance over localhost:9222, stores no credentials, and makes no external network calls — genuine positives. However, several operations have real, potentially irreversible side effects with no described confirmation step: pine_save overwrites scripts saved to the TradingView cloud, alert_delete/draw_clear remove user data, and ui_evaluate offers general-purpose arbitrary JS execution inside the Electron renderer — a broad privilege surface with no documented scoping or confirmation gating. The README also candidly discloses that the tool's core function (programmatic chart data access) may violate TradingView's Terms of Use, risking account bans — an honest disclosure but not a technical mitigation. None of this rises to the malware/credential-theft/covert-exfiltration red-line bar, so no red-line is applied, but the clear gaps in least-privilege and confirmation handling justify a score of 11.
Maintenance 9/20: The project has a high star count (5,681) suggesting attention, but 199 open issues with no static evidence of triage speed or maintainer responsiveness. More critically, the repo metadata reports License: NOASSERTION while the README claims an MIT license backed by a LICENSE file — this contradiction suggests GitHub could not detect a properly formatted license text, a governance red flag. There is also no version number, changelog, or security-contact channel described anywhere in the README. Combined, the license inconsistency and missing governance signals yield a score of 9.
Documentation 14/20: Overall documentation is fairly comprehensive: it covers installation, per-platform launch scripts, a CLI-to-MCP-tool mapping table, a full categorized tool reference, a context-management strategy section, and a dedicated disclaimer/usage-limits section — above-average coverage. Deductions apply for the internal tool-count inconsistency (78 vs 84), the lack of parameter-level specs for individual tools (only one-line descriptions are given, not types/required fields/return shapes), and the fact that running the test suite requires a live TradingView connection without further troubleshooting guidance for that prerequisite. Usable but with notable detail gaps, so it is scored 14.
Setup experience 11/20: The setup path is reasonably clear: clone, npm install, launch TradingView with a debug flag (via provided Mac/Windows/Linux scripts or manually), add the MCP config, and verify with tv_health_check — plus a table of common install locations across platforms, which is a genuine plus. However, per the static calibration rule, setup cannot exceed 15 without verifiable, committed CI plus tests covering the key setup paths; here the test suite itself depends on a live, debug-enabled TradingView Desktop instance and there is no CI evidence, so it doesn't qualify as verifiable execution proof. The process also requires manually editing config file paths and deliberately opening a debug port that is disabled by default, against internal interfaces the authors admit can break at any time — a multi-step, somewhat fragile flow, warranting a score of 11.

Static review · not runListed 2026-08-26

Read the FMRS scoring method →

Fit and risk

What it can accessRuns commands or codeUses the networkControls a browser

Best for

Individual traders/researchers with a paid TradingView subscription who run TradingView Desktop
Developers who want AI assistance writing and debugging Pine Script
Researchers studying human-AI collaboration on professional financial interfaces
Claude Code users who want chart automation on their own machine

Not for

Use cases requiring TradingView's official APIs or cloud services
Automated trading bots or algorithmic order execution
Commercial redistribution or resale of TradingView market data
Users without a paid TradingView subscription or the Desktop app installed
Production environments needing a stable, officially supported API rather than an undocumented interface that can break on updates

Required permissions

Requires TradingView Desktop to be explicitly launched with `--remote-debugging-port=9222`, opening a local debug port
Requires Node.js 18+ and local filesystem access to clone and run the MCP server
Requires an active, logged-in TradingView subscription
The MCP server itself communicates with Claude Code over stdio and is not exposed to the network

Risks and side effects

Relies on undocumented internal TradingView Electron/CDP interfaces that can change or break without notice on updates
Opening the local debug port means other processes on the same machine could theoretically access it
Automated reading/processing of TradingView data may conflict with TradingView's Terms of Use restrictions on automated data collection — usage compliance is the user's responsibility
Not affiliated with or supported by TradingView Inc., so long-term compatibility is not guaranteed
The README explicitly warns against redistributing data or circumventing paywalls; misuse could risk account suspension

Setup

Before you start

Runtime：Node.js 18+

Make sure Node.js 18+ is installed and you have a valid TradingView subscription plus the Desktop app.
Clone the repo and install dependencies: git clone https://github.com/tradesdontlie/tradingview-mcp.git && cd tradingview-mcp && npm install.
Launch TradingView Desktop in debug mode using the platform launch script (Mac/Windows/Linux) or manually with --remote-debugging-port=9222, or ask the tv_launch tool to auto-detect and start it.
Add the server to your Claude Code MCP config (~/.claude/.mcp.json or a project .mcp.json) with command: node and args pointing at the local path to src/server.js.
Ask Claude to call tv_health_check to confirm the connection.

.mcp.json

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

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json

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

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal

claude mcp add tradingview -- node /path/to/tradingview-mcp/src/server.js

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Ask Claude: "Use tv_health_check to verify TradingView is connected" — the tool should appear in the client's tool list and confirm the CDP connection to the locally running TradingView Desktop on port 9222.

Troubleshooting

If the connection fails, confirm TradingView Desktop was launched via the platform script or with `--remote-debugging-port=9222`
Call `tv_health_check` or run `tv status` from the CLI to check connection status
Verify the `args` path in your Claude Code MCP config correctly points to the cloned `src/server.js`
Confirm Node.js is version 18 or newer
Check that port 9222 isn't blocked by a firewall or already in use by another process
If things break after a TradingView update, check whether its internal Electron structure changed and consider pinning an older TradingView version

Things to try

Once connected, you can ask your AI assistant things like:

What's on my chart right now? Summarize symbol, timeframe and indicator values.
Write a Pine Script that plots previous day high and low, compile it, and fix any errors.
Switch the chart to AAPL on the daily timeframe and take a screenshot.
Set up a 2x2 pane grid and set a different symbol on each pane.

Tools 62

chart_get_state read-only

Get the current symbol, timeframe, and names/IDs of all loaded indicators (recommended first call)

data_get_study_values read-only

Read current RSI, MACD, Bollinger Bands, EMA, etc. indicator values

quote_get read-only

Get the latest price, OHLC, and volume

data_get_ohlcv read-only

Get price bar data; use summary mode for compact stats

data_get_pine_lines read-only

Read horizontal price levels drawn by Pine indicators (support/resistance, session levels)

data_get_pine_labels read-only

Read text annotations and their prices from Pine indicators

data_get_pine_tables read-only

Read data tables produced by Pine indicators (session stats, analytics dashboards)

data_get_pine_boxes read-only

Read price zones/ranges drawn by Pine indicators

Show 54 more tools

chart_set_symbol writes

Change the chart ticker (e.g. BTCUSD, AAPL, ES1!)

chart_set_timeframe writes

Change the chart resolution (1, 5, 15, 60, D, W, M)

chart_set_type writes

Change chart style (Candles, HeikinAshi, Line, Area, Renko)

chart_manage_indicator writes

Add or remove indicators (use the full indicator name)

chart_scroll_to_date writes

Jump the chart to a given ISO date

chart_set_visible_range writes

Zoom to an exact visible range by unix timestamps

symbol_info read-only

Get symbol metadata

symbol_search read-only

Search for symbols

indicator_set_inputs writes

Change an indicator's input settings

indicator_toggle_visibility writes

Show or hide an indicator

pane_list read-only

List all panes with their symbols and active state

pane_set_layout writes

Change the pane grid layout (e.g. 2x2, 4, 6, 8)

pane_focus writes

Focus a specific pane by index

pane_set_symbol writes

Set the symbol on a given pane

tab_list read-only

List open chart tabs

tab_new writes

Open a new chart tab

tab_close destructive

Close a chart tab

tab_switch writes

Switch to a tab by index

pine_set_source writes

Inject Pine Script code into the editor

pine_smart_compile writes

Compile Pine Script with auto-detection and error checking

pine_get_errors read-only

Read Pine Script compilation errors

pine_get_console read-only

Read log.info() console output

pine_save writes

Save the current script to TradingView's cloud

pine_get_source read-only

Read the current script source (can exceed 200KB for complex scripts)

pine_new writes

Create a blank indicator/strategy/library script

pine_open writes

Open a saved script

pine_list_scripts read-only

List saved scripts

pine_analyze read-only

Run offline static analysis on Pine Script (no chart required)

pine_check read-only

Run a server-side compile check (no chart required)

replay_start writes

Enter replay mode at a given date

replay_step writes

Advance replay by one bar

replay_autoplay writes

Auto-advance replay at a configured speed

replay_trade writes

Buy/sell/close positions in replay mode

replay_status read-only

Check replay position, P&L, and date

replay_stop writes

Exit replay and return to realtime

draw_shape writes

Draw a horizontal line, trend line, rectangle, or text annotation

draw_list read-only

List existing drawings

draw_remove_one destructive

Remove a single drawing

draw_clear destructive

Clear all drawings

alert_create writes

Create a price alert

alert_list read-only

List existing alerts

alert_delete destructive

Delete an alert

capture_screenshot read-only

Capture the chart state (regions: full, chart, strategy_tester)

batch_run writes

Run an action across multiple symbols/timeframes

watchlist_get read-only

Read the watchlist

watchlist_add writes

Add a symbol to the watchlist

layout_list read-only

List saved layouts

layout_switch writes

Switch to a saved layout

ui_open_panel writes

Open a UI panel (UI automation)

ui_click writes

Simulate a click on a UI element

ui_evaluate writes

Evaluate a custom script in the page context

tv_launch writes

Auto-detect and launch TradingView Desktop in debug mode

tv_health_check read-only

Verify the connection to TradingView Desktop is working

tv_discover read-only

Discover available local TradingView instances/interfaces

Use cases

Have an AI assistant read and interpret current chart indicator values, price levels, and annotations

Write, inject, compile, and debug Pine Script indicators or strategies with Claude's help

Change symbols, timeframes, chart type, and indicators via natural language

Draw trend lines, horizontal lines, and rectangles on the chart, and manage price alerts

Set up multi-pane grid layouts to monitor several symbols at once

Practice entries/exits by stepping through historical bars in replay mode

Stream chart data as JSONL to local monitoring scripts

Supported clients

Claude Code

Listed from the project's documentation, not tested by this site.

Overview

TradingView MCP Bridge is a personal-use bridge that connects to a user's locally running TradingView Desktop application over the Chrome DevTools Protocol (CDP, port 9222), letting Claude Code and other AI assistants read chart state, indicator values, and Pine-drawn overlays, and control the chart (change symbol/timeframe, draw annotations, manage alerts, arrange multi-pane layouts, step through replay mode, etc.). All processing happens locally; the server never talks to TradingView's servers and does not bypass any paywall. It requires a valid TradingView subscription, an installed Desktop app, and the app to be manually launched in debug mode. It relies on undocumented internal TradingView interfaces that can break with app updates.

Similar servers

Hevy MCP 77 · B

Manage your Hevy workout data from AI assistants via MCP.

★ 517 · Tools 26 Compare with this →

Firecrawl MCP Server 75 · B

Firecrawl's official MCP server for web search, scraping, and structured extraction for AI agents

★ 7.6k · Tools 11 Compare with this →

BioMCP 75 · B

One binary. One grammar. Evidence from the biomedical sources you already trust.

★ 659 · Tools 11 Compare with this →

Compartment 75 · B

Encrypted, fully offline long-term memory for AI agents

★ 583 · Tools 14 Compare with this →

Compare with other MCP servers

Source revision c05b8f5755ed Data synced 2026-10-19 Read the FMRS scoring method