7 Free Claude Skills for Trading (Copy, Paste and Control TradingView)

By Mind Math Money | Last updated: November 18, 2026

Claude Skills for trading are saved instructions that make Claude run the same trading task the same way every time. This page gives you 7 free Claude Skills that control the TradingView desktop app. They build a watchlist, screen a whole stock market, set up a chart, write a morning brief, scan for candlestick patterns and volume spikes, and turn a trade plan into price alerts.

You copy a skill, paste it into Claude and save it. No coding. These are the seven skills from my Claude Skills course, and I tested every one of them in my own TradingView.

Key Takeaways

  • A Claude Skill is a saved set of instructions. You install it once, then run it with one sentence

  • All 7 skills on this page are free, and each one sits in a box with a Copy button

  • The skills follow one workflow: Find, Prepare, Scan, Act

  • Every skill uses fixed rules with exact numbers, so the result is consistent and easy to check

  • The skills report facts, not signals. They never say buy or sell, and they never place a trade

What Is a Claude Skill?

A Claude Skill is a text file with a name, a description and step-by-step instructions that Claude follows the same way every time. The description tells Claude when to use the skill. The steps hold the exact rules, the numbers and the report format.

That is the difference between a skill and a normal prompt. A prompt has to be typed again every time, and a small change in wording can change the answer. A skill is installed once. After that, one short sentence starts the whole task.

Anthropic, the company behind Claude, explains the feature in its help center guide to using Skills in Claude.

The skills on this page do more than write text. They control the TradingView desktop app through the TradingView MCP, a free open-source bridge between Claude and TradingView. MCP stands for Model Context Protocol, the standard that lets Claude work with other apps.

What You Need Before You Start

You need three things before any of the skills can run: the Claude desktop app with Skills turned on, the TradingView desktop app, and the connection between the two.

  • The Claude desktop app with Skills turned on. Skills are available on every Claude plan, including the free one. They need the setting called "Code execution and file creation" to be on. You find it in Settings, under Capabilities. In the newer layout the same setting is called "Create and edit files".

  • The TradingView desktop app. The browser version does not work for this. My install guide asks for a paid TradingView plan, and the cheapest tier works. If you do not have TradingView yet, you get a $15 bonus and 30 days of free Premium through my link.

  • The Claude and TradingView connection. My step-by-step guide on how to connect Claude to TradingView walks you through the install with one copy-paste prompt. I also show the full setup in my AI Trading course on YouTube.

One thing to know before you start. The TradingView MCP is an independent open-source project. It is not made by TradingView or Anthropic, and a TradingView update can break it for a while.

How to Install a Claude Skill

Installing a Claude Skill from this page takes four steps.

  1. Click Copy Skill on one of the skill boxes below

  2. Paste it into a new chat in Claude and type: Save this as a skill, exactly as written.

  3. Click Save on the card that Claude shows

  4. Run it by naming it, for example: Use the Morning Brief Skill.

Naming the skill in your request is the reliable way to start it. Claude can also pick a skill on its own when your request matches the description of the skill.

If Claude does not show a Save card, use the ZIP backup. Download the skill pack below and unzip it. Inside you find one small ZIP file per skill. In Claude, go to Customize, then Skills. Click the "+" button, choose "Create skill", then "Upload a skill", and pick one of the small ZIP files.

The 7 Claude Skills for Trading: Find, Prepare, Scan, Act

The seven skills follow the order of a trading routine, and the later skills use what the earlier ones create.

  • Find: Watchlist Builder and Stock Picker create your list

  • Prepare: Chart Setup and Morning Brief get you ready for the day

  • Scan: Candlestick Scanner and Volume Spike Scanner look for setups

  • Act: Alert Setter turns your trade plan into alerts

Start with Skill 1. The Morning Brief and both scanners read the watchlist that is open in TradingView.

Skill 1: Watchlist Builder

The Watchlist Builder turns a short request into a real watchlist inside your TradingView app. You give it four inputs: Market, Style, Theme and Size. An example is US stocks, swing trading, AI, 15 symbols.

Claude ranks the candidates first, then checks every symbol on TradingView before it goes on the list. It shows you the list and waits for a yes. Only then does it create a new watchlist and read it back to confirm what was added.

The cap is 20 symbols, and your existing watchlists are never changed.

📋 Skill 1: Watchlist Builder

Copy it, paste it into Claude and say: Save this as a skill, exactly as written.

Show the full skill (153 lines)
---
name: "tradingview-watchlist-builder"
description: "Builds a new TradingView watchlist from a short request (market, style, theme, size) using the TradingView MCP. Use for any request to build or create a watchlist or a list of symbols to watch."
---

# TradingView Watchlist Builder

Turn a short request like "US stocks, swing trading, AI theme, 15 symbols" into a real watchlist inside the user's TradingView app.

The result is a new, clearly named watchlist. The user's existing watchlists are never changed.

## What you need

- The TradingView desktop app, open, with the TradingView MCP connected.
- These tools: `tv_health_check`, `symbol_search`, `ui_open_panel`, `ui_evaluate`, `ui_type_text`, `ui_keyboard`, `watchlist_get`, `watchlist_add_bulk`, `watchlist_remove`.

Tool names can carry a prefix that depends on the setup (for example `mcp__tradingview__watchlist_get`). Match on the last part of the name.

Start with `tv_health_check`. If it fails, tell the user to open TradingView with the MCP connected, and stop. Nothing else in this skill works without it.

## Step 1: Get the four inputs

| Input | Meaning | If missing |
|---|---|---|
| Market | For example US stocks, Indian stocks, crypto, forex | Ask |
| Style | Day trading, swing trading or long-term investing | Ask |
| Theme | Anything: AI, dividends, large caps, a sector | Use "the most liquid names in that market" |
| Size | How many symbols | 15 |

Size is at least 5 and at most 20. If the user asks for more than 20, say that 20 is the cap and why: the other skills in this pack read every chart on the list, so long lists get slow and expensive.

Ask for everything that is missing in one message. Do not ask for anything the user already gave.

**If the user already has the symbols** (for example a result from the Stock Picker skill, or their own list), skip Step 2. Keep their order, check each symbol with Step 3, and continue from Step 4. Symbols that came straight from TradingView's screener in this conversation, with their full name like `NASDAQ:AAPL`, count as checked. The 20 symbol cap still applies.

## Step 2: Pick and rank the candidates

Make a ranked list, best fit first, about twice as long as the size. Use your own knowledge. If you have a web search tool and the theme depends on recent events, search to check that the names are current.

Selection rules:

- **Day trading:** only the most actively traded names in that market.
- **Swing trading:** liquid names that tend to trend and move.
- **Long-term investing:** large, established companies and broad funds.
- Use the main listing in the user's market. Skip depositary receipts, leveraged funds, inverse funds and penny stocks unless the user asks for them.
- For crypto, use one pair per coin against USD or USDT, all from one large exchange.

Write one short reason for each candidate (8 words or fewer).

Fix the ranking before you check anything on TradingView, so the final list depends on fit, not on search order.

## Step 3: Check each symbol on TradingView

Go down the ranking and run `symbol_search` for each candidate (the ticker as `query`, plus the `type` filter such as `stock` or `crypto`). Stop as soon as you have enough checked symbols to fill the size.

In the results, find the entry that is the same company or asset on the right exchange and keep its `full_name` (for example `NASDAQ:NVDA`). The same ticker often appears on other exchanges, as a depositary receipt, or inside the name of a leveraged fund. Those are not matches.

If there is no clear match, drop the candidate and move to the next one.

Why this matters: `watchlist_add_bulk` reports success even for a symbol that does not exist, and leaves a dead row in the watchlist. Checking first is the only way to keep the list clean.

## Step 4: Show the list and wait for a yes

Pick a short, clear watchlist name (30 characters or fewer), for example "AI Swing Stocks". If the user gave a name, use theirs.

Show this, then stop and wait:

```
New watchlist: [name]

| Symbol | Name | Why |
|---|---|---|
| NASDAQ:NVDA | NVIDIA | Leading AI chip maker |

Add these to a new watchlist in TradingView?
```

If the user wants changes, check any new symbol with Step 3 before it goes on the list. Skip the wait only if the user already said to add without asking.

## Step 5: Create the new watchlist

There is no direct tool for this, so it is done through TradingView's own menu. Follow the steps in order.

1. `ui_open_panel` with panel `watchlist` and action `open`.

2. Open the watchlist menu. Run this with `ui_evaluate`:

```js
(() => { const item = () => [...document.querySelectorAll('#overlap-manager-root [data-role="menuitem"]')].find(e => (e.innerText || '').trim().toLowerCase().startsWith('create new list')); if (item()) return 'menu-open'; const b = document.querySelector('[data-name="watchlists-button"]'); if (!b) return 'no-button'; const r = b.getBoundingClientRect(); const o = {bubbles: true, cancelable: true, view: window, clientX: r.x + r.width / 2, clientY: r.y + r.height / 2, button: 0}; ['pointerover', 'mouseover', 'pointermove', 'mousemove', 'pointerdown', 'mousedown', 'pointerup', 'mouseup', 'click'].forEach(t => b.dispatchEvent(new (t.startsWith('pointer') ? PointerEvent : MouseEvent)(t, o))); return 'menu-open'; })()
```

3. Click "Create new list…". Run this with `ui_evaluate`:

```js
(() => { const it = [...document.querySelectorAll('#overlap-manager-root [data-role="menuitem"]')].find(e => (e.innerText || '').trim().toLowerCase().startsWith('create new list')); if (!it) return 'no-item'; const r = it.getBoundingClientRect(); const o = {bubbles: true, cancelable: true, view: window, clientX: r.x + r.width / 2, clientY: r.y + r.height / 2, button: 0}; ['pointerover', 'mouseover', 'pointerenter', 'mouseenter', 'pointermove', 'mousemove', 'pointerdown', 'mousedown', 'pointerup', 'mouseup', 'click'].forEach(t => it.dispatchEvent(new (t.startsWith('pointer') ? PointerEvent : MouseEvent)(t, o))); return 'clicked'; })()
```

4. Check that the name box is ready. Run this with `ui_evaluate`:

```js
(() => { const a = document.activeElement; return a && a.tagName === 'INPUT' && a.type === 'text' ? 'name-box-ready' : 'not-ready'; })()
```

5. If it says `name-box-ready`: `ui_type_text` with the watchlist name, then `ui_keyboard` with key `Enter`.

6. Confirm the new list is the one that is open. Run this with `ui_evaluate`, then run `watchlist_get`:

```js
(() => { const b = document.querySelector('[data-name="watchlists-button"]'); return b ? b.innerText.trim() : 'no-button'; })()
```

Continue only if the snippet returns the new name and `watchlist_get` shows `count` 0. An empty list does not return its name through `watchlist_get`, which is why the name is read from the screen.

The menu item is found by its text on purpose. "Clear list" sits right next to "Create new list…" in that menu, so never click by position or coordinates.

**If any step fails:** press `Escape` with `ui_keyboard` and try steps 2 to 6 one more time. If it fails again, stop and tell the user plainly. The usual reasons are that TradingView's free plan allows only one watchlist, or that TradingView is not set to English. Offer two choices:

- They create an empty watchlist by hand and reply "ready". Then run `watchlist_get` and continue only if `count` is 0.
- They ask you to add the symbols to the watchlist that is open now. Tell them its name and how many symbols it already has, and continue only after a clear yes.

Never add symbols to a list unless it is the new empty one, or the user clearly chose their open list. This is what protects their existing watchlists.

## Step 6: Add the symbols and read the list back

1. `watchlist_add_bulk` with the checked `full_name` values.
2. `watchlist_get` and compare with what you sent.
3. A row with no price (`last` is null) is a dead symbol. Remove it with `watchlist_remove` and note it for the report.
4. Note any symbol that is missing.

