tradingview-mcp: market data and technical analysis for MCP clients

What tradingview-mcp actually solves

An AI assistant asked about a ticker will usually answer from memory, and memory has a cutoff. The gap this project fills is the one between a chat client and a live quote, a screener result, or an indicator reading. The README frames it as real-time market data, technical indicators, screeners and backtesting exposed as MCP tools, covering stocks, crypto, forex and futures across global exchanges.

The intended user is someone already living inside an MCP-capable client: Claude, ChatGPT, Cursor, Copilot, or anything else speaking the protocol. The README's own opening examples are a good sketch of the shape: ask for today's top crypto gainers on Binance, run a full technical analysis of NVDA, request a multi-timeframe read on gold, or backtest an RSI strategy on BTC on the daily timeframe. Those are research questions, not execution instructions.

One design decision deserves attention early. The server does not log into TradingView, does not scrape it, and does not automate a browser session. It requires no TradingView account and no TradingView API key. Data is fetched server-side from public endpoints. That is why it works from a hosted URL when your laptop is closed, and it is also why it is a different product from the MCP servers that remote-control TradingView Desktop. The README is explicit that the project is independent and not affiliated with TradingView Inc.

The architecture: one Python server, two transports

The repository is a Python package named tradingview-mcp-server, version 0.9.0, declared for Python >=3.10,<3.14. The Dockerfile builds in two stages with python:3.11-slim, installs dependencies through uv with `uv pip install --system .`, copies site-packages and the tradingview-mcp entry point into a second stage, creates a non-root mcpuser, and exposes port 8000. The container entrypoint runs the server over streamable-http, bound to 0.0.0.0 on port 8000, with a health check hitting http://localhost:8000/health every 30 seconds.

That gives two deployment shapes. Locally, the server runs as a stdio process that an MCP client launches. Remotely, it runs as an HTTP service that a client connects to by URL, which is what the hosted version at pro.cryptosieve.com does. The docker-compose.yml publishes container port 8000 on host port 8080 and sets PORT and HOST as environment variables.

The dependency block in pyproject.toml is unusually candid about version boundaries, and it is worth reading before you pin anything. The MCP SDK is constrained to >=1.14.0,<2. The comment explains why the lower bound is not 1.12.0: server.py uses `from __future__ import annotations`, so annotations reach FastMCP as strings, and Tool.from_function in 1.13.x and earlier calls issubclass on that string and raises a TypeError at import time, which fails every tool registration and stops the server from starting. The upper bound excludes 2.x because that release removed the mcp.server.fastmcp module the server imports. The comment also notes that a Docker rebuild with `uv pip install --system .` ignores uv.lock, so an open range would break fresh installs. Moving to the 2.x SDK is described as a deliberate migration, not a drive-by resolve. That is a maintenance signal, and a reminder that the lockfile is not the whole story in the container path.

Installing tradingview-mcp and running a first request

The README offers two routes and states that self-hosting stays free forever. The hosted version, TradingMCP, is a connector URL you add and sign in to in Claude, Cursor or Grok, while ChatGPT, Copilot and other MCP clients connect with a private link; it is priced from $9/mo for Pro or $29/mo for Pro+ with higher limits, with a 14-day money-back guarantee. The self-hosted route is a package install or a container. The README mentions `pip install` and the package is published on PyPI as tradingview-mcp-server.

For a container deployment, the compose file in the repository is the shortest path. It builds the local Dockerfile, tags the image as ghcr.io/atilaahmettaner/tradingview-mcp:latest, and maps host port 8080 to container port 8000. Note the comment in that file: CI publishes to GHCR, and the older Docker Hub image atilaahmet/tradingview-mcp is not what CI builds.

services:
  tradingview-mcp:
    build: .
    image: ghcr.io/atilaahmettaner/tradingview-mcp:latest
    container_name: tradingview-mcp
    ports:
      - "8080:8000"
    restart: unless-stopped
    environment:
      - PORT=8000
      - HOST=0.0.0.0

After `docker compose up`, the health endpoint the Dockerfile probes should answer on the mapped port. The container runs the entrypoint with streamable-http on 0.0.0.0:8000, so an MCP client is pointed at the HTTP URL rather than launched as a subprocess.

Two configuration files matter. The repository ships .env.example, which you copy to .env before filling in values; .env is in .gitignore. The optional news tools use the licensed Marketaux API, and without a token the README says those tools return empty results while every other tool works normally. There is also a daily request budget key.

cp .env.example .env

MARKETAUX_API_TOKEN=your_marketaux_token_here
MARKETAUX_DAILY_BUDGET=90

The second optional block is a rotating residential proxy, used to reach Yahoo Finance and Xueqiu behind rate limits. The example file sets PROXY_ENABLED=true along with host, port, username prefix, password and session bounds, and notes that TradingView tools work fine without it. If you do not have proxy credentials, set PROXY_ENABLED to false rather than leaving placeholder values in place.

