TradingView MCP lets an AI assistant such as Claude work with TradingView through the Model Context Protocol, and two different servers answer to the name. TradingView's official server, in public beta since 16 September 2026, signs in to your account and serves delayed quotes and bars, the screener, fundamentals, news, filings, calendars, watchlists and simple price alerts on Essential plans and up. A community server on GitHub drives the TradingView Desktop app on your own computer instead: it can compile Pine Script and read the Strategy Tester, and it is unofficial.
We use the community server daily, to compile Pine and to read Strategy Tester reports. We have not run the official one, because it needs Essential or higher and the account we test on is on the free plan. The official-server comparison comes from TradingView's own announcement and MCP docs, checked 2026-10-03. The first-connection check and watchlist exception below were rechecked against the docs on 2026-10-15; they are not a captured run of the official server.
If you'd rather have the assistant write a strategy than drive the chart, building a trading bot with ChatGPT or Claude covers the workflow and the silent bugs to audit before you trust it.
A simulated session, checked 2026-10-03 against TradingView's MCP docs (official) and the tradesdontlie/tradingview-mcp README and source (community). Tool names are the servers' own; the replies are our one-line summaries, not captured output.
Read as text
- Your AI client signs in to the official server at mcp.tradingview.com with OAuth 2.1. Access needs a TradingView plan of Essential or higher.
- It calls get_ohlcv and gets delayed bars, up to 5,000 per call. That is one of 25 read-only tools.
- It calls run_screener and gets screener results.
- It calls get_news and gets headlines: text the model reads, and text can carry instructions.
- It calls create_alert, a write tool, so you approve the call first. The official server has 10 write tools, and every one touches watchlists or alerts.
- The official server has no Pine, chart or Strategy Tester tools.
- For the community server, you start TradingView Desktop with --remote-debugging-port=9222, a debug port open on an app signed in to your account. The server runs on your machine and drives the app through that port.
- It calls tv_health_check. A connection alone does not confirm chart access. Require api_available and verify the intended chart symbol and timeframe before Pine edits.
- It calls pine_smart_compile in your Pine Editor and gets the script compiled, or the errors to fix.
- It calls data_get_strategy_results and reads the Strategy Tester: results, trade list, equity.
- The community server has no screener, news or fundamentals tools.
- Neither server lists a tool that places an order. Keep broker tools out of the same session.
What is TradingView MCP?
MCP, the Model Context Protocol, is an open standard for handing an AI assistant a set of tools. The server lists what it can do; the assistant decides when to call each one. TradingView's announcement compares it to a USB-C port.
- The official TradingView MCP Server is built and hosted by TradingView at
https://mcp.tradingview.com/mcp, and talks to TradingView's own backend once you sign in. The docs list setup for Claude on the web, desktop and mobile, Claude Code, ChatGPT, Codex and any client that speaks MCP over streamable HTTP with OAuth 2.1. - Community servers live on GitHub. The one we use is tradesdontlie/tradingview-mcp: MIT-licensed, about 6,700 stars on 2026-10-03, and not affiliated with TradingView, its README says. It drives the TradingView Desktop app on your machine through the Chrome DevTools Protocol, the debugging interface built into Electron apps.
Official vs community: what can each one do?
The official server is a research desk over TradingView's data, with no Pine, chart or Strategy Tester tools. The community server is the reverse: your chart and Pine Editor, but no screener, news or fundamentals tools. The split, as each project documents it:
| Official server | Community server | |
|---|---|---|
| Made by | TradingView | An independent developer, not affiliated with TradingView |
| Connects to | TradingView's servers, after an OAuth sign-in | TradingView Desktop on your machine, through debug port 9222 |
| Market data | Delayed. Up to 5,000 bars per get_ohlcv call | What your chart has loaded |
| Screener, fundamentals, news, filings, calendars | Yes | No tools for these |
| Watchlists | Read, create, edit, delete | Read and add symbols |
| Alerts | Simple price alerts only. No webhook or indicator alerts through MCP | Create, list and delete price alerts |
| Pine Script | No tools | Write, inject, compile, read errors, save |
| Strategy Tester | No tools | Reads results, trade list and equity |
| Chart control | No tools | Symbol, timeframe, indicators, drawings, replay, screenshots |
| Real orders | No order tool listed | README: does not execute real trades |
| Stability | Public beta. TradingView says the tool list is limited and some tools may not work smoothly yet | Uses undocumented internals that can break with any TradingView update |
On 2026-10-03 the official docs listed 35 tools, 25 marked read-only and 10 marked write; every write tool touches watchlists or alerts. The toolset will grow, TradingView says, so ask your assistant for the current list before you trust this table.
Which TradingView plan do you need for MCP?
The official server needs Essential or higher, and TradingView's docs say trial plans don't include MCP access. Essential is listed at $12.95 a month billed annually, marked as a special price on TradingView's pricing page (checked 2026-10-03). Tool calls are rate-limited to about 100 a minute per user, and during the beta TradingView says it may also cap requests per day.
The community README asks for a valid TradingView subscription plus the Desktop app, and notes that real-time data needs a paid plan. We run it on the free Basic plan, inside Basic's own limits, such as two indicators per chart. Basic's other limits, on open chart tabs, chart bars and alerts, and the plan that lifts each, are in TradingView limit reached.
How do you connect Claude to the official TradingView MCP server?
In Claude's apps, add https://mcp.tradingview.com/mcp as a custom connector and sign in to TradingView. In Claude Code, add it with one command and authorize it through /mcp.
For Claude on the web, desktop or mobile, Claude's custom connector guide gives these steps:
- Open Customize → Connectors. TradingView's docs call the same page Settings → Connectors.
- Click + Add, then Add custom connector.
- Name it, paste
https://mcp.tradingview.com/mcp, continue, and click Add. - Sign in to TradingView and approve access.
A free Claude plan allows one custom connector. On Team and Enterprise plans an owner adds the connector first, then members connect to it. The same help page notes that the connection runs from Anthropic's cloud, not from your computer.
For Claude Code, this is the command from TradingView's docs:
claude mcp add --transport http mcp-tradingview https://mcp.tradingview.com/mcp
Then run /mcp inside Claude Code and authorize your TradingView account in the browser. Codex users get their own line in the same docs: codex mcp add tradingview --url https://mcp.tradingview.com/mcp.
Verify the connection with one small read
Before asking for a market briefing, check that the assistant is using the intended server and returning identifiable data. This is a docs-based test prompt, not a transcript of a successful connection:
Use only the official TradingView server for this check.
List its available tool names, then call search_symbols with query "Apple".
Show the returned exchange-qualified symbols and let me choose one.
For my choice, call get_ohlcv with interval "1D", count 3, summary false.
Report the server and tool names, exact symbol, actual number of bars,
and first and last bar timestamps in UTC. If the call fails or returns
fewer bars, say so. Do not fill gaps or call watchlist or alert tools.
TradingView's current tool definitions specify these parameters and UTC timestamps. A successful response verifies that small request; it doesn't prove live data, complete history or Pine access. If you need Pine compilation and the official server has no Pine tools, that's the route's documented scope, not an installation failure.
How do you connect Claude to the community TradingView MCP server?
Install the server from GitHub, start TradingView Desktop with its debug port open, then register the server with Claude Code or Claude Desktop as a local command. You need Node.js 18 or newer and the TradingView Desktop app.
Install it. These are the README's three lines:
git clone https://github.com/tradesdontlie/tradingview-mcp.git
cd tradingview-mcp
npm install
Before launching, save your open scripts and layouts and finish other active TradingView sessions. The Windows launch helper forcibly closes existing TradingView.exe processes before relaunching the app with the debug port.
Launch TradingView with the debug port. The repo ships scripts\launch_tv_debug.bat for Windows, plus launch_tv_debug_mac.sh and launch_tv_debug_linux.sh. By hand, the flag is --remote-debugging-port=9222.
Register it with Claude Code. This is Claude Code's documented syntax for a local stdio server, pointed at the README's entry file:
claude mcp add --transport stdio tradingview -- node /absolute/path/to/tradingview-mcp/src/server.js
Or register it with Claude Desktop. Settings → Developer → Edit Config opens claude_desktop_config.json. Add the entry below with an absolute path, then quit and restart Claude Desktop, as the MCP docs describe:
{
"mcpServers": {
"tradingview": {
"command": "node",
"args": ["/absolute/path/to/tradingview-mcp/src/server.js"]
}
}
}
Check the intended chart. Ask the community server to run tv_health_check. Require cdp_connected: true and api_available: true, then compare chart_symbol and chart_resolution with the chart you intend to use. The server can return success: true and cdp_connected: true even when the chart API is unavailable and those chart fields are unknown. Stop on an error, unavailable API or mismatched chart before asking it to edit Pine. Pine compilation and strategy results still need their own checks.
The Windows launcher behavior and health-check return fields were checked in the community source on 2026-10-19, at commit c05b8f57. This is a source-based check, not a new live connection test.
Is TradingView MCP safe?
Start with a bounded data read, review tools that can change account state, and keep order execution out of the session. The community server adds a risk of its own: it needs a debug port open on an app that is signed in to your account.
Start read-only
TradingView marks tools read-only or write, but read the behavior as well as the label. Its current docs mark get_active_watchlist read-only while saying it can activate the first custom list if none is active, or create a default list if none exists. The starter deny list below includes that exception alongside the tools marked write.
In Claude Code you can deny those calls until you choose to allow them. Deny rules use the server name you chose, mcp-tradingview in the command above. Put this in .claude/settings.json:
{
"permissions": {
"deny": [
"mcp__mcp-tradingview__get_active_watchlist",
"mcp__mcp-tradingview__create_watchlist",
"mcp__mcp-tradingview__delete_watchlist",
"mcp__mcp-tradingview__add_to_watchlist",
"mcp__mcp-tradingview__remove_from_watchlist",
"mcp__mcp-tradingview__update_watchlist",
"mcp__mcp-tradingview__create_alert",
"mcp__mcp-tradingview__update_alert",
"mcp__mcp-tradingview__delete_alert",
"mcp__mcp-tradingview__stop_alerts",
"mcp__mcp-tradingview__restart_alerts"
]
}
}
In Claude's apps, switch off the tools you don't need for a conversation, and keep "Allow always" for tools you would let run unsupervised. Claude's connector guide gives the same advice. When the beta adds tools, review their descriptions and side effects as well as their labels.
Never hand an agent order execution
Neither server lists a tool that places a real order, and the community README states it does not execute real trades. Keep it that way: no broker MCP server in the same session, and no alerts wired into an execution bridge on an agent's say-so.
TradingView's own Terms of Use back this up. Section 3 licenses its data for display-only use and lists automated trading, automated order generation and algorithmic decision-making as prohibited non-display usage.
There is a second reason. Headlines, filings and transcripts are text the model reads, and text can carry instructions; Claude's connector guide warns about prompt injection. We made the longer case in You Gave an AI Agent the Keys.
Let the agent read the market. Keep the order ticket in your own hands.The community server's CDP risks
- The debug port is a door into an app signed in to your account, and the server needs it open. In March 2025, Google's Chrome team wrote that infostealers increasingly use Chrome's remote-debugging port to extract cookies, and that from Chrome 136 Chrome ignores the switch on its default profile. TradingView Desktop isn't Chrome, but it is an Electron app and the port is the same kind of interface. Open it when you work, close the app when you're done, and don't run it on a machine you don't trust.
- One tool runs arbitrary JavaScript. The server's own description of
ui_evaluateis "Execute JavaScript code in the TradingView page context". Whatever your agent can be talked into, that tool can do inside your signed-in app. - It depends on undocumented internals. The README warns that a TradingView update can break it at any time and suggests pinning your Desktop version.
- UI tools can overwrite work. On our install,
pine_newreplaced the text in the open editor tab instead of creating a new script. Save a copy of any script before an agent touches the Pine Editor, and run one agent per chart. - Compliance is on you. The README says programmatic use of TradingView data may conflict with TradingView's Terms of Use and that you alone are responsible. Our own Evolution Lab page says the same thing about automating your desktop app.
What is TradingView MCP actually good for?
The official server is good at research chores: briefings, screens saved to watchlists, earnings and macro prep, alert follow-ups, and pulling bars into code. The community server is good at Pine work: writing, compiling, fixing errors and reading the Strategy Tester without copy-paste.
TradingView's own examples include running a screen and saving the results as a watchlist, and asking which alerts fired and what price did next. Inside TradingView itself, the AI Screener turns a sentence into a screen. For code, get_ohlcv returns up to 5,000 bars per call. On one-minute bars that is under four days of a market that trades around the clock, and the data is delayed. That is plenty for research. It is not a feed to time entries from.
The community server earns its place in our lab. We use it to compile Pine, and to read Strategy Tester reports and per-bar indicator output when we check that a Pine tool and its web version agree. It removes copy-paste mistakes. It doesn't make a strategy any better. A connection changes what the model can reach, not whether the idea works.
If you're connecting an agent to work on Pine, give it real source to start from. Our Pine v6 tools ship as full .pine source with an AI kit (an AGENTS.md, Pine skills and prompt files), so your agent reads the actual code and its rules instead of guessing. It's a one-time purchase. The kit makes a tool readable and extendable; it doesn't make it profitable.
If you'd rather not hand-wire the community route, Pine Evolution Lab bundles an MIT-licensed copy of this bridge with a one-shot installer and works on the free TradingView plan. Your agent builds Pine strategy variants, runs each one through your own Strategy Tester, and files a verdict against its kill gates. The best verdict it gives is "promising, validate further", never "profitable", and its page flags desktop automation as a Terms of Use gray area, as above.
The deep version, as a PDF
TradingView Power-User Guide
The plan you actually need, Pine without the pain, alerts that fire, and backtests you can trust.
- Every plan's limits on one page, which plan each kind of trader needs, and how to fit more on the one you have
- Original research: two strategies, three Strategy Tester settings and two fill-order assumptions on a year of gold and Bitcoin, and how far each result moved
- Alerts and webhooks that fire when they should, with the full why-it-didn't checklist and a JSON template
One payment, instant download. Refund within 7 days if you haven't downloaded it.
Which TradingView MCP should you use?
Use the official server for data and research, the community server for Pine work, and neither one for orders.
- You want data, screens, research and alerts inside Claude, and you already pay for Essential or higher. Use the official server. It is TradingView's own route, and it never touches your chart.
- You write Pine and want the agent to compile it and read the tester. Use the community server, on a machine you control, and close the debug port when you're done.
- You want both. That works. Just never in a session that also holds a broker tool.
Sources, checked 2026-10-03: TradingView's MCP announcement, MCP docs, pricing and Terms of Use; the tradesdontlie/tradingview-mcp README; Claude's connector guide; Claude Code's MCP and permissions docs; and Chrome for Developers.
Use this animation on your site.