Do not trust the `added` count from `watchlist_add_bulk`. Only the read-back shows what is really on the list.

## Step 7: Report

Keep it short:

```
Watchlist ready: [name]
[N] symbols added.

| Symbol | Name | Last | Change |
|---|---|---|---|

Dropped: [symbol and reason, or "none"]

This is a list to study, not a list to buy.
```

## Boundaries

- Never remove, rename or clear anything on the user's existing watchlists.
- Never add a symbol that was not checked in Step 3 or did not come straight from TradingView's screener.
- Never add more than 20 symbols.
- Never say buy or sell. The watchlist is a starting point for the user's own analysis.

Skill 2: Stock Picker

The Stock Picker screens a whole stock market from plain words, using the same data as the TradingView screener. You say what you are looking for, such as growing revenue, profitable and uptrend.

Every word has an exact rule behind it:

  • Growing revenue: revenue up more than 10% in the last year

  • Growing earnings: earnings per share up more than 10% in the last year

  • Profitable: net income above zero

  • Cheap: price to earnings ratio (P/E) below 15

  • Pays a dividend: dividend yield above 2%

  • Uptrend: price above the 200-day moving average

  • Strong momentum: price up more than 10% in the last 3 months

You can replace any number. Say "revenue growth above 25%" and the rule changes. The menu also has rules for oversold, overbought, large companies and sectors.

The skill has market codes for the United States, India, the United Kingdom, Canada, Germany, Australia, Sweden, Nigeria, Kenya, South Africa, Pakistan and the Philippines.

The report shows the rules that were used, how many stocks passed, and a table with every number. If you say yes at the end, the results go into a new watchlist through Skill 1.

A screen gives you a shortlist to study, not an answer. For deeper research on a company from that list, InvestingPro is the research tool I use.

📋 Skill 2: Stock Picker

Copy it, paste it into Claude and say: Save this as a skill, exactly as written.

Show the full skill (241 lines)
---
name: "tradingview-stock-picker"
description: "Screens a whole stock market on TradingView from ready-made words or any rule stated freely (growth over years, profit, value, dividend, trend). Use for any request to pick, find or screen stocks."
---

# TradingView Stock Picker

Turn a request into a real screen of the whole market, using the same data as TradingView's own screener.

The user can do it the easy way or the free way, and can mix both:

- **Easy:** ready-made words, like "US market, growing revenue, profitable, uptrend, 10 results".
- **Free:** anything they say in their own words, like "at least 15% revenue growth a year over the last 3 years" or "net margin above 20%".

Anything that is a number in TradingView's data can be screened. The skill only reads data. It changes nothing in TradingView.

## What you need

- TradingView open with the TradingView MCP connected.
- These tools: `tv_health_check` and `ui_evaluate`. Tool names can carry a prefix that depends on the setup. Match on the last part of the name.

Start with `tv_health_check`. If it fails, tell the user to open TradingView with the MCP connected, and stop.

## Step 1: Get the three inputs

| Input | Meaning | If missing |
|---|---|---|
| Market | One country | Ask |
| Criteria | Ready-made words, free wishes, or both | Ask. Show the ready-made list as suggestions and say they can also describe what they want freely |
| How many | Number of results | 10 |

The number of results is at most 20. Ask for everything that is missing in one message.

## Step 2: Turn the request into exact rules

Every wish becomes one exact rule. There are three kinds. Use A when the words match, B and C for everything else.

### A. Ready-made rules

The user can replace any number ("revenue growth above 25%"). When they give no number, use the default.

| The user says | Rule object | Column to show |
|---|---|---|
| Growing revenue | `{left: 'total_revenue_yoy_growth_ttm', operation: 'greater', right: 10}` | `total_revenue_yoy_growth_ttm` |
| Long-term growth | `{left: 'total_revenue_cagr_5y', operation: 'greater', right: 10}` | `total_revenue_cagr_5y` |
| Consistent growth | history rule, see C: `{field: 'total_revenue_fy_h', kind: 'up_every_year', years: 5}` | none, the result is added as a column |
| Growing earnings | `{left: 'earnings_per_share_diluted_yoy_growth_ttm', operation: 'greater', right: 10}` | `earnings_per_share_diluted_yoy_growth_ttm` |
| Profitable | `{left: 'net_income_ttm', operation: 'greater', right: 0}` | `net_income_ttm` |
| Cheap | `{left: 'price_earnings_ttm', operation: 'less', right: 15}` | `price_earnings_ttm` |
| Pays a dividend | `{left: 'dividends_yield_current', operation: 'greater', right: 2}` | `dividends_yield_current` |
| Uptrend | `{left: 'close', operation: 'greater', right: 'SMA200'}` | `SMA200` |
| Strong momentum | `{left: 'Perf.3M', operation: 'greater', right: 10}` | `Perf.3M` |
| Oversold | `{left: 'RSI', operation: 'less', right: 30}` | `RSI` |
| Overbought | `{left: 'RSI', operation: 'greater', right: 70}` | `RSI` |
| Large companies (US only) | `{left: 'market_cap_basic', operation: 'greater', right: 10000000000}` | none, market cap is always shown |
| A sector | `{left: 'sector', operation: 'in_range', right: ['Sector Name']}` | none, sector is always shown |

In plain words: Growing revenue is revenue up more than 10% in the last twelve months against the twelve months before. Long-term growth is revenue up more than 10% a year on average over the last 5 fiscal years. Consistent growth is revenue higher in each of the last 5 fiscal years.

For "below" use `less`, for "above" use `greater`.

### B. Any other number TradingView has

Use this when the wish is not in the table: "net margin above 20%", "return on equity above 15%", "little debt", "price up more than 50% in 3 years".

1. Find the real field name. Run this with `ui_evaluate`. Change only `words` (one or two short words, such as `['net', 'margin']`, `['return_on']`, `['debt']`, `['Perf']`) and the market code:

```js
(() => { const words = ['net', 'margin']; const market = 'america'; window.__stockPickerFields = 'pending'; fetch('https://scanner.tradingview.com/' + market + '/metainfo', {method: 'POST', credentials: 'include', body: '{}'}).then(r => r.json()).then(m => { const hits = (m.fields || []).filter(f => !f.n.includes('|') && words.every(w => f.n.toLowerCase().includes(w.toLowerCase()))).map(f => f.n + ' (' + f.t + ')'); window.__stockPickerFields = JSON.stringify({found: hits.length, fields: hits.slice(0, 60)}); }).catch(e => { window.__stockPickerFields = 'ERROR: ' + e.message; }); return 'started'; })()
```

Then read `window.__stockPickerFields` with `ui_evaluate`. If it says `pending`, read it again.

2. Pick the field that fits the user's words and period. The end of the name tells the period:

| Name ending | Meaning |
|---|---|
| `_ttm` | Last twelve months |
| `_fy` | Last fiscal year |
| `_fq` | Last quarter |
| `_current` | Right now |
| `yoy_growth` | Change against one year earlier |
| `qoq_growth` | Change against the quarter before |
| `cagr_5y` | Average growth per year over 5 years |
| `_5y_growth_fy` | Total growth over 5 years |
| `Perf.3M`, `Perf.Y`, `Perf.3Y`, `Perf.5Y` | Price change over that period |
| `_fy_h` | Yearly history, used in C |

3. The type in brackets tells the unit. `percent` is already in percent (20 means 20%). `fundamental_price` is a money amount in the company's currency. `number` is a plain number or ratio. `num_slice` is a history list for C.

4. Write the rule as `{left: 'field_name', operation: 'greater', right: 20}` and add the field to `show`.

Never type a field name from memory. TradingView does not complain about a wrong name: a wrong filter quietly returns zero stocks and a wrong column quietly returns empty values. The screen in Step 4 checks every field against TradingView's own list and stops if one is not real.

If the finder returns nothing, try one other word. If there is still nothing, that wish cannot be screened.

### C. Growth over several years (history rules)

Use this when TradingView has no ready number for the period: "15% a year over the last 3 years", "revenue up every year for 5 years", "profitable in each of the last 5 years". The screen calculates it from the yearly history. Put these objects in `calc`:

| The user wants | calc object |
|---|---|
| Average growth per year over N years | `{field: 'total_revenue_fy_h', kind: 'avg_growth', years: 3, operation: 'greater', right: 15}` |
| Total growth over N years | `{field: 'total_revenue_fy_h', kind: 'total_growth', years: 3, operation: 'greater', right: 50}` |
| Higher every year for N years | `{field: 'total_revenue_fy_h', kind: 'up_every_year', years: 5}` |
| Above a number in each of the last N years | `{field: 'net_income_fy_h', kind: 'every_year_above', years: 5, right: 0}` |

History fields: `total_revenue_fy_h` (revenue), `net_income_fy_h` (profit), `earnings_per_share_diluted_fy_h` (earnings per share), `free_cash_flow_fy_h`, `ebitda_fy_h`, `gross_profit_fy_h`, `total_debt_fy_h`, `total_assets_fy_h`, `dps_common_stock_prim_issue_fy_h` (dividend per share).

Years are fiscal years. N is at most 15.

"15% growth over the last 3 years" can mean 15% a year or 15% in total. Read it as growth per year (`avg_growth`) unless the user says "in total". Say which reading you used at the top of the report, so the user can ask for the other one.

A stock that cannot be judged is left out and counted: not enough years of history, or a starting value of zero or below for a growth rule.

### What cannot be screened

Only things that are not numbers in TradingView's data: "good management", "a strong brand", "will go up". Say that it cannot be screened, run the rest, and name what was left out at the top of the report.

### Notes

**Sectors.** Use TradingView's exact names: Commercial Services, Communications, Consumer Durables, Consumer Non-Durables, Consumer Services, Distribution Services, Electronic Technology, Energy Minerals, Finance, Health Services, Health Technology, Industrial Services, Miscellaneous, Non-Energy Minerals, Process Industries, Producer Manufacturing, Retail Trade, Technology Services, Transportation, Utilities. Everyday words can map to more than one: "tech" is Electronic Technology plus Technology Services, "healthcare" is Health Technology plus Health Services.

**Large companies outside the US.** Market cap is in local currency, so the $10B rule only fits the US. For other markets, leave the size rule out and say so. Results are sorted biggest company first anyway.

**Stocks only.** If the user asks for crypto, forex or funds, say this skill screens stocks.

## Step 3: Pick the market code and the sort order

| Market | Code |
|---|---|
| US | `america` |
| India | `india` |
| UK | `uk` |
| Canada | `canada` |
| Germany | `germany` |
| Australia | `australia` |
| Sweden | `sweden` |
| Nigeria | `nigeria` |
| Kenya | `kenya` |
| South Africa | `rsa` |
| Pakistan | `pakistan` |
| Philippines | `philippines` |

For another country, try its English name in lowercase. If the screen returns an error, tell the user that market is not available.

Sort order is biggest company first (`market_cap_basic`, `desc`) unless the user asks for another order:

| The user says | sortBy | sortOrder |
|---|---|---|
| Fastest growing | `total_revenue_yoy_growth_ttm` | `desc` |
| Cheapest | `price_earnings_ttm` | `asc` |
| Highest dividend | `dividends_yield_current` | `desc` |
| Strongest | `Perf.3M` | `desc` |

Any field from a rule can be used as `sortBy`. To sort by a history rule from C, biggest value first, set `sortCalc` to its position in `calc` (0 for the first one).

## Step 4: Run the screen

Run this with `ui_evaluate`. Change only the `cfg` object at the start: the market code, the count, the sort, the rules from A and B, the columns to show, and the history rules from C in `calc` (leave `calc` empty when there are none).

