Who tradingview-mcp is for#
Traders iterating on Pine Script indicators
Write a Pine Script indicator in natural language, have Claude inject it via `pine_set_source`, compile it with `pine_smart_compile`, read errors with `pine_get_errors`, and iterate in a single Claude Code conversation. The workflow removes the manual copy-paste cycle between the editor and a chat window.
Skip if:
Not suitable for automated trading systems or algorithmic execution. The project disclaimer explicitly prohibits using this tool for automated trading or algorithmic decision-making.
Developers researching LLM-trading interfaces
The repo includes RESEARCH.md documenting open questions around LLM latency in real-time data environments, failure modes with ambiguous UI state, and whether natural language is effective for chart navigation. The 29-test suite covers Pine Script static analysis and CLI routing. Architecture is documented: Claude Code to MCP to CDP to TradingView Desktop.
Skip if:
If you need a controlled, reproducible test environment, the dependency on a live TradingView Desktop session makes reproducible experiments harder to set up.
Traders setting up multi-chart monitoring
Set up a 2x2 or 3x1 grid with `pane_set_layout`, assign symbols to each pane with `pane_set_symbol`, and run `tv stream all` to monitor all panes simultaneously. Claude can read all panes' indicator values and act on conditions defined in natural language.
Skip if:
If you want portfolio-level analytics or cross-symbol correlation analysis, TradingView's native Pine Script and layout tools may handle those use cases more reliably without this layer.
Engineers building personal trading scripts
Every MCP tool is also a `tv` CLI command with JSON output. Pipe `tv stream quote | jq '.close'` into a shell script, batch actions across symbols with `batch_run`, or capture screenshots on a schedule with `tv screenshot`. No LLM is required for the CLI path.
Skip if:
Requires TradingView Desktop running locally. Does not work in headless server environments or CI pipelines.
The problem it solves#
TradingView's charting environment has no official automation API. Every Pine Script iteration, symbol change, and indicator reading is a manual step, so traders doing AI-assisted analysis must copy-paste chart data into a chat window, translate AI suggestions back into manual actions, and repeat the cycle each time the chart state changes.
For developers building personal trading workflows, the gap between what an LLM can reason about and what it can actually see and control is the core friction. A screenshot provides some visual context, but reading live indicator values, drawing price levels, or compiling and debugging Pine Script all require structured access to the chart's internal state that TradingView does not expose through a public API.
How it solves it#
AI-Assisted Pine Script Development
Write, inject, compile, and debug Pine Script through natural language in Claude Code. The pipeline runs `pine_set_source` to inject code, `pine_smart_compile` to compile with auto-detection, and `pine_get_errors` to read compilation errors, all in a single conversation. Scripts can be saved to TradingView cloud with `pine_save`.
84-Tool Chart Reading API
Read current indicator values, OHLCV data, Pine Script line/label/table/box output, and price levels through 84 structured MCP tools. Context usage is compact by default: a full chart analysis workflow uses roughly 5-10KB versus 80KB from a raw screenshot. Use `study_filter` to target a specific indicator instead of scanning all.
Programmatic Chart Navigation
Change symbols, timeframes, chart types, indicators, and scroll position through MCP calls. `chart_set_symbol` accepts standard tickers (BTCUSD, AAPL, ES1!, NYMEX:CL1!); `pane_set_layout` configures 2x2, 3x1, and other multi-pane grids; `chart_scroll_to_date` jumps to any ISO date. Indicators can be added, removed, toggled, and reconfigured programmatically.
Bar-by-Bar Replay with P&L Tracking
Enter historical replay at any date with `replay_start`, advance one bar at a time with `replay_step`, execute simulated buy/sell/close positions with `replay_trade`, and read current P&L and position with `replay_status`. Autoplay mode (`replay_autoplay`) advances bars at a configurable speed in milliseconds.
CLI Access with JSON Output
Every MCP tool has a matching `tv` CLI command with JSON output for piping with `jq`. Run `tv quote` for current price, `tv stream quote | jq '.close'` for price tick monitoring, or `tv pine compile` to compile a Pine Script from the command line. `npm link` installs `tv` globally.
Local Chart Stream via JSONL
`tv stream` polls your locally running TradingView Desktop at regular intervals via CDP and outputs JSONL to stdout. Monitor price ticks (`tv stream quote`), bar updates (`tv stream bars`), indicator values (`tv stream values`), or all panes at once (`tv stream all`). No connection is made to TradingView's servers.
Strengths and trade-offs#
Strengths
- Local-Only Data ProcessingAll chart data stays on your machine. The tool communicates only with the locally running TradingView Desktop instance via CDP on localhost:9222 and makes no external connections. For traders concerned about market data leaving their system, this architecture eliminates that risk by design.
- Context-Efficient by DesignTools return compact output by default to preserve LLM context. OHLCV summary mode sends statistics plus the last 5 bars instead of full history; Pine drawing tools return deduplicated price levels and text only; `study_filter` targets one indicator instead of all. A full chart analysis workflow uses 5-10KB of context versus 80KB from a raw screenshot.
- 6,400+ Stars with Active MaintenanceThe repo had 6,473 stars and 2,718 forks as of the research snapshot, with the last push in July 2026. That adoption level for a project under 18 months old reflects developer interest in the MCP-over-CDP pattern for financial tooling.
- Minimal Runtime DependenciesThe MCP server's only runtime dependencies are `@modelcontextprotocol/sdk` and `chrome-remote-interface`. No Redis, no Postgres, no container runtime. Install requires three commands: `git clone`, `cd`, and `npm install`.
Trade-offs
- -Breaks with TradingView Desktop UpdatesThe tool accesses undocumented internal TradingView APIs via the Electron debug interface. These can change without notice in any TradingView Desktop update, breaking tools that rely on specific internal state. The README explicitly recommends pinning your TradingView Desktop version if stability matters. This is a structural limitation; the tool has no access to stable, documented APIs.
- -Requires a Paid TradingView SubscriptionTradingView MCP Bridge requires TradingView Desktop installed and a valid paid subscription active. It does not bypass any paywall or access control. Teams looking for a self-hosted open source charting tool will need a different product; this one augments a paid subscription.
- -Terms of Use Compliance Is Your ResponsibilityTradingView's Terms of Use restrict automated data collection, scraping, and non-display usage of their platform. Using this tool to programmatically interact with TradingView Desktop may conflict with those terms depending on your use. The project's disclaimer explicitly places compliance responsibility on the user, including the risk of account suspension.
tradingview-mcp vs alternatives#
TradingView MCP Bridge vs TradingView (Native Interface)
TradingView is the commercial charting platform this bridge extends; the comparison is between using TradingView's native interface alone and using it augmented with an AI control layer via this MCP server.
| Feature | TradingView MCP Bridge | TradingView (Native) |
|---|---|---|
| Source license | MIT with trademark notices | Proprietary |
| Subscription required | Yes (TradingView paid plan) | Yes |
| Automation API | Via Chrome DevTools Protocol | None officially supported |
| Pine Script workflow | AI-assisted write, compile, debug | Manual editor |
| Trade execution | No | Yes (paper + live via brokers) |
| Mobile/web access | No (Desktop app only) | Yes |
| API stability | Undocumented internals | N/A |
TradingView MCP Bridge is the better choice for traders who spend significant time iterating on Pine Script indicators and want to delegate the write-compile-debug loop to Claude. The 84 MCP tools let you ask "analyze my chart and tell me what the Profiler shows" without reading each indicator manually. For multi-symbol setups, pane_set_layout and tv stream all enable monitoring workflows that require constant manual switching in the native UI.
TradingView's native interface is the better choice when you need trade execution through connected brokers, mobile charting, TradingView's social features (published scripts, shared layouts), or any workflow requiring API stability. This bridge accesses undocumented Electron internals and breaks with TradingView Desktop updates, making it unsuitable for production-critical workflows.
Quick start#
Install TradingView MCP Bridge by cloning the repo and running npm install, then register the server path in your Claude Code MCP config.
```bash
git clone https://github.com/tradesdontlie/tradingview-mcp.git
cd tradingview-mcp
npm install
```What it's built on#
- Languages
- JavaScript
FAQ#
Does this tool work without a TradingView subscription?
No. TradingView MCP Bridge requires TradingView Desktop installed with a valid subscription active for real-time data. It reads from and controls the locally running app; it does not bypass or replicate TradingView's data feed.
Does TradingView MCP Bridge connect to TradingView's servers?
No. The tool communicates only with your locally running TradingView Desktop instance via Chrome DevTools Protocol on localhost:9222. It makes no connection to TradingView's servers and transmits no data externally. The CDP debug port must be explicitly enabled by you with the --remote-debugging-port=9222 flag.
What license does TradingView MCP Bridge use?
The source code is released under MIT with trademark/affiliation notices. You can use, modify, distribute, sublicense, and sell copies with no restrictions beyond including the copyright notice. The additional notices clarify that the license covers only this project's code and grants no rights to TradingView or Anthropic trademarks. Your use of TradingView itself remains subject to TradingView's own Terms of Use.
Will this break when TradingView updates its app?
Possibly. The tool accesses undocumented internal TradingView APIs via the Electron debug interface, which can change without notice in any TradingView Desktop update. The README recommends pinning your TradingView Desktop version if stability matters. With 257 open issues on the repository, compatibility after TradingView updates is a recurring concern.
Can I use TradingView MCP Bridge for automated trading?
No. The project disclaimer explicitly prohibits using this tool for automated trading or algorithmic decision-making using extracted data. It is designed for personal workflow automation and research only. The tool also has no order execution capability; it reads charts and controls the UI but does not connect to brokers or send trade orders.
Similar open-source tools#
FckSignups
Open-source tools that work instantly, no signup required
rakazo
AI teammates you own: your keys, your model, your machine.
OpenSpec
Spec-driven development for AI coding assistants
cli
Official Lark/Feishu CLI with 200+ commands and AI Agent Skills
Multica
Assign GitHub issues to AI coding agents. They run on your machine.
opendisplay
Turn any iPhone, iPad, or spare Mac into a free second Mac monitor