# TradingView Screener (`scrapix/tradingview-screener`) Actor

Screen and export TradingView data for stocks, crypto, forex, and indices — straight to JSON, CSV, or Excel.  You can build TradingView's own screener: market cap, price, volume, RSI, MACD, moving averages (SMA/EMA), P/E, dividend yield, performance, and 100+ more fields. No API Key needed

- **URL**: https://apify.com/scrapix/tradingview-screener.md
- **Developed by:** [Saleem Javed](https://apify.com/scrapix) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## TradingView Screener — Stock, Crypto & Forex Scanner (No Login, No API Key)

**Screen and export TradingView data for stocks, crypto, forex, and indices** —
straight to JSON, CSV, or Excel. This TradingView screener (scanner) runs any
filter you can build in TradingView's own screener: market cap, price, volume,
RSI, MACD, moving averages (SMA/EMA), P/E, dividend yield, performance, and 100+
more fields — across US and global markets, with **no TradingView account or API
key required**.

Use it for stock screening, crypto screening, technical-analysis scans, watchlist
monitoring, backtesting datasets, and feeding dashboards, spreadsheets, or
trading bots.

### Why use this TradingView screener

Built to go beyond basic screener actors:

- **Arbitrary filters** — combine any number of conditions on any field (not just
  a single "minimum market cap").
- **More than 500 results** — paginates past TradingView's response cap up to
  your chosen limit.
- **Any market in one run** — US, India, UK, Germany, Japan, and more, plus
  crypto and forex.
- **Pick your own columns** — return exactly the native TradingView fields you
  want, including every major technical indicator.
- **Sort by any column**, ascending or descending.
- **One-click preset screens** — top gainers, top losers, most active, oversold
  RSI, overbought RSI, high dividend, high-volume breakouts, large-cap leaders,
  and a full per-symbol technical snapshot.
- **No login, no API key, no scraping headaches** — pure HTTP, ready to schedule.

### What you can do with it

- **Stock screener / stock scanner** — find oversold large caps, breakout
  candidates, high-dividend payers, momentum leaders, 52-week movers.
- **Crypto screener** — rank coins and perpetuals by 24h volume, change, or
  market cap.
- **Forex screener** — scan currency pairs by change and volatility.
- **Single-stock data export** — pull a full technical + fundamental snapshot
  (OHLC, RSI, MACD, SMA/EMA, performance, ratings) for one or many tickers.
- **Automated watchlist monitoring** — schedule daily/intraday runs and push
  results to Google Sheets, Slack, a database, or your own app via the Apify API
  and integrations (Make, Zapier, webhooks).

### Supported markets

Equities across global exchanges — `america`, `india`, `uk`, `germany`, `france`,
`spain`, `italy`, `japan`, `china`, `hongkong`, `korea`, `taiwan`, `australia`,
`canada`, `brazil`, and more — plus `crypto`, `forex`, `coin` (spot crypto), and
`cfd`. Results are tagged with the market they came from.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `markets` | array\<string> | `["america"]` | Markets to scan, e.g. `["america"]`, `["crypto"]`, `["america","india"]`. |
| `preset` | string (enum) | `"none"` | Optional ready-made screen (see below). Merges with your own settings. |
| `filters` | array\<object> | `[]` | Conditions, AND-combined: `{"left": field, "operation": op, "right": value}`. |
| `columns` | array\<string> | preset/default | Native TradingView field names to return. Empty ⇒ preset columns, else a sensible stock default. |
| `symbols` | array\<string> | `[]` (whole market) | Restrict to specific `EXCHANGE:SYMBOL` tickers. |
| `sortBy` | string | — | Any column name to sort by. Overrides the preset's sort. |
| `sortOrder` | string (enum) | `"desc"` | `desc` or `asc`. |
| `maxResults` | integer (1–50000) | `100` | Total rows across all markets (paginated past 500). |
| `decimals` | integer (0–12) | `4` | Round floating-point values (price, % change, indicators) to this many decimals. Raise to `8` for crypto/forex micro-prices. |
| `proxyConfiguration` | object | Apify proxy | Proxy used to reach TradingView. |

**Filter operations:** `greater`, `egreater` (≥), `less`, `eless` (≤),
`in_range` / `not_in_range` (`right` = `[min, max]`), `equal`, `nequal`,
`match` (text).

**Presets:** `top_gainers`, `top_losers`, `most_active`, `oversold_rsi`,
`overbought_rsi`, `high_dividend`, `high_volume_breakouts`, `large_cap_leaders`,
`full_technicals` (OHLC, RSI, MACD, SMA/EMA 20/50/200, daily/weekly/monthly
candle change, 3M–1Y performance, Bollinger/VWAP, and TradingView ratings —
pair with `symbols`).

#### Full input (all fields)

A copy-paste example exercising every field:

```json
{
  "markets": ["america"],
  "preset": "none",
  "filters": [
    { "left": "market_cap_basic", "operation": "egreater", "right": 1000000000 },
    { "left": "volume", "operation": "egreater", "right": 500000 }
  ],
  "columns": ["name", "close", "change", "change|1W", "change|1M",
              "volume", "RSI", "SMA50", "SMA200", "market_cap_basic", "sector"],
  "symbols": [],
  "sortBy": "market_cap_basic",
  "sortOrder": "desc",
  "maxResults": 200,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

#### More examples

Oversold large caps in the US:

```json
{
  "markets": ["america"],
  "filters": [
    { "left": "market_cap_basic", "operation": "egreater", "right": 10000000000 },
    { "left": "RSI", "operation": "less", "right": 30 }
  ],
  "columns": ["name", "close", "change", "RSI", "market_cap_basic", "sector"],
  "sortBy": "RSI",
  "sortOrder": "asc",
  "maxResults": 100
}
```

Top crypto by 24h volume:

```json
{
  "markets": ["crypto"],
  "columns": ["base_currency", "close", "change", "24h_vol|5"],
  "sortBy": "24h_vol|5",
  "sortOrder": "desc",
  "maxResults": 50
}
```

Use a preset as-is:

```json
{ "preset": "high_volume_breakouts", "markets": ["america"], "maxResults": 50 }
```

Full technical snapshot for one or several symbols — OHLC, RSI, MACD, every
SMA/EMA, daily/weekly/monthly candle change, ratings, and more in one record
each:

```json
{
  "preset": "full_technicals",
  "markets": ["america"],
  "symbols": ["NASDAQ:AAPL", "NYSE:KO"],
  "maxResults": 10
}
```

### Output

One dataset record per matching symbol. Every record carries five fixed fields,
followed by one key per requested column (native TradingView field name → value).
Export the dataset as **JSON, CSV, Excel, XML, or HTML** from the Apify Console or
API.

#### Output schema (always present)

| Field | Type | Description |
|---|---|---|
| `symbol` | string | Full TradingView symbol, `EXCHANGE:TICKER`. |
| `exchange` | string | null | Exchange portion of the symbol. |
| `ticker` | string | null | Ticker portion of the symbol. |
| `market` | string | Market this row was scanned from. |
| `scrapedAt` | string | UTC timestamp (ISO 8601) the row was fetched. |
| *(your columns)* | number | string | null | One key per requested column; `null` when TradingView has no value. |

#### Sample record (simple columns)

From the full-input example above:

```json
{
  "symbol": "NASDAQ:NVDA",
  "exchange": "NASDAQ",
  "ticker": "NVDA",
  "market": "america",
  "scrapedAt": "2026-06-22T10:00:00+00:00",
  "name": "NVDA",
  "close": 210.69,
  "change": 2.95,
  "change|1W": 4.81,
  "change|1M": 12.34,
  "volume": 241271170,
  "RSI": 61.2,
  "SMA50": 188.4,
  "SMA200": 142.7,
  "market_cap_basic": 5098698059082,
  "sector": "Electronic Technology"
}
```

#### Sample record (`full_technicals` preset)

A complete per-symbol snapshot (real values for `NASDAQ:AAPL`):

```json
{
  "symbol": "NASDAQ:AAPL",
  "exchange": "NASDAQ",
  "ticker": "AAPL",
  "market": "america",
  "scrapedAt": "2026-06-22T06:15:20+00:00",
  "name": "AAPL",
  "description": "Apple Inc.",
  "sector": "Electronic Technology",
  "open": 298.11,
  "high": 300.57,
  "low": 295.62,
  "close": 298.01,
  "volume": 85961793,
  "average_volume_10d_calc": 56183193.5,
  "change": 0.70,
  "change_abs": 2.06,
  "change|1W": 2.36,
  "change|1M": -4.50,
  "Perf.3M": 20.18,
  "Perf.6M": 9.50,
  "Perf.Y": 52.09,
  "Perf.YTD": 9.46,
  "Volatility.D": 1.67,
  "RSI": 50.94,
  "RSI7": 48.47,
  "MACD.macd": 1.18,
  "MACD.signal": 3.22,
  "Stoch.K": 34.49,
  "Stoch.D": 31.53,
  "CCI20": -53.92,
  "ADX": 27.29,
  "ATR": 7.09,
  "Mom": -13.22,
  "AO": -2.62,
  "SMA20": 303.40,
  "SMA50": 288.74,
  "SMA200": 268.19,
  "EMA20": 298.59,
  "EMA50": 290.38,
  "EMA200": 266.89,
  "BB.upper": 318.96,
  "BB.lower": 287.83,
  "VWAP": 298.07,
  "Recommend.All": 0.11,
  "Recommend.MA": 0.13,
  "Recommend.Other": 0.09,
  "market_cap_basic": 4376979237699,
  "price_earnings_ttm": 36.05,
  "earnings_per_share_basic_ttm": 8.30,
  "dividend_yield_recent": 0.36
}
```

### Popular fields & technical indicators

Request any of these in `columns` (native TradingView names):

- **Price & volume:** `open`, `high`, `low`, `close`, `volume`,
  `average_volume_10d_calc`, `relative_volume_10d_calc`, `VWAP`.
- **Change & performance:** `change` (daily %), `change|1W` (weekly candle),
  `change|1M` (monthly candle), `Perf.W`, `Perf.1M`, `Perf.3M`, `Perf.6M`,
  `Perf.Y`, `Perf.YTD`, `Volatility.D`.
- **Moving averages:** `SMA20`, `SMA50`, `SMA200`, `EMA20`, `EMA50`, `EMA200`.
- **Oscillators & momentum:** `RSI`, `RSI7`, `MACD.macd`, `MACD.signal`,
  `Stoch.K`, `Stoch.D`, `CCI20`, `ADX`, `ATR`, `Mom`, `AO`.
- **Bands & ratings:** `BB.upper`, `BB.lower`, `Recommend.All`, `Recommend.MA`,
  `Recommend.Other`.
- **Fundamentals:** `market_cap_basic`, `price_earnings_ttm`,
  `earnings_per_share_basic_ttm`, `dividend_yield_recent`, `sector`.
- **Crypto fields:** `base_currency`, `close`, `change`, `24h_vol|5`,
  `market_cap_calc`.

### FAQ

**Do I need a TradingView account or API key?**
No. The actor uses TradingView's public scanner endpoint — no login, no key.

**Which markets and exchanges are supported?**
US and dozens of global equity markets, plus crypto, forex, spot crypto, and CFDs.
See "Supported markets" above.

**Can I screen crypto and forex, not just stocks?**
Yes — set `markets` to `["crypto"]` or `["forex"]`. Note that crypto/forex use
different field names than equities (e.g. `base_currency`, `market_cap_calc`).

**Can I get data for a single stock or a specific list of tickers?**
Yes — put `EXCHANGE:SYMBOL` values in `symbols` (e.g. `["NASDAQ:AAPL"]`). Pair it
with the `full_technicals` preset to get a complete OHLC + indicator snapshot per
ticker.

**Which technical indicators are available?**
RSI, MACD, SMA/EMA (20/50/200), Stochastic, CCI, ADX, ATR, Momentum, Awesome
Oscillator, Bollinger Bands, VWAP, and TradingView's buy/sell ratings — plus
fundamentals like P/E, EPS, market cap, and dividend yield.

**How many results can I get?**
Up to `maxResults` (default 100, max 50000). The actor paginates past
TradingView's 500-row response limit automatically.

**In what format can I export the data?**
The dataset exports to JSON, CSV, Excel, XML, and HTML via the Apify Console or
API, and can be pushed to other apps with Apify integrations.

**Can I run it on a schedule?**
Yes — use Apify Schedules to run it hourly/daily and integrate the output with
Make, Zapier, webhooks, or the Apify API.

**Is the data real-time?**
Quotes are delayed (as with most non-licensed feeds) and intended for screening
and analysis, not as a licensed real-time market-data source.

### Notes

- `maxResults` is a **total** budget across markets, consumed in the order you
  list them — give it enough room to reach later markets.
- Field names differ by asset class; an equity column requested against `crypto`
  may cause that market to be skipped (logged in the run).
- This actor is an independent tool and is not affiliated with or endorsed by
  TradingView. "TradingView" is a trademark of its respective owner. Use the data
  in accordance with TradingView's terms.

# Actor input Schema

## `markets` (type: `array`):

One or more TradingView markets to scan (results are tagged with their market). Stocks: america, india, uk, germany, france, japan, china, korea, australia, canada, brazil, … Other asset classes: crypto, forex, coin (spot crypto), cfd. Note: column/filter field names differ between equities and crypto/forex.

## `preset` (type: `string`):

Optional ready-made screen. Seeds filters, columns, and sort; your own filters/columns/sort below merge on top. Presets target equity markets.

## `filters` (type: `array`):

Screener conditions, AND-combined. Each is {"left": <field>, "operation": <op>, "right": <value>}. Operations: greater, egreater (>=), less, eless (<=), in\_range / not\_in\_range (right = \[min,max]), equal, nequal, match (text). Example: \[{"left":"market\_cap\_basic","operation":"egreater","right":1000000000},{"left":"RSI","operation":"less","right":30}].

## `columns` (type: `array`):

TradingView field names to return per row (native names, e.g. close, change, volume, market\_cap\_basic, price\_earnings\_ttm, RSI, SMA50, SMA200, sector, dividend\_yield\_recent). Leave empty to use the preset's columns or a sensible stock default. For crypto use e.g. base\_currency, close, change, 24h\_vol|5, market\_cap\_calc.

## `symbols` (type: `array`):

Restrict the scan to specific tickers in EXCHANGE:SYMBOL form (e.g. NASDAQ:AAPL). Filters still apply within this set. Leave empty to scan the whole market.

## `sortBy` (type: `string`):

Any column name to sort by (e.g. volume, market\_cap\_basic, change, RSI, Recommend.All). Overrides the preset's sort. Leave empty to use the preset default or TradingView's default order.

## `sortOrder` (type: `string`):

Sort direction.

## `maxResults` (type: `integer`):

Total rows to return across all markets. The actor paginates past TradingView's 500-row response cap to reach this number.

## `decimals` (type: `integer`):

Round floating-point output values (price, % change, indicators) to this many decimal places. TradingView returns full-precision floats (e.g. change 0.6960635242…); the default 4 keeps results readable. Increase (e.g. 8) for crypto/forex micro-prices.

## `proxyConfiguration` (type: `object`):

Proxy used to reach TradingView's scanner. Datacenter proxies are usually fine; enable if you hit rate limits.

## Actor input object example

```json
{
  "markets": [
    "america"
  ],
  "preset": "none",
  "filters": [
    {
      "left": "market_cap_basic",
      "operation": "egreater",
      "right": 1000000000
    }
  ],
  "symbols": [
    "NASDAQ:AAPL",
    "NYSE:KO"
  ],
  "sortOrder": "desc",
  "maxResults": 100,
  "decimals": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of screener matches.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "markets": [
        "america"
    ],
    "filters": [
        {
            "left": "market_cap_basic",
            "operation": "egreater",
            "right": 1000000000
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapix/tradingview-screener").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "markets": ["america"],
    "filters": [{
            "left": "market_cap_basic",
            "operation": "egreater",
            "right": 1000000000,
        }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapix/tradingview-screener").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "markets": [
    "america"
  ],
  "filters": [
    {
      "left": "market_cap_basic",
      "operation": "egreater",
      "right": 1000000000
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapix/tradingview-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapix/tradingview-screener",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5jhxdRw42cMULVxnj/builds/UbCRhEd165RZrooRv/openapi.json