```js
(() => { const cfg = { market: 'america', count: 10, sortBy: 'market_cap_basic', sortOrder: 'desc', rules: [ {left: 'total_revenue_yoy_growth_ttm', operation: 'greater', right: 10}, {left: 'net_income_ttm', operation: 'greater', right: 0}, {left: 'close', operation: 'greater', right: 'SMA200'} ], show: ['total_revenue_yoy_growth_ttm', 'net_income_ttm', 'SMA200'], calc: [], sortCalc: null }; const base = [ {left: 'is_primary', operation: 'equal', right: true}, {left: 'typespecs', operation: 'has', right: ['common']}, {left: 'average_volume_30d_calc', operation: 'greater', right: 500000} ]; const calc = cfg.calc || []; const hist = [...new Set(calc.map(c => c.field))]; const first = ['name', 'description', 'close', 'currency', 'market_cap_basic', 'sector'].concat(cfg.show); const columns = first.concat(hist); const used = [...new Set(cfg.rules.map(r => r.left).concat(cfg.rules.filter(r => typeof r.right === 'string' && ['greater', 'less'].includes(r.operation)).map(r => r.right), cfg.show, hist, [cfg.sortBy]))]; const judge = (h, c) => { const need = c.kind === 'every_year_above' ? c.years : c.years + 1; if (!Array.isArray(h) || h.length < need) return null; const v = h.slice(0, need); if (v.some(x => x === null || x === undefined)) return null; if (c.kind === 'up_every_year') { let n = 0; for (let i = 0; i < c.years; i++) if (v[i] > v[i + 1]) n++; return {ok: n === c.years, value: n + ' of ' + c.years}; } if (c.kind === 'every_year_above') { let n = 0; for (let i = 0; i < c.years; i++) if (v[i] > c.right) n++; return {ok: n === c.years, value: n + ' of ' + c.years}; } const a = v[0], b = v[c.years]; if (a <= 0 || b <= 0) return null; const val = c.kind === 'total_growth' ? (a / b - 1) * 100 : (Math.pow(a / b, 1 / c.years) - 1) * 100; return {ok: c.operation === 'less' ? val < c.right : val > c.right, value: Math.round(val * 10) / 10}; }; const url = 'https://scanner.tradingview.com/' + cfg.market; window.__stockPicker = 'pending'; fetch(url + '/metainfo', {method: 'POST', credentials: 'include', body: '{}'}).then(r => r.json()).then(m => { const real = new Set((m.fields || []).map(f => f.n).concat(['name', 'description'])); const unknown = used.filter(f => !real.has(f)); if (unknown.length) { window.__stockPicker = 'ERROR: these fields do not exist in TradingView: ' + unknown.join(', ') + '. Find the real name with the field finder.'; return; } return fetch(url + '/scan', {method: 'POST', credentials: 'include', body: JSON.stringify({filter: base.concat(cfg.rules), options: {lang: 'en'}, markets: [cfg.market], symbols: {query: {types: ['stock']}, tickers: []}, columns: columns, sort: {sortBy: cfg.sortBy, sortOrder: cfg.sortOrder}, range: [0, calc.length ? 5000 : cfg.count]})}).then(r => r.text().then(t => { try { const j = JSON.parse(t); let rows = (j.data || []).map(x => [x.s].concat(x.d)); let passed = j.totalCount, unjudged = 0; if (calc.length) { const kept = []; rows.forEach(row => { const res = calc.map(c => judge(row[1 + columns.indexOf(c.field)], c)); if (res.some(x => x === null)) { unjudged++; return; } if (res.every(x => x.ok)) kept.push(row.slice(0, 1 + first.length).concat(res.map(x => x.value))); }); if (Number.isInteger(cfg.sortCalc)) { const k = 1 + first.length + cfg.sortCalc; kept.sort((p, q) => (typeof q[k] === 'number' ? q[k] : 0) - (typeof p[k] === 'number' ? p[k] : 0)); } passed = kept.length; rows = kept.slice(0, cfg.count); } window.__stockPicker = JSON.stringify({status: r.status, screened: j.totalCount, passed: passed, unjudged: unjudged, columns: first.concat(calc.map(c => c.kind + ' ' + c.years + 'y ' + c.field)), rows: rows}); } catch (e) { window.__stockPicker = 'ERROR: ' + r.status + ' ' + t.slice(0, 200); } })); }).catch(e => { window.__stockPicker = 'ERROR: ' + e.message; }); return 'started'; })()
```

The `base` rules are always on: main listing only, ordinary shares only, and average volume above 500,000 shares a day. Change the volume number only if the user asks.

Then read the result. Run this with `ui_evaluate`:

```js
window.__stockPicker
```

If it says `pending`, read it again, up to three times.

How to read the result:

- `screened` is how many stocks passed the rules from A and B.
- `passed` is how many passed everything, including the history rules from C.
- `unjudged` is how many could not be judged by a history rule and were left out.
- The first value in each row is the full symbol (for example `NASDAQ:AAPL`). The rest follow the order in `columns`. Each history rule adds one column at the end: a percentage for growth, or a count like "5 of 5".

A stock with no data for one of the rules never passes, so every row has a real number for every rule.

If the result is an error, say so plainly and stop. If it names fields that do not exist, find the real names with the field finder in Step 2 and run the screen again. Never fill in numbers from your own memory.

## Step 5: Report everything

The answer has to stand on its own. Someone reading it should see how the request was read, the rules, the count and every number without opening TradingView.

```
Stock Picker: [market]

How I read your request
[One line per free wish, in plain words. Example: "15% growth over the last 3 years" = revenue up at least 15% a year on average over the last 3 fiscal years. Say "in total" if you meant that instead.]

Rules used
| Rule | Exact filter | Source |
|---|---|---|
| Growing revenue | Revenue growth above 10% (last twelve months) | TradingView screener |
| 3-year growth | Revenue up more than 15% a year on average over 3 fiscal years | Calculated from TradingView's yearly revenue |
| Always on | Main listing, ordinary shares, average volume above 500K | TradingView screener |

Left out: [a wish that cannot be screened and why, or leave this line out]

[passed] stocks passed. Showing the top [N], [sort order in plain words].
[If there are history rules: [unjudged] stocks could not be judged (not enough yearly history, or a starting value of zero or below) and are not included.]

| # | Symbol | Name | Price | Market cap | Sector | [one column per rule] |
|---|---|---|---|---|---|---|

Data: TradingView screener, read just now.
Passing a screen is not a recommendation. It is a shortlist to study.

Want these as a watchlist in TradingView?
```

Leave out "How I read your request" when the user only used ready-made words.

Formatting:

- Symbol is the full name, like `NASDAQ:AAPL`, so the next skill can use it as is.
- Price with its currency code. Some markets quote in pence or cents (GBX, ZAC). Show the code as given.
- Market cap and other money amounts shortened: 5.06T, 845B, 29.1B, 640M, with the currency code.
- Percentages with one decimal. P/E, RSI and other ratios with one decimal.
- For the uptrend rule, show how far the price is above the 200-day average in percent: (price / SMA200 - 1) x 100.
- Give every column a plain name the user understands, not the field name.

If fewer stocks passed than the user asked for, show what passed and say which rule is the tightest. If nothing passed, say so and suggest one rule to loosen.

## Step 6: Hand over to the watchlist

If the user says yes, pass the symbols to the Watchlist Builder skill in the same order, with a short name built from the rules (for example "US Growth Uptrend"). If that skill is not installed, say so. Do not try to create the watchlist another way.

## Boundaries

- Never say buy or sell. A screen is a starting point for the user's own analysis.
- Never guess a number, and never use a field name that did not come from this skill or from the field finder.
- Never refuse a wish that can be measured. Find the field or use a history rule.
- Never show more than 20 results.
- Never change anything in TradingView.

Skill 3: Chart Setup

Chart Setup prepares a TradingView chart for your trading style in one step. It sets the symbol, the timeframe and the candles, then adds a standard set of indicators.

The skill has three presets:

  • Day trading: 5-minute chart with the 9 and 20 exponential moving averages (EMA), the volume-weighted average price (VWAP) and Volume

  • Swing trading: daily chart with the 50-day and 200-day moving averages, Volume and the Relative Strength Index (RSI)

  • Long-term investing: weekly chart with the 40-week moving average and Volume

Indicators that are already on your chart stay where they are. The report lists every indicator with its current value. You can also name your own setup, for example daily, 20 EMA and MACD (Moving Average Convergence Divergence), with up to five indicators.

If moving averages or RSI are new to you, my Moving Averages course and my RSI course explain how to read them.

📋 Skill 3: Chart Setup

Copy it, paste it into Claude and say: Save this as a skill, exactly as written.

Show the full skill (105 lines)
---
name: "tradingview-chart-setup"
description: "Sets up a TradingView chart for a trading style in one step (symbol, timeframe, candles, standard indicators) and reports every indicator value. Use for any request to set up, prepare or configure a chart."
---

# TradingView Chart Setup

Turn a request like "Set up my chart: NVDA, swing trading" into a ready chart in the user's TradingView app, then report what is on it with live values.

## What you need

- TradingView open with the TradingView MCP connected.
- These tools: `tv_health_check`, `chart_get_state`, `data_get_study_values`, `quote_get`, `symbol_search`, `chart_set_symbol`, `chart_set_timeframe`, `chart_set_type`, `chart_manage_indicator`, `indicator_add`, `indicator_search`, `ui_keyboard`.

Tool names can carry a prefix that depends on the setup. Match on the last part of the name.

Start with `tv_health_check`. If it fails, tell the user to open TradingView with the MCP connected, and stop.

## Step 1: Get the inputs

| Input | Meaning | If missing |
|---|---|---|
| Symbol | What to chart | Keep the symbol that is open |
| Style | Day trading, swing trading or long-term investing, or the user's own list of indicators | Ask |

## Step 2: Pick the setup

| Style | Timeframe | Indicators, in this order |
|---|---|---|
| Day trading | `5` | 9 EMA, 20 EMA, VWAP, Volume |
| Swing trading | `D` | 50 SMA, 200 SMA, Volume, RSI 14 |
| Long-term investing | `W` | 40 SMA, Volume |

The order matters. TradingView's free plan allows only two indicators per chart, so the most important ones go first.

If the user lists their own setup instead ("daily, 20 EMA, MACD"), use their timeframe and indicators in the order they gave. Add at most 5 indicators in one setup. If they ask for more, say that 5 is the cap because a crowded chart is hard to read, and ask which 5.

## Step 3: Read the chart as it is now

Run `chart_get_state` and `data_get_study_values`. Note every indicator that is already there, with its settings.

Existing indicators stay. Do not remove anything on your own.

If the user asks for a clean chart or a fresh start, list what is on the chart and wait for a clear yes before removing. Remove with `chart_manage_indicator`, action `remove`, and the `entity_id` from `chart_get_state`. Removing someone's indicators cannot be undone by this skill, which is why it always asks first.

## Step 4: Set the symbol, timeframe and chart type

1. If the user gave a symbol, find it with `symbol_search` and take the `full_name` of the main listing (for example `NASDAQ:NVDA`). Then `chart_set_symbol`. If there is no clear match, say so and stop.
2. `chart_set_timeframe` with the code from Step 2.
3. `chart_set_type` with `Candles`.

## Step 5: Add the missing indicators

Skip any indicator that is already on the chart with the same setting (compare names without regard to upper and lower case). Add the rest one at a time, in order, with `chart_manage_indicator`, action `add`:

| Indicator | `indicator` | `inputs` |
|---|---|---|
| Simple moving average (SMA) | `Moving Average` | `{"length": 50}` with the length you need |
| Exponential moving average (EMA) | `Exponential moving average` | `{"length": 9}` with the length you need |
| VWAP | `VWAP` | none |
| Volume | `Volume` | none |
| RSI | `Relative Strength Index` | none for the standard 14 |
| MACD | `MACD` | none |