Once the server is reachable, the first real use is a plain sentence in the chat client. The README suggests asking for today's top crypto gainers on Binance, or a full technical analysis of NVDA. The expected result is a ranked table or an analysis returned in the conversation, computed from live data rather than model memory.

Where tradingview-mcp stops working

The hosted tier draws charts. The README states that the hosted server renders an interactive candlestick view inside the conversation through MCP Apps, at 1d, 1h or 15m, with an optional Bollinger overlay, and that the assistant reads the band values back. That capability is described as belonging to the hosted server, so a self-hosted instance should not be expected to reproduce it. If in-conversation charting is the reason you are interested, the self-hosted path is the wrong one.

Coverage is another boundary. The server consumes third-party public endpoints. The README warns that market data may be delayed, inaccurate or incomplete and is provided without warranty, and that you are responsible for complying with the terms of any data source you point it at. There is no exchange-private data here, no order book you are entitled to, and no execution. The disclaimer is blunt that the software does not execute trades or manage money.

News and sentiment are conditional. The RSS and Reddit scraping the project previously used was replaced by the licensed Marketaux API, and without a token the news-driven tools return empty results. A daily budget key caps requests before cached or stub results are served, which means a heavy news workflow can degrade to stale output rather than fail loudly.

Finally, the proxy dependency is a real operational cost for anyone who wants Yahoo Finance or Xueqiu data at volume. The example configuration points at a commercial rotating residential proxy service. That is not a free, set-and-forget component.

tradingview-mcp versus desktop-automation MCPs

The README draws the comparison itself, and it is the clearest way to decide. The other family of projects, which it calls desktop-automation MCPs, drives the TradingView Desktop application, typically through Chrome DevTools, and usually requires a paid TradingView plan. It names tradesdontlie/tradingview-mcp as an example of that approach.

The difference is not quality, it is what each one can reach. Desktop automation operates your logged-in TradingView session, so it can edit Pine Script, draw on charts and use replay, and it inherits whatever the TradingView UI offers, including its screeners. The cost is that it mostly runs on your own machine under Claude Code, and it stops when the machine is off. This project is headless: it needs nothing installed on the client side beyond an MCP connection, answers from a hosted URL around the clock, and ships its own screeners and backtesting. What it cannot do is touch your charts, your drawings or your saved scripts.

There is a practical consequence worth stating plainly. If your work is authoring or debugging Pine Script, the desktop-automation route is the one that matches the job, because this server has no path into the TradingView editor. If your work is asking an assistant what the RSI on a 15-minute chart is, or which coins are up most today, or whether a simple strategy held up historically, the headless route answers without a subscription to TradingView or a running desktop app.

Maintenance, licensing and upgrade cost

The last push to the repository was on 2026-10-29, and the repository is not archived. The package version in pyproject.toml is 0.9.0, and the repository has no published releases, so version history has to be read from the changelog and the file itself. A pre-1.0 version number is a reasonable expectation-setter: interfaces can move.

The upgrade cost is concentrated in one place, and the pyproject comments make it visible. The MCP SDK range is deliberately narrow, and the maintainer states that moving to the 2.x SDK means renaming FastMCP to MCPServer, which is a migration rather than a version bump. Until that happens, installs that ignore the declared range will fail at import: with SDK 1.13.x or earlier through a TypeError during tool registration, with 2.x because it removed the mcp.server.fastmcp module. If you build from the Dockerfile, remember that `uv pip install --system .` does not consult uv.lock, so the declared bounds in pyproject.toml are your only protection on a rebuild.

The licence is MIT, stated in the README badge, the pyproject classifier and the LICENSE file. MIT permits commercial use and modification with the copyright notice retained; it also means no warranty, which lines up with the disclaimer in the README. The hosted service is a separate commercial offering at pro.cryptosieve.com with its own terms, and paying for it is not the same as licensing the code. Nothing here is legal advice, and if you redistribute the server inside a product, read the LICENSE file rather than the badge.

Editorial conclusion

Adopt it if you want screener output, indicator values and backtests available inside a chat client without running TradingView Desktop or handing over an account. Skip it if you need order execution, exchange-private data, or chart drawing on your own TradingView session; this server does none of that. Before wiring it into a workflow, check three things: that your Python is in the 3.10 to 3.13 range the package declares, whether you are pointing at the hosted connector or a local streamable-http instance on port 8000, and whether the news tools matter to you, because without a Marketaux token the README says they return empty results while every other tool keeps working.

Frequently asked questions

Official sources

1. atilaahmettaner/tradingview-mcp on GitHub
2. Issues
3. License: MIT
4. Project website
5. README