# TradingView Alerts MCP Server

**Create, list, pause, resume and delete TradingView alerts from Claude, Claude Desktop or Cursor.**

An [MCP (Model Context Protocol)](https://modelcontextprotocol.io) server for managing
TradingView alerts programmatically. Attach a Pine strategy to any symbol and timeframe,
wire it to a webhook for your trading bot, and pause or resume the whole set by asking
in plain language.

```
"Pause every BTC alert."
"Create an alert from my RSI strategy on BYBIT:ETHUSDT.P 15m, webhook to my bot."
"Which of my alerts are paused, and why did they stop?"
```

[![MCP](https://img.shields.io/badge/MCP-Model_Context_Protocol-blue)](https://modelcontextprotocol.io)
[![Node](https://img.shields.io/badge/node-%3E%3D20-green)](https://nodejs.org)
[![Tests](https://img.shields.io/badge/tests-58_passing-brightgreen)](#development)
[![License](https://img.shields.io/badge/license-MIT-lightgrey)](LICENSE)

---

> [!WARNING]
> **This server authenticates with your live TradingView session cookies**, which grant
> full access to your account. Never commit `auth.json`, never paste your cookies into a
> shared config, and never publish them. `auth.json` and `.env` are gitignored here.
> `delete_alerts` is permanent and cannot be undone.

## Contents

- [What this does](#what-this-does)
- [Quick start](#quick-start)
- [Getting your session cookies](#getting-your-session-cookies)
- [Install in Claude Code](#install-in-claude-code)
- [Install in Claude Desktop](#install-in-claude-desktop)
- [Install in Cursor](#install-in-cursor)
- [Tools](#tools)
- [Example prompts](#example-prompts)
- [The TradingView alerts API](#the-tradingview-alerts-api)
- [Gotchas worth knowing](#gotchas-worth-knowing)
- [FAQ](#faq)
- [Development](#development)

## What this does

TradingView has no public API for alerts. Everything has to go through the web UI, which
makes managing more than a handful of strategy alerts tedious and impossible to automate.

This server exposes the full alert lifecycle as MCP tools:

- **Create** an alert from any Pine strategy saved on your account, on any symbol and
  timeframe, with an optional webhook URL
- **List** every alert with its status, symbol, timeframe and webhook
- **Pause** and **resume** alerts individually or in bulk, by symbol or by name
- **Delete** alerts permanently
- **Inspect** firing history and the reason an alert stopped on its own

Creating a strategy alert correctly is the hard part, and it is handled for you: the
symbol and its `currency-id` are resolved from TradingView's own search, and the
strategy's default input values are read from its compiled metadata, so the alert
actually fires.

## Quick start

```bash
git clone https://github.com/daviddme/tradingview-alerts-mcp-server.git
cd tradingview-alerts-mcp-server
npm install
```

Requires **Node.js 20 or newer**. Then add your credentials and register it with a
client below.

## Getting your session cookies

TradingView has no alert API key. Authentication is a logged-in browser session, so the
server replays four cookies.

1. Log in to [tradingview.com](https://www.tradingview.com) in your browser
2. Open DevTools (`F12` or `Cmd+Option+I`)
3. Go to **Application** → **Storage** → **Cookies** → `https://www.tradingview.com`
4. Copy the values of these four cookies:

| Cookie | What it is |
|---|---|
| `sessionid` | Your session token |
| `sessionid_sign` | Signature for the session token |
| `device_t` | Device token |
| `tv_ecuid` | Client id |

You also need your **TradingView username** exactly as it appears on your profile.

Supply them either as environment variables in your MCP client config (recommended), or
by copying `auth.example.json` to `auth.json` and filling it in.

Cookies expire, and logging in on another device can invalidate them. When that happens
every tool returns a clear "session rejected" error telling you to refresh them. Run
`check_auth` to test at any time.

## Install in Claude Code

```bash
claude mcp add tradingview-alerts -s user \
  -e TV_USERNAME=YourUsername \
  -e TV_SESSIONID=... \
  -e TV_SESSIONID_SIGN=... \
  -e TV_DEVICE_T=... \
  -e TV_ECUID=... \
  -- node "$(pwd)/src/server.js"
```

## Install in Claude Desktop

Edit `claude_desktop_config.json`:

- **macOS** — `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows** — `%APPDATA%\Claude\claude_desktop_config.json`

```json
{
  "mcpServers": {
    "tradingview-alerts": {
      "command": "/absolute/path/to/node",
      "args": ["/absolute/path/to/tradingview-alerts-mcp-server/src/server.js"],
      "env": {
        "TV_USERNAME": "YourUsername",
        "TV_SESSIONID": "your-sessionid-cookie",
        "TV_SESSIONID_SIGN": "your-sessionid_sign-cookie",
        "TV_DEVICE_T": "your-device_t-cookie",
        "TV_ECUID": "your-tv_ecuid-cookie"
      }
    }
  }
}
```

> **Use the absolute path to `node`.** Desktop apps do not inherit your shell `PATH`, so
> a bare `"node"` fails with `spawn node ENOENT`. Find yours with `which node`.

Restart Claude Desktop.

## Install in Cursor

Same block as above in `~/.cursor/mcp.json`, then restart Cursor.

## Tools

| Tool | What it does |
|---|---|
| `list_alerts` | Every alert with status, symbol, timeframe and `alert_id`. Start here |
| `create_strategy_alert` | New alert from a saved Pine strategy, with optional webhook |
| `pause_alerts` | Stop alerts firing, keeping them on the account |
| `resume_alerts` | Reactivate paused alerts |
| `delete_alerts` | Permanently delete alerts |
| `list_saved_strategies` | Your saved Pine scripts, flagging which are strategies |
| `list_alert_fires` | Firing history |
| `resolve_symbol` | Resolve `EXCHANGE:TICKER` to its canonical symbol and `currency-id` |
| `check_auth` | Verify the session works and report alert counts |

`pause_alerts`, `resume_alerts` and `delete_alerts` all target alerts the same way:
explicit `alert_ids`, or a `symbol` / `name` / `status` filter. They refuse to run with
no target at all rather than acting on everything, and error if a filter matches nothing
rather than silently doing nothing.

## Example prompts

> "List my TradingView alerts and tell me which are paused."

> "Create an alert from my 'RSI Breakout' strategy on BYBIT:BTCUSDT.P at 60m, and send
> it to https://my-bot.example.com/webhook"

> "Pause everything on RUNEUSDT, I'm done trading it for today."

> "Resume all my paused alerts."

> "Delete every alert with 'test' in the name."

> "My ETH alert stopped firing. What happened?" (reads `last_stop_reason`)

## The TradingView alerts API

Undocumented and private. The endpoint names below were confirmed empirically: the API
answers `unauthorized` for endpoints that exist and `no_such_endpoint` for ones that do
not, which cleanly separates real endpoints from guesses.

All live on `https://pricealerts.tradingview.com`:

| Endpoint | Purpose |
|---|---|
| `list_alerts` | List all alerts |
| `create_alert` | Create |
| `stop_alerts` | **Pause** (takes `alert_ids[]`) |
| `restart_alerts` | **Resume** (takes `alert_ids[]`) |
| `delete_alerts` | Delete (takes `alert_ids[]`) |
| `list_fires` | Firing history |

Endpoints that do **not** exist, despite being plausible: `modify_alert`, `edit_alert`,
`pause_alerts`, `resume_alerts`, `deactivate_alerts`, and every singular variant such as
`stop_alert`.

Creating a strategy alert is a four-step chain:

1. `symbol-search/v3` resolves the symbol and its `currency-id`
2. `pine-facade/list?filter=saved` finds the script's `pine_id` and version
3. `pine-facade/translate/<id>/<version>` returns the compiled metadata containing the
   script's default input values
4. `create_alert` posts a `type: "strategy"` condition wrapping
   `StrategyScript@tv-scripting-101`

## Gotchas worth knowing

Each of these cost real debugging time and is handled by this server.

**There is no modify endpoint.** Editing an alert means deleting it and creating a
replacement. The alert gets a new `alert_id`.

**Activation is asynchronous.** `create_alert` returns `active: false`, and TradingView
flips the alert to active a second or two later. The same applies to `stop_alerts` and
`restart_alerts`. Reading the response directly tells you the wrong thing, so every
state-changing tool here polls until the state settles and reports `confirmed`.

**Strategy inputs are not positional in the way they look.** The alert payload wants an
`in_0`, `in_1`, … map, and `metaInfo.inputs` is an array, so it is tempting to walk that
array by index. That is wrong: the array starts with four hidden internal entries
(`text`, `pineId`, `pineVersion`, `pineFeatures`), so index 0 is the compiled script
blob, not `in_0`. Use `metaInfo.defaults.inputs`, which is already keyed correctly.
An alert built the wrong way is accepted by the API and then **never fires**, with no
error anywhere.

**The useful metadata is nested at `result.metaInfo`**, not `metaInfo`.

**`symbol` is a JSON document inside a string**, prefixed with `=`. This server parses it
so you get a plain `"BYBIT:BTCUSDT.P"` back.

**`user_id` is not required** by `list_alerts`, despite the web app always sending it.
The session cookie identifies the account.

**`last_stop_reason` explains self-stopping alerts**, with values like
`pro_plan_expired` or `auto`. Worth checking when an alert goes quiet.

## FAQ

### Do I need a paid TradingView plan?

To *use* strategy alerts, yes. TradingView limits how many alerts each plan allows, and
strategy alerts need a paid tier. This server surfaces `last_stop_reason:
"pro_plan_expired"` when a plan lapse is what stopped an alert.

### Is this an official TradingView API?

No. TradingView publishes no alerts API. This drives the same private endpoints the web
app uses, which means they can change without notice. Not affiliated with TradingView.

### Will this get my account banned?

It makes the same requests the TradingView web app makes, as your own logged-in user, at
a far lower rate than clicking through the UI. That said, you are using a private API,
which is your own decision and risk. See [NOTICE.md](NOTICE.md).

### Can it create simple price alerts, not just strategy alerts?

Not yet. This server covers Pine **strategy** alerts, which is the automation-heavy case.
Price alerts use a different condition shape. Contributions welcome.

### Why does my new alert say it is not active?

Activation is asynchronous. The tool polls for a couple of seconds and reports
`activation: "confirmed active"` when it settles. If it reports otherwise, run
`list_alerts` again or call `resume_alerts` to force it.

### My alert was created but never fires. Why?

Almost always wrong strategy inputs. This server reads inputs from the script's own
compiled defaults to avoid exactly that, and reports `inputs_applied` so you can check
the count looks right. Zero applied inputs means something went wrong.

### How do I change an alert's settings?

Delete it and create a new one. TradingView has no modify endpoint.

### Where are my credentials stored?

Wherever you put them: environment variables in your MCP client config, or a local
`auth.json` that is gitignored. This server never transmits them anywhere except
TradingView.

## Development

```bash
npm test
```

58 tests, fully offline. The alerts API is stubbed in-memory, so the suite never touches
a real account.

```bash
npm run smoke -- --strategy "Your Strategy Name" --symbol BYBIT:BTCUSDT.P
```

Live end-to-end test against your real account. It creates one alert, verifies it,
pauses it, resumes it, then deletes it, checking state at every step. It only ever
touches the alert it created, verifies your existing alerts are untouched, and cleans up
in a `finally` block even if a step fails.

### Project layout

| File | Responsibility |
|---|---|
| `src/server.js` | MCP wiring and tool definitions |
| `src/tools.js` | Tool implementations, targeting and state confirmation |
| `src/alerts.js` | The six lifecycle operations and payload construction |
| `src/pine.js` | Saved script lookup and strategy input extraction |
| `src/symbols.js` | Symbol and currency-id resolution |
| `src/format.js` | Normalising raw alert objects |
| `src/http.js` | Request handling and error mapping |
| `src/config.js` | Credential loading |

## License

MIT. See [LICENSE](LICENSE) and [NOTICE.md](NOTICE.md).

---

**Keywords:** TradingView alerts MCP server, TradingView MCP, TradingView alert API,
Model Context Protocol TradingView, Pine Script alerts automation, TradingView webhook
automation, create TradingView alerts programmatically, pause resume TradingView alerts,
Claude TradingView alerts, Cursor TradingView MCP, trading bot webhook alerts.