Check `success` in every result. Indicator names differ between TradingView versions, so a name that works on one setup can fail on another.

**If an add fails:** try `indicator_add` with the common name as `query` and `section` set to `Technicals`. For an indicator that is not in the table, use `indicator_search` first to find its exact title.

**If that fails too:** stop adding. Press `Escape` once with `ui_keyboard`, because a TradingView popup may be open. Report which indicators are missing. The usual reason is the plan limit: the free plan allows two indicators per chart.

## Step 6: Read the chart back

Run `chart_get_state`, `data_get_study_values` and `quote_get` (no symbol, so it reads the open chart).

Only what the read-back shows counts as done. Some indicators return a very long `text` value in their inputs. Ignore it and use the `values`.

## Step 7: Report everything

The answer has to stand on its own. Someone reading it should know exactly what is on the chart without opening TradingView.

```
Chart ready: [SYMBOL], [timeframe in words], candles
Price now: [price]

| Indicator | Setting | Value now | What it shows |
|---|---|---|---|
| 50-day average | 50, close | 218.00 | Medium-term trend |
| 200-day average | 200, close | 204.54 | Long-term trend |
| Volume | | 428.99M | How much was traded |
| RSI | 14 | 23.95 | Speed of recent moves |

Already on the chart and kept: [list, or "nothing"]
Not added: [indicator and reason, or "nothing"]
```

Keep "What it shows" to 6 words or fewer. Report the values as they are. Do not turn them into a signal or an opinion.

If other indicators were kept, add one line: "Say 'remove them' if you want a clean chart."

## Boundaries

- Never remove an indicator without a clear yes.
- Never touch drawings, watchlists or alerts.
- Never add more than 5 indicators in one setup.
- Never say buy or sell.

Skill 4: Morning Brief

The Morning Brief reads the watchlist that is open in TradingView and writes one complete report. It needs no input from you.

The brief has five parts:

  • Price moves: 1 day, 1 week and 1 month for every symbol, plus Trend, RSI and Volume against normal

  • Flags: facts worth a look today, such as unusual volume, an RSI at 70 or above, a price within 3% of the 52-week high, or earnings within 7 days

  • Key price levels: the 50-day and 200-day moving averages, the 1-month high and low, and the 52-week high and low

  • Alerts: your TradingView alerts and when each one last fired

  • What happened: plain-English news on the 3 biggest movers, with links to the sources

Trend has an exact rule too. Uptrend means the price is above both the 50-day and the 200-day moving average. Downtrend means it is below both. Anything else is Mixed.

The news comes from the TradingView news feed. After the brief, Claude asks if it should open the four biggest movers side by side.

📋 Skill 4: Morning Brief

Copy it, paste it into Claude and say: Save this as a skill, exactly as written.

Show the full skill (155 lines)
---
name: "tradingview-morning-brief"
description: "Writes a morning brief for the open TradingView watchlist with movers, trend, flags, key levels, alerts and headlines. Use when the user asks for a morning brief, a market brief or a rundown of their watchlist."
---

# TradingView Morning Brief

Read the watchlist that is open in the user's TradingView app and write one complete brief: what moved, where each symbol stands, what deserves a look today.

Every number in the brief is read from TradingView. Nothing is estimated.

## What you need

- TradingView open with the TradingView MCP connected.
- These tools: `tv_health_check`, `watchlist_get`, `ui_evaluate`, `alert_list`, `pane_set_layout`, `pane_set_symbol`, `pane_focus`, `pane_list`, `chart_set_timeframe`, `chart_set_symbol`.

Tool names can carry a prefix that depends on the setup. Match on the last part of the name.

Start with `tv_health_check`. If it fails, tell the user to open TradingView with the MCP connected, and stop.

## Step 1: Read the watchlist

Run `watchlist_get`. Keep the list name, every full symbol (like `NASDAQ:NVDA`), and each row's price and daily change. You need those rows later for symbols with limited data.

- If the list is empty, say so, suggest building one with the Watchlist Builder, and stop.
- If it has more than 30 symbols, use the first 30 and say so in the brief.

## Step 2: Read the data for every symbol in one go

Run this with `ui_evaluate`. Change only `tickers` in the `cfg` object at the start. Change the other numbers only if the user asks for different thresholds.

```js
(() => { const cfg = { tickers: ['NASDAQ:NVDA', 'NASDAQ:AAPL'], volX: 1.5, rsiHi: 70, rsiLo: 30, nearPct: 3, earnDays: 7 }; const cols = ['description', 'type', 'close', 'currency', 'change', 'Perf.W', 'Perf.1M', 'SMA50', 'SMA200', 'RSI', 'relative_volume_10d_calc', 'price_52_week_high', 'price_52_week_low', 'High.1M', 'Low.1M', 'earnings_release_next_date', 'relative_volume_intraday|5', 'current_session']; const r1 = (x) => x == null ? null : Math.round(x * 10) / 10; const px = (x) => x == null ? null : (Math.abs(x) >= 100 ? Math.round(x * 100) / 100 : Math.round(x * 10000) / 10000); const dayNum = (ms) => Math.floor(ms / 86400000); window.__morningBrief = 'pending'; fetch('https://scanner.tradingview.com/global/scan', {method: 'POST', credentials: 'include', body: JSON.stringify({symbols: {tickers: cfg.tickers}, columns: cols})}).then(r => r.text().then(t => { try { const j = JSON.parse(t); const now = Date.now(); const rows = (j.data || []).map(x => { const d = x.d; const open = d[17] === 'market'; const vx = open && d[16] != null ? d[16] : d[10]; const o = {symbol: x.s, name: d[0], type: d[1], price: px(d[2]), currency: d[3], day: r1(d[4]), week: r1(d[5]), month: r1(d[6]), sma50: px(d[7]), sma200: px(d[8]), rsi: r1(d[9]), volX: r1(vx), marketOpen: open, hi52: px(d[11]), lo52: px(d[12]), hi1m: px(d[13]), lo1m: px(d[14]), earnings: d[15] ? new Date(d[15] * 1000).toISOString().slice(0, 10) : null}; o.trend = (d[7] == null || d[8] == null) ? 'n/a' : (d[2] > d[7] && d[2] > d[8]) ? 'Uptrend' : (d[2] < d[7] && d[2] < d[8]) ? 'Downtrend' : 'Mixed'; const f = []; if (vx != null && vx >= cfg.volX) f.push('Unusual volume (' + r1(vx) + 'x normal' + (open ? ' for this time of day' : '') + ')'); if (d[9] != null && d[9] >= cfg.rsiHi) f.push('Overbought (RSI ' + r1(d[9]) + ')'); if (d[9] != null && d[9] <= cfg.rsiLo) f.push('Oversold (RSI ' + r1(d[9]) + ')'); if (d[11]) { const p = (1 - d[2] / d[11]) * 100; if (p <= cfg.nearPct) f.push('Near 52-week high (' + r1(p) + '% below)'); } if (d[12]) { const p = (d[2] / d[12] - 1) * 100; if (p <= cfg.nearPct) f.push('Near 52-week low (' + r1(p) + '% above)'); } if (d[15]) { const days = dayNum(d[15] * 1000) - dayNum(now); if (days >= 0 && days <= cfg.earnDays) f.push('Earnings in ' + days + ' days (' + o.earnings + ')'); } o.flags = f; return o; }); rows.sort((a, b) => Math.abs(b.day || 0) - Math.abs(a.day || 0)); const got = rows.map(x => x.symbol); window.__morningBrief = JSON.stringify({status: r.status, today: new Date(now).toISOString().slice(0, 10), up: rows.filter(x => x.day > 0).length, down: rows.filter(x => x.day < 0).length, marketsOpen: rows.filter(x => x.marketOpen).length, rows: rows, missing: cfg.tickers.filter(s => got.indexOf(s) < 0)}); } catch (e) { window.__morningBrief = 'ERROR: ' + r.status + ' ' + t.slice(0, 200); } })).catch(e => { window.__morningBrief = 'ERROR: ' + e.message; }); return 'started'; })()
```

Then read the result. Run this with `ui_evaluate`:

```js
window.__morningBrief
```

If it says `pending`, read it again, up to three times.

What comes back:

- `rows`: one entry per symbol, already sorted with the biggest daily move first. Changes are in percent. `volX` is volume against normal. For a symbol whose market is open (`marketOpen` is `true`) it compares the volume so far today with the usual volume by this time of day. For a closed market it compares the last full day with the average of the previous 10 days. `marketsOpen` counts the symbols whose market is open. `trend` and `flags` are already worked out by the rules below, so use them as they are and do not recalculate.
- `missing`: symbols TradingView's screener has no data for (some index feeds and broker CFDs). For these, show only the price and daily change from Step 1 and list them under "Limited data".

The rules the snippet applies:

| Word | Rule |
|---|---|
| Uptrend | Price above both the 50-day and the 200-day average |
| Downtrend | Price below both |
| Mixed | Anything else |
| Unusual volume | 1.5 times normal or more. Normal is the usual volume by this time of day when the market is open, and the 10-day average when it is closed |
| Overbought / oversold | RSI at 70 or above / at 30 or below |
| Near a 52-week high or low | Within 3% |
| Earnings soon | Within 7 days |

If the result is an error, say so plainly and write the brief from the Step 1 rows only. Never fill in numbers from memory.

## Step 3: Read the alerts

Run `alert_list`. For each alert keep only: symbol, kind (price, indicator or strategy), whether it is active, and when it last fired. Ignore the long settings data. An alert counts as "fired" if `last_fired` is within the last 24 hours.

## Step 4: Find out what happened to the three biggest movers

The news comes from TradingView's own news feed, so no web search is needed. Run this with `ui_evaluate`. Change only `symbols`: the first three symbols in `rows`.

```js
(() => { const symbols = ['NASDAQ:NVDA', 'NASDAQ:MSFT', 'NASDAQ:AMZN']; const hours = 48, perSymbol = 8; window.__briefNews = {}; const cutoff = Date.now() / 1000 - hours * 3600; symbols.forEach(s => { window.__briefNews[s] = 'pending'; fetch('https://news-headlines.tradingview.com/v2/headlines?client=web&lang=en&symbol=' + encodeURIComponent(s), {credentials: 'include'}).then(r => r.json()).then(j => { window.__briefNews[s] = (j.items || []).filter(i => i.published >= cutoff).sort((a, b) => b.published - a.published).slice(0, perSymbol).map(i => ({title: (i.title || '').slice(0, 160), source: i.source || i.provider, date: new Date(i.published * 1000).toISOString().slice(0, 16).replace('T', ' '), link: 'https://www.tradingview.com' + i.storyPath})); }).catch(e => { window.__briefNews[s] = 'ERROR: ' + e.message; }); }); return 'started'; })()
```

Then read the result with `ui_evaluate`:

```js
JSON.stringify(window.__briefNews)
```

If a symbol still says `pending`, read again, up to three times. Each symbol comes back with up to eight headlines from the last 48 hours: title, source, date (UTC) and link.

Read all the headlines for a symbol together and work out the main story. Then write what happened in plain English, the way you would tell a friend who has not seen the news.

- One or two short sentences per symbol. Lead with the main story, the one most of the headlines are about.
- Say it plainly. Never hide the main story behind a side detail. If the news is that a CEO admitted to something, or that a company is under investigation, say exactly that and name the source ("Reuters reports that...").
- Explain names and jargon in a few words. The reader should not need to know who a law firm or an analyst is to understand the line.
- Stick to what the headlines say. Add nothing from your own memory, and do not speculate about what it means for the stock.
- If a headline itself links the news to the price move, you can say that the source makes that link. Do not make the link yourself.
- End with the one or two most useful sources as links.
- If a symbol has no headlines, or the read fails, write "No recent news in TradingView's feed."

## Step 5: Write the brief

The brief has to stand on its own. Someone reading it should not need to open TradingView.

```
Morning Brief: [list name], [today]
[N] symbols: [up] up, [down] down.

Price moves (biggest move first)
| Symbol | Price | 1 day | 1 week | 1 month | Trend | RSI (14) | Volume vs normal |
|---|---|---|---|---|---|---|---|
| NASDAQ:NVDA | 168.89 USD | -5.5% | -18.8% | -27.8% | Downtrend | 23.9 | 2.5x |

[One line under the table that says what "normal" is, see below]

Flags (facts worth a look today)
- NVDA: Unusual volume (2.5x normal). Oversold (RSI 23.9).

Key price levels
| Symbol | 50-day moving average | 200-day moving average | 1-month high | 1-month low | 52-week high | 52-week low |
|---|---|---|---|---|---|---|

Alerts (your TradingView alerts)
- [symbol]: [kind], [active or paused], last fired [time or "never"]

What happened (news on the 3 biggest movers)
- NVDA: [one or two plain sentences]. Sources: [Source name](link), [Source name](link)

Limited data: [symbols], price and daily change only.

Flags are facts, not signals.

Open the 4 biggest movers side by side?
```

- Use the full symbol in the tables so the next skill can use it as is.
- If volume is missing or 0, show "n/a".
- The line under the price table depends on `marketsOpen`. All markets closed: "Volume vs normal: the last full day against the average of the previous 10 days." All open: "Volume vs normal: the volume so far today against the usual volume by this time of day. The market is open." Mixed: say both, and which symbols are open.
- If no symbol has a flag, write "No flags today."
- If there are no alerts, write "No alerts set."
- Leave the "Limited data" line out when nothing is missing.
- Write every column header and label exactly as in the template. Short labels like "50-day" on their own are unclear.

## Step 6: Open the charts, only after a yes

If the user says yes and the list has at least 4 symbols with data:

1. `pane_set_layout` with `2x2`.
2. `pane_set_symbol` for index 0, 1, 2 and 3 with the four biggest movers, in order.
3. `pane_list`. For any pane that is not on the daily timeframe, use `pane_focus` on it and then `chart_set_timeframe` with `D`.
4. `pane_list` again and report which symbol is on which pane.

Tell the user they can say "single chart" to go back. That is `pane_set_layout` with `s`.

If the layout change fails or does not give 4 panes, put the biggest mover on the chart with `chart_set_symbol` instead, and explain why: more than one chart per tab needs a paid TradingView plan. Do the same if the list has fewer than 4 symbols with data.

## Boundaries

- Never say buy or sell. A flag is a fact to look at, not a signal.
- Never invent news or guess why something moved. Say what the sources report, and name them.
- Never guess a level. Every level is a number read from TradingView.
- Never change the chart layout without a clear yes.
- Never create, change or delete an alert.

Skill 5: Candlestick Scanner

The Candlestick Scanner looks for 16 candlestick patterns on your watchlist or across a whole stock market. It uses the pattern detection built into TradingView, on the newest daily or weekly candle.

  • Bullish patterns: Hammer, Inverted Hammer, Bullish Engulfing, Morning Star, Bullish Harami, Three White Soldiers and Dragonfly Doji

  • Bearish patterns: Shooting Star, Hanging Man, Bearish Engulfing, Evening Star, Bearish Harami, Three Black Crows and Gravestone Doji

  • Neutral patterns: Doji and Spinning Top

The scanner also checks where the pattern formed. Good location means a bullish pattern within 5% of the 1-month low, or a bearish pattern within 5% of the 1-month high.

Every hit shows the open, high, low and close of the candle, so you can check the pattern by hand. One limit to know: the scanner reads the newest candle. If the market is open, that candle is not finished and the pattern can still change.

📋 Skill 5: Candlestick Scanner

Copy it, paste it into Claude and say: Save this as a skill, exactly as written.

Show the full skill (186 lines)
---
name: "tradingview-candlestick-scanner"
description: "Scans a TradingView watchlist or a whole stock market for candlestick patterns on the newest candle of any timeframe. Use for any request to find, scan or check candlestick patterns."
---

# TradingView Candlestick Scanner

Find candlestick patterns with TradingView's own pattern detection, on the user's open watchlist or across a whole stock market, and report every hit with the candle's four prices so it can be checked by hand.

The skill only reads data. It changes nothing in TradingView.

## What you need

- TradingView open with the TradingView MCP connected.
- These tools: `tv_health_check`, `watchlist_get`, `ui_evaluate`.

Tool names can carry a prefix that depends on the setup. Match on the last part of the name.

Start with `tv_health_check`. If it fails, tell the user to open TradingView with the MCP connected, and stop.

## Step 1: Get the inputs

| Input | Meaning | If missing |
|---|---|---|
| Where | The open watchlist, or one market (a country) | The open watchlist |
| Patterns | "All" (the 16 main patterns), "bullish", "bearish", one or more pattern names, or "every pattern" (all 43 that TradingView detects) | All |
| Timeframe | Daily, weekly, monthly, 4 hours, 1 hour, or 30, 15 or 5 minutes | Daily |
| How many | For a market scan only | 10, at most 20 |

Nothing here needs a question. If the user gave no details, scan the open watchlist for all patterns on the daily candle.

The 16 main patterns, with the exact names to use:

| Bullish | Bearish | Neutral |
|---|---|---|
| Hammer | Shooting Star | Doji |
| Inverted Hammer | Hanging Man | Spinning Top |
| Bullish Engulfing | Bearish Engulfing | |
| Morning Star | Evening Star | |
| Bullish Harami | Bearish Harami | |
| Three White Soldiers | Three Black Crows | |
| Dragonfly Doji | Gravestone Doji | |

The user can also ask for any other pattern that TradingView detects. These 27 work the same way when the user names them, or all at once with "every pattern":

| Bullish | Bearish |
|---|---|
| Piercing Line | Dark Cloud Cover |
| Morning Doji Star | Evening Doji Star |
| Bullish Doji Star | Bearish Doji Star |
| Bullish Harami Cross | Bearish Harami Cross |
| Bullish Abandoned Baby | Bearish Abandoned Baby |
| Bullish Kicking | Bearish Kicking |
| Bullish Tri-Star | Bearish Tri-Star |
| Tweezer Bottom | Tweezer Top |
| Rising Three Methods | Falling Three Methods |
| Rising Window | Falling Window |
| Upside Tasuki Gap | Downside Tasuki Gap |
| White Marubozu | Black Marubozu |
| Long Lower Shadow | Long Upper Shadow |
| | On Neck |

If the user uses another common name for one of these (for example "bullish piercing"), use the name from the table. Only if the pattern is in neither table, say that TradingView does not detect it, and scan for the rest.

## Step 2: Fill in the settings

- **Watchlist scan:** run `watchlist_get` and keep the list name and every full symbol (like `NASDAQ:NVDA`). If the list is empty, say so and stop.
- **Market scan:** pick the market code.

| Market | Code |
|---|---|
| US | `america` |
| India | `india` |
| UK | `uk` |
| Canada | `canada` |
| Germany | `germany` |
| Australia | `australia` |
| Sweden | `sweden` |
| Nigeria | `nigeria` |
| Kenya | `kenya` |
| South Africa | `rsa` |
| Pakistan | `pakistan` |
| Philippines | `philippines` |

For another country, try its English name in lowercase. If the scan returns an error, tell the user that market is not available.

A market scan covers stocks only.

## Step 3: Run the scan

Run this with `ui_evaluate`. Change only the `cfg` object at the start:

- `mode`: `'market'` or `'watchlist'`
- `market`: the code from Step 2 (market scans)
- `tickers`: the full symbols from the watchlist (watchlist scans)
- `patterns`: `'all'` (the 16 main patterns), `'bullish'`, `'bearish'`, `'every'` (all 43), or a list of exact names from either table like `['Hammer', 'Piercing Line']`
- `timeframe`: `'D'` daily, `'W'` weekly, `'M'` monthly, `'240'` 4 hours, `'60'` 1 hour, `'30'`, `'15'` or `'5'` minutes
- `count`: how many hits to show in a market scan
- `nearPct`: leave at 5 unless the user asks for a different location rule

```js
(() => { const cfg = { mode: 'market', market: 'america', tickers: [], patterns: 'all', timeframe: 'D', count: 10, nearPct: 5 }; const P = [['Hammer', 'Bullish', ['Candle.Hammer']], ['Inverted Hammer', 'Bullish', ['Candle.InvertedHammer']], ['Bullish Engulfing', 'Bullish', ['Candle.Engulfing.Bullish']], ['Morning Star', 'Bullish', ['Candle.MorningStar']], ['Bullish Harami', 'Bullish', ['Candle.Harami.Bullish']], ['Three White Soldiers', 'Bullish', ['Candle.3WhiteSoldiers']], ['Dragonfly Doji', 'Bullish', ['Candle.Doji.Dragonfly']], ['Shooting Star', 'Bearish', ['Candle.ShootingStar']], ['Hanging Man', 'Bearish', ['Candle.HangingMan']], ['Bearish Engulfing', 'Bearish', ['Candle.Engulfing.Bearish']], ['Evening Star', 'Bearish', ['Candle.EveningStar']], ['Bearish Harami', 'Bearish', ['Candle.Harami.Bearish']], ['Three Black Crows', 'Bearish', ['Candle.3BlackCrows']], ['Gravestone Doji', 'Bearish', ['Candle.Doji.Gravestone']], ['Doji', 'Neutral', ['Candle.Doji']], ['Spinning Top', 'Neutral', ['Candle.SpinningTop.White', 'Candle.SpinningTop.Black']]]; const X = [['Piercing Line', 'Bullish', ['Candle.Piercing.Bullish']], ['Morning Doji Star', 'Bullish', ['Candle.MorningDojiStar.Bullish']], ['Bullish Doji Star', 'Bullish', ['Candle.DojiStar.Bullish']], ['Bullish Harami Cross', 'Bullish', ['Candle.HaramiCross.Bullish']], ['Bullish Abandoned Baby', 'Bullish', ['Candle.AbandonedBaby.Bullish']], ['Bullish Kicking', 'Bullish', ['Candle.Kicking.Bullish']], ['Bullish Tri-Star', 'Bullish', ['Candle.TriStar.Bullish']], ['Tweezer Bottom', 'Bullish', ['Candle.TweezerBottom.Bullish']], ['Rising Three Methods', 'Bullish', ['Candle.RisingThreeMethods.Bullish']], ['Rising Window', 'Bullish', ['Candle.RisingWindow.Bullish']], ['Upside Tasuki Gap', 'Bullish', ['Candle.UpsideTasukiGap.Bullish']], ['White Marubozu', 'Bullish', ['Candle.Marubozu.White']], ['Long Lower Shadow', 'Bullish', ['Candle.LongShadow.Lower']], ['Dark Cloud Cover', 'Bearish', ['Candle.DarkCloudCover.Bearish']], ['Evening Doji Star', 'Bearish', ['Candle.EveningDojiStar.Bearish']], ['Bearish Doji Star', 'Bearish', ['Candle.DojiStar.Bearish']], ['Bearish Harami Cross', 'Bearish', ['Candle.HaramiCross.Bearish']], ['Bearish Abandoned Baby', 'Bearish', ['Candle.AbandonedBaby.Bearish']], ['Bearish Kicking', 'Bearish', ['Candle.Kicking.Bearish']], ['Bearish Tri-Star', 'Bearish', ['Candle.TriStar.Bearish']], ['Tweezer Top', 'Bearish', ['Candle.TweezerTop.Bearish']], ['Falling Three Methods', 'Bearish', ['Candle.FallingThreeMethods.Bearish']], ['Falling Window', 'Bearish', ['Candle.FallingWindow.Bearish']], ['Downside Tasuki Gap', 'Bearish', ['Candle.DownsideTasukiGap.Bearish']], ['Black Marubozu', 'Bearish', ['Candle.Marubozu.Black']], ['Long Upper Shadow', 'Bearish', ['Candle.LongShadow.Upper']], ['On Neck', 'Bearish', ['Candle.OnNeck.Bearish']]]; const ALL = P.concat(X); const asked = Array.isArray(cfg.patterns) ? cfg.patterns.map(n => String(n).toLowerCase()) : []; const want = cfg.patterns === 'all' ? P : cfg.patterns === 'bullish' ? P.filter(p => p[1] === 'Bullish') : cfg.patterns === 'bearish' ? P.filter(p => p[1] === 'Bearish') : cfg.patterns === 'every' ? ALL : ALL.filter(p => asked.indexOf(p[0].toLowerCase()) >= 0); const unknown = asked.filter(n => !ALL.some(p => p[0].toLowerCase() === n)); const TF = {D: ['', 'Daily'], W: ['|1W', 'Weekly'], M: ['|1M', 'Monthly'], '240': ['|240', '4-hour'], '60': ['|60', '1-hour'], '30': ['|30', '30-minute'], '15': ['|15', '15-minute'], '5': ['|5', '5-minute']}; const tf = TF[cfg.timeframe] || TF.D; const sfx = tf[0]; const base = ['description', 'currency', 'open' + sfx, 'high' + sfx, 'low' + sfx, 'close' + sfx, 'close', 'High.1M', 'Low.1M', 'SMA50', 'SMA200', 'relative_volume_10d_calc', 'market_cap_basic', 'relative_volume_intraday|5', 'current_session']; const fields = []; want.forEach(p => p[2].forEach(f => fields.push(f + sfx))); const cols = base.concat(fields); const r1 = (x) => x == null ? null : Math.round(x * 10) / 10; const px = (x) => x == null ? null : (Math.abs(x) >= 100 ? Math.round(x * 100) / 100 : Math.round(x * 10000) / 10000); const build = (x) => { const d = x.d; const hit = want.filter(p => p[2].some(f => d[base.length + fields.indexOf(f + sfx)])); if (!hit.length) return null; const c = d[6], hi = d[7], lo = d[8]; const nearLow = lo ? (c / lo - 1) * 100 <= cfg.nearPct : false; const nearHigh = hi ? (1 - c / hi) * 100 <= cfg.nearPct : false; const where = nearLow && !nearHigh ? 'Near 1-month low' : nearHigh && !nearLow ? 'Near 1-month high' : 'Mid-range'; const sides = hit.map(p => p[1]); const bull = sides.indexOf('Bullish') >= 0, bear = sides.indexOf('Bearish') >= 0; const side = bull && !bear ? 'Bullish' : bear && !bull ? 'Bearish' : 'Neutral'; const location = side === 'Neutral' ? 'n/a' : ((side === 'Bullish' && where === 'Near 1-month low') || (side === 'Bearish' && where === 'Near 1-month high')) ? 'Good' : 'Weak'; const trend = (d[9] == null || d[10] == null) ? 'n/a' : (c > d[9] && c > d[10]) ? 'Uptrend' : (c < d[9] && c < d[10]) ? 'Downtrend' : 'Mixed'; return {symbol: x.s, name: d[0], patterns: hit.map(p => p[0]), side: side, candle: {open: px(d[2]), high: px(d[3]), low: px(d[4]), close: px(d[5])}, currency: d[1], where: where, location: location, trend: trend, volX: sfx ? null : r1(d[14] === 'market' && d[13] != null ? d[13] : d[11]), marketOpen: d[14] === 'market', cap: d[12] || 0}; }; const rank = {Good: 0, Weak: 1, 'n/a': 2}; const finish = (rowsBySymbol, totals, extra) => { const hits = Object.keys(rowsBySymbol).map(k => build(rowsBySymbol[k])).filter(Boolean); hits.sort((a, b) => (rank[a.location] - rank[b.location]) || (b.cap - a.cap)); const out = hits.slice(0, cfg.mode === 'market' ? cfg.count : 30).map(h => { delete h.cap; return h; }); window.__candleScan = JSON.stringify(Object.assign({status: 'ok', mode: cfg.mode, timeframe: tf[1], unknown: unknown, totals: totals, shown: out.length, hits: out}, extra)); }; window.__candleScan = 'pending'; const post = (url, body) => fetch(url, {method: 'POST', credentials: 'include', body: JSON.stringify(body)}).then(r => r.text().then(t => { try { return JSON.parse(t); } catch (e) { throw new Error(r.status + ' ' + t.slice(0, 150)); } })); if (cfg.mode === 'market') { const filt = [{left: 'is_primary', operation: 'equal', right: true}, {left: 'typespecs', operation: 'has', right: ['common']}, {left: 'average_volume_30d_calc', operation: 'greater', right: 500000}]; const rows = {}, totals = {}; const jobs = []; want.forEach(p => p[2].forEach(f => jobs.push(post('https://scanner.tradingview.com/' + cfg.market + '/scan', {filter: filt.concat([{left: f + sfx, operation: 'nequal', right: 0}]), options: {lang: 'en'}, markets: [cfg.market], symbols: {query: {types: ['stock']}, tickers: []}, columns: cols, sort: {sortBy: 'market_cap_basic', sortOrder: 'desc'}, range: [0, 50]}).then(j => { totals[p[0]] = (totals[p[0]] || 0) + (j.totalCount || 0); (j.data || []).forEach(x => { rows[x.s] = x; }); })))); Promise.all(jobs).then(() => finish(rows, totals, {market: cfg.market})).catch(e => { window.__candleScan = 'ERROR: ' + e.message; }); } else { post('https://scanner.tradingview.com/global/scan', {symbols: {tickers: cfg.tickers}, columns: cols}).then(j => { const rows = {}, totals = {}; (j.data || []).forEach(x => { rows[x.s] = x; }); const got = Object.keys(rows); got.forEach(k => { const h = build(rows[k]); if (h) h.patterns.forEach(n => { totals[n] = (totals[n] || 0) + 1; }); }); finish(rows, totals, {scanned: got.length, missing: cfg.tickers.filter(s => got.indexOf(s) < 0)}); }).catch(e => { window.__candleScan = 'ERROR: ' + e.message; }); } return 'started'; })()
```

Then read the result. Run this with `ui_evaluate`:

```js
window.__candleScan
```

If it says `pending`, read it again, up to three times. A market scan for many patterns can need the second or third read.

What comes back:

- `unknown`: pattern names the user asked for that TradingView does not detect. Name them in the report.
- `totals`: how many times each pattern was found. In a market scan this is the count for the whole market. In a watchlist scan it is the count on the list.
- `hits`: the hits to show, already sorted with good locations first and bigger companies before smaller ones. Each hit has the symbol, the pattern names, the type, the candle's open, high, low and close, the location and the trend. `volX` is volume against normal: for an open market (`marketOpen` is `true`) the volume so far today against the usual volume by this time of day, for a closed market the full day against the average of the previous 10 days. Use them as they are and do not recalculate.
- `scanned` and `missing` (watchlist scans): how many symbols had data, and which ones TradingView's screener does not cover (some index feeds and broker CFDs).

The rules the snippet applies:

| Word | Rule |
|---|---|
| Good location | A bullish pattern within 5% of the 1-month low, or a bearish pattern within 5% of the 1-month high |
| Weak location | A bullish or bearish pattern anywhere else |
| Uptrend | Price above both the 50-day and the 200-day moving average |
| Downtrend | Price below both |
| Mixed | Anything else |
| Market scan filter | Main listing, ordinary shares, average volume above 500,000 shares a day |

Two limits to keep honest about:

- TradingView's detection reads the newest candle only. If the market is open, that candle is not finished and the pattern can still change.
- TradingView does not publish its exact detection math. That is why every hit shows the candle's four prices.

If the result is an error, say so plainly and stop. Never report a pattern from memory or by guessing.

## Step 4: Report everything

The answer has to stand on its own.

```
Candlestick Scanner: [market or list name], [timeframe] candles

Patterns found
| Pattern | Count |
|---|---|
| Bullish Engulfing | 22 |

[shown] hits, good locations first
| Symbol | Name | Pattern | Type | Open | High | Low | Close | Location | Trend (50/200-day moving averages) | Volume vs normal |
|---|---|---|---|---|---|---|---|---|---|---|
| NYSE:CVX | Chevron Corporation | Bullish Engulfing | Bullish | 208.07 | 211.85 | 206.01 | 211.22 | Good: near 1-month low | Mixed | 1.2x |

Not covered by TradingView's screener: [symbols]

The four prices are the pattern candle, so every hit can be checked by hand.
Patterns are read from the newest candle. If the market is open, that candle is not finished yet.
A pattern is something to look at, not a signal.

Save these as a watchlist in TradingView?
```

- In "Patterns found", list only patterns with a count above 0, biggest count first. If the user asked for specific patterns, list those even when the count is 0.
- In a market scan, say that the counts are for the whole market and the table shows the top hits.
- Write the location as "Good: near 1-month low", "Weak: mid-range" and so on. For neutral patterns write only where the candle is, like "Mid-range".
- Use the full symbol so the next skill can use it as is.
- If volume is missing or 0, show "n/a". Only daily scans have a volume figure.
- When any hit has `marketOpen` `true`, add one line under the table: "Volume vs normal compares the volume so far today with the usual volume by this time of day."
- If `unknown` is not empty, add one line above the table: "TradingView does not detect: [names]."
- Leave the "Not covered" line out when nothing is missing.
- If a watchlist scan finds nothing, say so in one line: no patterns on the newest candle for the symbols on that list. Add that this is normal for a short list, and offer a market scan instead.

## Step 5: Hand over to the watchlist

If the user says yes, pass the symbols to the Watchlist Builder skill in the same order, with a short name built from the scan (for example "US Bullish Engulfing"). If that skill is not installed, say so. Do not try to create the watchlist another way.

Skip the question when a watchlist scan found nothing.

## Boundaries

- Never say buy or sell. A pattern is something to look at, not a signal.
- Never report a pattern that was not read from TradingView.
- Never refuse a pattern that is in one of the two tables.
- Never show more than 20 hits in a market scan.
- Never change anything in TradingView.

Skill 6: Volume Spike Scanner

The Volume Spike Scanner finds symbols that trade far above their normal volume. A volume spike means the volume today is at least 2 times the average of the previous 10 days.

It scans your watchlist or a whole stock market, with the biggest companies first. For every hit it shows the volume today, the normal volume, and where the price closed in the range of the day: top third, middle or bottom third.

Then it explains what happened to the top 3 hits in plain English, with links to the news sources. A volume spike shows attention, not direction.

📋 Skill 6: Volume Spike Scanner

Copy it, paste it into Claude and say: Save this as a skill, exactly as written.

Show the full skill (182 lines)
---
name: "tradingview-volume-spike-scanner"
description: "Scans a TradingView watchlist or a whole stock market for unusual volume and explains what happened to the top hits. Use for any request to find volume spikes, unusual volume or stocks with high relative volume."
---

# TradingView Volume Spike Scanner

Find symbols trading far above their normal volume, on the user's open watchlist or across a whole stock market, and say in plain English what happened to the top hits.

The skill only reads data. It changes nothing in TradingView.

## What you need

- TradingView open with the TradingView MCP connected.
- These tools: `tv_health_check`, `watchlist_get`, `ui_evaluate`.

Tool names can carry a prefix that depends on the setup. Match on the last part of the name.

Start with `tv_health_check`. If it fails, tell the user to open TradingView with the MCP connected, and stop.

## Step 1: Get the inputs

| Input | Meaning | If missing |
|---|---|---|
| Where | The open watchlist, or one market (a country) | The open watchlist |
| How big | Volume as a multiple of normal | 2 |
| Direction | Up days, down days or both | Both |
| Order | Biggest companies first, or biggest spikes first | Biggest companies first |
| How many | For a market scan only | 10, at most 20 |

Nothing here needs a question. If the user gave no details, scan the open watchlist with the defaults.

The exact rule depends on whether the market is open, because a half-finished day cannot be compared with full days:

- **Market closed:** the full day's volume is at least 2 times the average of the previous 10 days. This is TradingView's "relative volume".
- **Market open:** the volume so far today is at least 2 times the usual volume by this time of day. This is TradingView's "relative volume at time".

The snippet reads from TradingView whether the market is open and picks the right number by itself.

If the user asks for "biggest spikes first" in a market scan, do it, and warn in one line that very small and very cheap stocks will fill the top of the list.

## Step 2: Fill in the settings

- **Watchlist scan:** run `watchlist_get` and keep the list name and every full symbol (like `NASDAQ:NVDA`). If the list is empty, say so and stop.
- **Market scan:** pick the market code.

| Market | Code |
|---|---|
| US | `america` |
| India | `india` |
| UK | `uk` |
| Canada | `canada` |
| Germany | `germany` |
| Australia | `australia` |
| Sweden | `sweden` |
| Nigeria | `nigeria` |
| Kenya | `kenya` |
| South Africa | `rsa` |
| Pakistan | `pakistan` |
| Philippines | `philippines` |

For another country, try its English name in lowercase. If the scan returns an error, tell the user that market is not available.

A market scan covers stocks only.

## Step 3: Run the scan

Run this with `ui_evaluate`. Change only the `cfg` object at the start:

- `mode`: `'market'` or `'watchlist'`
- `market`: the code from Step 2 (market scans)
- `tickers`: the full symbols from the watchlist (watchlist scans)
- `minX`: the multiple of normal volume
- `direction`: `'both'`, `'up'` or `'down'`
- `order`: `'size'` for biggest companies first, `'spike'` for biggest spikes first
- `count`: how many hits to show in a market scan

```js
(() => { const cfg = { mode: 'market', market: 'america', tickers: [], minX: 2, direction: 'both', order: 'size', count: 10, nearPct: 5 }; const cols = ['description', 'currency', 'close', 'change', 'volume', 'relative_volume_10d_calc', 'open', 'high', 'low', 'High.1M', 'Low.1M', 'SMA50', 'SMA200', 'market_cap_basic', 'relative_volume_intraday|5', 'current_session']; const r1 = (x) => x == null ? null : Math.round(x * 10) / 10; const px = (x) => x == null ? null : (Math.abs(x) >= 100 ? Math.round(x * 100) / 100 : Math.round(x * 10000) / 10000); const fmt = (n) => n == null ? null : n >= 1e9 ? (n / 1e9).toFixed(2) + 'B' : n >= 1e6 ? (n / 1e6).toFixed(1) + 'M' : n >= 1e3 ? Math.round(n / 1e3) + 'K' : String(Math.round(n)); const build = (x) => { const d = x.d; const open = d[15] === 'market'; const vx = open && d[14] != null ? d[14] : d[5]; const c = d[2], hi = d[7], lo = d[8]; const pos = hi > lo ? (c - lo) / (hi - lo) : null; const nearLow = d[10] ? (c / d[10] - 1) * 100 <= cfg.nearPct : false; const nearHigh = d[9] ? (1 - c / d[9]) * 100 <= cfg.nearPct : false; return {symbol: x.s, name: d[0], price: px(c), currency: d[1], day: r1(d[3]), volume: fmt(d[4]), normal: vx ? fmt(d[4] / vx) : null, volX: r1(vx), marketOpen: open, closedIn: pos == null ? 'n/a' : pos >= 2 / 3 ? 'Top third' : pos <= 1 / 3 ? 'Bottom third' : 'Middle', where: nearLow && !nearHigh ? 'Near 1-month low' : nearHigh && !nearLow ? 'Near 1-month high' : 'Mid-range', trend: (d[11] == null || d[12] == null) ? 'n/a' : (c > d[11] && c > d[12]) ? 'Uptrend' : (c < d[11] && c < d[12]) ? 'Downtrend' : 'Mixed', raw: vx || 0, cap: d[13] || 0, chg: d[3] || 0}; }; const clean = (h) => { delete h.raw; delete h.cap; delete h.chg; return h; }; window.__volScan = 'pending'; const post = (url, body) => fetch(url, {method: 'POST', credentials: 'include', body: JSON.stringify(body)}).then(r => r.text().then(t => { try { return JSON.parse(t); } catch (e) { throw new Error(r.status + ' ' + t.slice(0, 150)); } })); if (cfg.mode === 'market') { const url = 'https://scanner.tradingview.com/' + cfg.market + '/scan'; const basic = [{left: 'is_primary', operation: 'equal', right: true}, {left: 'typespecs', operation: 'has', right: ['common']}, {left: 'average_volume_30d_calc', operation: 'greater', right: 500000}]; post(url, {filter: basic, options: {lang: 'en'}, markets: [cfg.market], symbols: {query: {types: ['stock']}, tickers: []}, columns: ['current_session'], sort: {sortBy: 'market_cap_basic', sortOrder: 'desc'}, range: [0, 5]}).then(s => { const isOpen = (s.data || []).filter(x => x.d[0] === 'market').length >= 3; const rv = isOpen ? 'relative_volume_intraday|5' : 'relative_volume_10d_calc'; const filt = basic.concat([{left: rv, operation: 'egreater', right: cfg.minX}]); const dir = (s) => s === 'up' ? [{left: 'change', operation: 'greater', right: 0}] : s === 'down' ? [{left: 'change', operation: 'less', right: 0}] : []; const body = (extra, range) => ({filter: filt.concat(extra), options: {lang: 'en'}, markets: [cfg.market], symbols: {query: {types: ['stock']}, tickers: []}, columns: cols, sort: {sortBy: cfg.order === 'spike' ? rv : 'market_cap_basic', sortOrder: 'desc'}, range: [0, range]}); return Promise.all([post(url, body(dir(cfg.direction), cfg.count)), post(url, body(dir('up'), 1)), post(url, body(dir('down'), 1))]).then(a => { const hits = (a[0].data || []).map(build).map(clean); window.__volScan = JSON.stringify({status: 'ok', mode: 'market', market: cfg.market, marketOpen: isOpen, minX: cfg.minX, direction: cfg.direction, order: cfg.order, total: a[0].totalCount, up: a[1].totalCount, down: a[2].totalCount, shown: hits.length, hits: hits}); }); }).catch(e => { window.__volScan = 'ERROR: ' + e.message; }); } else { post('https://scanner.tradingview.com/global/scan', {symbols: {tickers: cfg.tickers}, columns: cols}).then(j => { const all = (j.data || []).map(build); const got = all.map(h => h.symbol); const pass = all.filter(h => h.raw >= cfg.minX && (cfg.direction === 'both' || (cfg.direction === 'up' ? h.chg > 0 : h.chg < 0))); pass.sort((a, b) => cfg.order === 'spike' ? b.raw - a.raw : b.cap - a.cap); const best = all.slice().sort((a, b) => b.raw - a.raw)[0]; window.__volScan = JSON.stringify({status: 'ok', mode: 'watchlist', marketOpen: all.some(h => h.marketOpen), minX: cfg.minX, direction: cfg.direction, order: cfg.order, scanned: got.length, missing: cfg.tickers.filter(s => got.indexOf(s) < 0), total: pass.length, up: pass.filter(h => h.chg > 0).length, down: pass.filter(h => h.chg < 0).length, highest: best ? {symbol: best.symbol, volX: best.volX} : null, shown: pass.length, hits: pass.map(clean)}); }).catch(e => { window.__volScan = 'ERROR: ' + e.message; }); } return 'started'; })()
```

Then read the result. Run this with `ui_evaluate`:

```js
window.__volScan
```

If it says `pending`, read it again, up to three times.

What comes back:

- `total`, `up`, `down`: how many symbols qualify, and how many of them rose or fell today. In a market scan these count the whole market. Some qualifying stocks are unchanged on the day, so up plus down can be less than the total.
- `marketOpen`: `true` when the market is open right now. In a watchlist scan it is `true` when at least one symbol's market is open, and every hit has its own `marketOpen`.
- `hits`: the hits to show, already in the right order. `volume` is today's volume. When the market is closed, `normal` is the average full day of the previous 10 days. When it is open, `normal` is the usual volume by this time of day. `volX` is how many times normal. `closedIn`, `where` and `trend` are already worked out by the rules below. Use them as they are and do not recalculate.
- `scanned`, `missing` and `highest` (watchlist scans): how many symbols had data, which ones TradingView's screener does not cover, and the symbol with the highest volume against normal on the list.

The rules the snippet applies:

| Word | Rule |
|---|---|
| Volume spike, market closed | The full day's volume at least `minX` times the average of the previous 10 days |
| Volume spike, market open | The volume so far today at least `minX` times the usual volume by this time of day |
| Closed in the top third | The close (or the latest price while the market is open) is in the upper third of the day's range, from low to high |
| Closed in the bottom third | The close is in the lower third of the day's range |
| Near the 1-month high or low | Within 5% |
| Uptrend | Price above both the 50-day and the 200-day moving average |
| Downtrend | Price below both |
| Mixed | Anything else |
| Market scan filter | Main listing, ordinary shares, average volume above 500,000 shares a day |

If the result is an error, say so plainly and stop. Never report a number from memory or by guessing.

## Step 4: Find out what happened to the top three hits

A volume spike nearly always has a reason. The news comes from TradingView's own news feed, so no web search is needed. Run this with `ui_evaluate`. Change only `symbols`: the first three symbols in `hits`. Skip this step if there are no hits.

```js
(() => { const symbols = ['NASDAQ:NVDA', 'NASDAQ:TTWO', 'NYSE:GFL']; const hours = 48, perSymbol = 8; window.__scanNews = {}; const cutoff = Date.now() / 1000 - hours * 3600; symbols.forEach(s => { window.__scanNews[s] = 'pending'; fetch('https://news-headlines.tradingview.com/v2/headlines?client=web&lang=en&symbol=' + encodeURIComponent(s), {credentials: 'include'}).then(r => r.json()).then(j => { window.__scanNews[s] = (j.items || []).filter(i => i.published >= cutoff).sort((a, b) => b.published - a.published).slice(0, perSymbol).map(i => ({title: (i.title || '').slice(0, 160), source: i.source || i.provider, date: new Date(i.published * 1000).toISOString().slice(0, 16).replace('T', ' '), link: 'https://www.tradingview.com' + i.storyPath})); }).catch(e => { window.__scanNews[s] = 'ERROR: ' + e.message; }); }); return 'started'; })()
```

Then read the result with `ui_evaluate`:

```js
JSON.stringify(window.__scanNews)
```

If a symbol still says `pending`, read again, up to three times. Each symbol comes back with up to eight headlines from the last 48 hours: title, source, date (UTC) and link.

Read all the headlines for a symbol together and work out the main story. Then write what happened in plain English, the way you would tell a friend who has not seen the news.

- One or two short sentences per symbol. Lead with the main story, the one most of the headlines are about.
- Say it plainly. Never hide the main story behind a side detail. If the news is that a company reported earnings, lost a deal, or that its CEO admitted to something, say exactly that and name the source ("Reuters reports that...").
- Explain jargon in a few words. The reader should not need a dictionary to understand the line.
- Stick to what the headlines say. Add nothing from your own memory, and do not speculate about what it means for the stock.
- If a headline itself links the news to the price move, you can say that the source makes that link. Do not make the link yourself.
- End with the one or two most useful sources as links.
- If a symbol has no headlines, or the read fails, write "No recent news in TradingView's feed."

## Step 5: Report everything

The answer has to stand on its own.

```
Volume Spike Scanner: [market or list name]
[Market closed] Rule: the full day's volume at least [2] times the average of the previous 10 days.
[Market open] Rule: the volume so far today at least [2] times the usual volume by this time of day. The market is open, so the day is not finished.

[total] qualify: [up] up, [down] down. Showing [shown], [order in plain words].

| Symbol | Name | Price | 1 day | Volume today | Normal volume | Times normal | Position in day's range | Location | Trend (50/200-day moving averages) |
|---|---|---|---|---|---|---|---|---|---|
| NASDAQ:NVDA | NVIDIA Corporation | 168.89 USD | -5.5% | 429.3M | 173.3M | 2.5x | Middle | Near 1-month low | Downtrend |

What happened (news on the top 3)
- NVDA: [one or two plain sentences]. Sources: [Source name](link), [Source name](link)

Not covered by TradingView's screener: [symbols]

A volume spike shows attention, not direction.

Save these as a watchlist in TradingView?
```

- Write only the rule line that fits `marketOpen`, without the label in brackets.
- When the market is open, name the columns "Volume so far today" and "Normal by this time".
- If a watchlist mixes open and closed markets, write both rule lines and add a column "Market" with Open or Closed.
- Use the full symbol in the table so the next skill can use it as is.
- In a market scan, say that the counts are for the whole market and the table shows the top hits.
- Leave the "Not covered" line out when nothing is missing.
- If a watchlist scan finds nothing, say so in one line and name the highest one: "No symbol on [list] traded at [2] times normal or more. The highest is [symbol] at [x] times." Then offer a market scan instead, and skip the watchlist question.

## Step 6: Hand over to the watchlist

If the user says yes, pass the symbols to the Watchlist Builder skill in the same order, with a short name built from the scan (for example "US Volume Spikes"). If that skill is not installed, say so. Do not try to create the watchlist another way.

## Boundaries

- Never say buy or sell. A volume spike shows attention, not direction.
- Never report a number that was not read from TradingView.
- Never invent news or guess why something moved. Say what the sources report, and name them.
- Never show more than 20 hits in a market scan.
- Never change anything in TradingView.

Skill 7: Alert Setter

The Alert Setter turns a trade plan on your chart into price alerts. You draw a Long Position or Short Position tool on your chart, then run the skill.

Claude reads the entry, the stop and the target from the drawing and shows the reward to risk. It asks first, then creates the price alerts. Each alert fires once, when the price crosses its level.

If there is no drawing on the chart, you can type the prices instead, up to five. The skill never deletes or changes an alert that already exists.

📋 Skill 7: Alert Setter

Copy it, paste it into Claude and say: Save this as a skill, exactly as written.

Show the full skill (110 lines)
---
name: "tradingview-alert-setter"
description: "Sets TradingView price alerts at the entry, stop and target of the Long or Short Position tool on the chart, or at prices the user types. Use for any request to set, create or add alerts."
---

# TradingView Alert Setter

Read the Long Position or Short Position tool the user drew on their TradingView chart, and turn its entry, stop and target into price alerts.

Alerts are only created after the user says yes.

## What you need

- TradingView open with the TradingView MCP connected.
- These tools: `tv_health_check`, `ui_evaluate`, `alert_create`, `alert_list`, `symbol_search`, `chart_set_symbol`.

Tool names can carry a prefix that depends on the setup. Match on the last part of the name.

Start with `tv_health_check`. If it fails, tell the user to open TradingView with the MCP connected, and stop.

## Step 1: Read the position tool on the chart

Run this with `ui_evaluate`. Do not change it.

```js
(() => { try { const chart = window.TradingViewApi.activeChart(); const series = chart._chartWidget.model().mainSeries(); const si = series.symbolInfo(); const tick = si.minmov / si.pricescale; const dec = Math.max(0, Math.round(Math.log10(si.pricescale))); const rd = (x) => Number(x.toFixed(dec)); let last = null; try { last = parseFloat(String(series.lastValueData(4, true).text).replace(/,/g, '')); } catch (e) {} const pct = (x) => last ? Math.round((x / last - 1) * 1000) / 10 : null; const pos = chart.getAllShapes().filter(s => s.name === 'long_position' || s.name === 'short_position').map(s => { const sh = chart.getShapeById(s.id); const pts = sh.getPoints(); const p = sh.getProperties(); const long = s.name === 'long_position'; const entry = pts[0].price; const stop = long ? entry - p.stopLevel * tick : entry + p.stopLevel * tick; const target = long ? entry + p.profitLevel * tick : entry - p.profitLevel * tick; return {id: s.id, side: long ? 'Long' : 'Short', entry: rd(entry), stop: rd(stop), target: rd(target), riskPerUnit: rd(Math.abs(entry - stop)), rewardPerUnit: rd(Math.abs(target - entry)), rewardToRisk: p.stopLevel ? Math.round(p.profitLevel / p.stopLevel * 100) / 100 : null, entryFromPrice: pct(entry), stopFromPrice: pct(stop), targetFromPrice: pct(target), entryAtPrice: last ? Math.abs(entry / last - 1) * 100 <= 0.2 : false}; }); return JSON.stringify({status: 'ok', symbol: chart.symbol(), currency: si.currency_code, price: last, positions: pos}); } catch (e) { return 'ERROR: ' + e.message; } })()
```

It answers straight away with the chart's symbol, the current price, and every position tool on the chart: side, entry, stop, target, risk and reward per unit, reward to risk, and how far each level is from the current price in percent. All numbers are already worked out. Use them as they are and do not recalculate.

What to do with the answer:

- **One position:** use it.
- **No position:** say that there is no Long or Short Position tool on the chart. Ask the user to draw one and say "ready", or to type the prices instead.
- **More than one position:** list them (side, entry, stop, target) and ask which one.
- **An error:** say that the drawing could not be read, and ask the user to type the prices instead.

## Step 2: Build the plan

**From a position tool:** three alerts, at the entry, the stop and the target.

If `entryAtPrice` is true, the entry is within 0.2% of the current price. Leave the entry alert out and say why: it would fire straight away.

**From typed prices:** one alert per price, at most 5. If the user names a symbol that is not on the chart, find its full name with `symbol_search`, switch with `chart_set_symbol`, and run the Step 1 snippet again to get the current price. Alerts are always set on the symbol that is on the chart.

Every alert is a "crossing" alert: it fires when the price crosses the level in either direction. Use `greater_than` or `less_than` only if the user asks for "above" or "below".

## Step 3: Show the plan and wait for a yes

```
Alert plan: [SYMBOL], [Long or Short] position
Price now: [price] [currency]

| Alert | Price | From current price |
|---|---|---|
| Entry | 700.00 | -2.5% |
| Stop | 642.44 | -10.5% |
| Target | 757.56 | +5.5% |

Risk per share: 57.56. Reward per share: 57.56. Reward to risk: 1.0 to 1.

Each alert fires once, when the price crosses its level.

Create these 3 alerts?
```

- Say "per share" for stocks and "per unit" for anything else.
- For typed prices, leave out the position line and the risk and reward line.
- Do not comment on whether the trade is good. The numbers speak for themselves.

Then stop and wait. Creating alerts changes the user's TradingView account, so it needs a clear yes every time.

## Step 4: Create the alerts

For each alert, run `alert_create` with:

- `condition`: `crossing`
- `price`: the level
- `message`: short and clear, like `TMO long: stop 642.44`

Create them one at a time, in the order entry, stop, target, and check `success` each time. Keep the `alert_id` of each one.

**If one fails:** stop. Do not retry in a loop. Report which alerts were created and which were not. The usual reason is the plan limit: TradingView's free plan allows 3 price alerts.

## Step 5: Read the alert list back and report

Run `alert_list` and find the alerts you just created by their ids. The list can contain long settings data for other alerts. Ignore it.

```
Alerts created on [SYMBOL]

| Alert | Price | Fires | Expires |
|---|---|---|---|
| Entry | 700.00 | Once, on crossing | 2026-12-11 |
| Stop | 642.44 | Once, on crossing | 2026-12-11 |
| Target | 757.56 | Once, on crossing | 2026-12-11 |

You now have [N] active alerts in TradingView.
Not created: [alert and reason, or leave this line out]
```

Only what the read-back shows counts as created. Take the expiry date from the list. If an alert has no expiry, write "No expiry".

## Boundaries

- Never create an alert without a clear yes.
- Never delete or change an alert that already exists, and never use the delete-all option. If the user wants an alert removed, tell them to do it in TradingView's alert panel.
- Never move, change or remove a drawing.
- Never create more than 5 alerts in one run.
- Never say buy or sell, and never judge the trade.

Limits and Safe Use

The skills are tools for preparation, and they have clear limits.

  • The connection is unofficial. A TradingView update can break the connection, and a skill with it.

  • Your TradingView plan sets the ceiling. The cheapest paid plan, Essential, allows 2 charts per tab, 5 indicators per chart and 20 price alerts. You find the current numbers on the TradingView pricing page. The four-chart view in the Morning Brief needs a plan with 4 charts per tab. When a skill hits a plan limit, it stops and tells you what it could not do.

  • Facts, not signals. A flag, a pattern or a volume spike is something to look at. None of the skills tells you to buy or sell.

  • You make every decision. The skills never place a trade, and the connection has no access to your broker.

  • AI can make mistakes. Check a number on your own chart before you rely on it.

Frequently Asked Questions

Are these Claude Skills free?

Yes. All 7 Claude Skills on this page are free to copy and use. To run them you need the Claude desktop app, the TradingView desktop app and the connection between the two.

Do Claude Skills work on the free Claude plan?

Yes. Anthropic lists Skills as available on the Free, Pro, Max, Ultra, Team and Enterprise plans. Skills need code execution, so the setting "Code execution and file creation" has to be turned on in Claude. Heavier use benefits from a paid Claude plan.

Do I need a paid TradingView plan?

Yes. The connection between Claude and TradingView needs the TradingView desktop app with a paid plan, and the cheapest tier works. The plan limits still apply inside the skills. On the Essential plan that means 2 charts per tab, 5 indicators per chart and 20 price alerts.

Can a Claude Skill place trades for me?

No. These 7 skills read data, set up charts, build watchlists and create price alerts. They never place a trade and they never say buy or sell. You make every trading decision.

Is the Claude and TradingView connection official?

No. The TradingView MCP is an independent open-source project. It is not made by TradingView or Anthropic. A TradingView update can break it for a while, and the skills stop working until the connection is fixed.

Can I change the rules inside a skill?

Yes. A skill is plain text, so every rule is visible when you open the box. You can replace a number in your request, for example "revenue growth above 25%" in the Stock Picker. You can also edit the skill text before you save it.

For Channel Members

Channel members get two extras with this course:

  • Gold and higher: the full PDF study guide

  • Diamond and higher: a members-only video on how to build your own Claude Skills

You find the study guide on the members page. If you are not a member yet, you can join the channel on YouTube.

Mind Math Daily is my free newsletter on trading and markets. You can sign up on the homepage.

[Affiliate disclosure] This article contains affiliate links. Mind Math Money only recommends tools personally used and trusted.

[Financial disclaimer] This is educational content, not financial advice. Markets involve risk. Do your own research before making investment decisions.

This article is the companion page to the Mind Math Money Claude Skills course on YouTube. Mind Math Money is an independent trading and markets educator. The TradingView MCP is an independent open-source project and is not affiliated with TradingView or Anthropic.

A note on AI tools: these skills worked in my own setup. AI language models can still make mistakes, so check the numbers on your own chart.

Next
Next

TradingView Black Friday 2026: Up to 80% Off + 1 Month Free (Dates, Prices, Best Plan)