# TradingView Screener Scraper (`cirkit/tradingview-screener-scraper`) Actor

Run the TradingView screener across every market it publishes: 60+ countries plus crypto, forex, futures, bonds and CFDs. Up to 77 fields per row covering price, fundamentals and technicals, with column names validated so a typo is reported instead of returning silent nulls.

- **URL**: https://apify.com/cirkit/tradingview-screener-scraper.md
- **Developed by:** [Crikit](https://apify.com/cirkit) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.70 / 1,000 instrument rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Scraper

**Scrape the TradingView screener** across every market it publishes: **60+ countries** plus crypto, forex, futures, bonds, and CFDs. This **TradingView screener scraper** returns up to **77 fields per row** covering price, fundamentals, and technicals — with column names validated up front, so a typo is reported as an error instead of silently returning nothing.

No TradingView API key, no login, and no headless browser. Results land in a structured dataset you can export to JSON, CSV, Excel, or XML, or pull straight from the Apify API.

### What is TradingView Screener Scraper?

TradingView Screener Scraper is an [Apify Actor](https://apify.com/actors) that extracts screener rows across equities, crypto, forex, and futures from [TradingView](https://www.tradingview.com) and returns them as clean, structured records. Column validation is a genuinely useful safeguard here. With 88 possible fields across a dozen asset classes, a mistyped column in an unvalidated screener query returns an empty result that looks like a legitimate 'no matches'.

### What data can this TradingView screener scraper extract?

Every run writes one row per instrument. The full schema carries **88 fields**; the most-used ones are below.

| Field | Type | Description |
| --- | --- | --- |
| `symbol` | string | Fully qualified TradingView symbol, EXCHANGE:TICKER, for example NASDAQ:AAPL. Null only on the explanatory row an... |
| `ticker` | string | Short ticker as it trades, for example AAPL. |
| `companyName` | string | Full instrument name, for example Apple Inc. |
| `market` | string | The TradingView market this row was screened from, for example america or crypto. |
| `screenerRank` | integer | Position of this row within its market once the sort was applied. 1 is the top of the screen. |
| `price` | number | Last traded price in the instrument currency. |
| `changePercent` | number | Percentage change on the session. |
| `changeAbs` | number | Absolute price change on the session. |
| `volume` | number | Units traded on the session. On crypto markets this carries the 24 hour volume, which is the equivalent figure there. |
| `marketCap` | number | Market capitalisation in the instrument currency. On crypto markets this carries the calculated crypto market cap,... |
| `peRatio` | number | Price to earnings, trailing twelve months. |
| `eps` | number | Basic earnings per share, trailing twelve months. |
| `dividendYield` | number | Trailing dividend yield. Null for instruments that pay no dividend. |
| `sector` | string | TradingView sector, for example Electronic Technology. |
| `industry` | string | TradingView industry, for example Semiconductors. |
| `exchange` | string | Listing exchange, for example NASDAQ. |
| `country` | string | Country the issuer is domiciled in. |
| `currency` | string | Currency the instrument is quoted in. |
| `instrumentType` | string | Instrument type: stock, fund, dr, structured and so on. |
| `rsi` | number | Relative strength index over 14 periods on the daily chart. |
| `technicalRating` | string | The same overall rating as the label TradingView shows: Strong Buy, Buy, Neutral, Sell or Strong Sell. |
| `technicalRatingScore` | number | TradingView overall technical rating as a number from -1 (strong sell) to 1 (strong buy). |

See the **Output** tab in Apify Console for all 88 fields.

### How to scrape TradingView screener data

1. Open [TradingView Screener Scraper](https://apify.com/cirkit/tradingview-screener-scraper) and click **Try for free**.
2. Choose `markets` and an `instrumentTypes` filter, or start from a `preset`.
3. Pick a `columnSet`, and add any extra fields via `extraColumns`.
4. Filter with `minMarketCap`, `minPrice`, `minVolume`, `sectors`, and `minChangePercent`.
5. Set `sortBy` and `sortOrder`, then bound with `maxItems`.
6. Click **Start** and watch rows appear live in the **Output** tab.
7. Export the dataset as JSON, CSV, Excel, or XML — or fetch it from the [Apify API](https://docs.apify.com/api/v2) once the run finishes.

### TradingView Screener Scraper input options

| Input | Type | What it does | Default |
| --- | --- | --- | --- |
| `markets` | array | Which TradingView markets to screen. Every market is a separate universe, so listing several widens the result set.... | `["america"]` |
| `preset` | string | A ready-made screen. Each one sets its own filter and sort, so you get a useful result without writing any filter... | `"all"` |
| `columnSet` | string | How much detail each row carries. Every set returns the same 28 core fields (price, change, volume, market cap, P/E,... | `"core"` |
| `maxItems` | integer | Hard cap on how many rows this run returns, and therefore on what it costs. Filters and de-duplication are applied... | `100` |
| `tickers` | array | Screen only these instruments instead of a whole market. Write them as EXCHANGE:TICKER (NASDAQ:AAPL, NYSE:KO,... |  |
| `primaryListingsOnly` | boolean | Drop OTC mirrors and secondary listings of the same company. On the US market this takes 19,837 rows down to 13,698... | `true` |
| `instrumentTypes` | array | Restrict to particular instrument types on equity markets: stock, fund (ETFs and funds), dr (depositary receipts),... |  |
| `sectors` | array | Keep only these sectors, written exactly as TradingView spells them: Technology Services, Electronic Technology,... |  |
| `minMarketCap` | integer | Keep only instruments with at least this market capitalisation, in the market's own currency. 1000000000 is one billion. |  |
| `maxMarketCap` | integer | Keep only instruments at or below this market capitalisation. |  |
| `minPrice` | integer | Keep only instruments trading at or above this last price. |  |
| `maxPrice` | integer | Keep only instruments trading at or below this last price. |  |
| `minVolume` | integer | Keep only instruments that traded at least this many units today. Useful for cutting illiquid tickers out of a screen. |  |
| `minChangePercent` | integer | Keep only instruments up at least this much today. Use a negative value to keep everything above a given loss. |  |
| `sortBy` | string | TradingView field name to sort on, for example market\_cap\_basic, change, volume, RSI, dividends\_yield or Perf.Y.... |  |
| `sortOrder` | string | Descending puts the largest, fastest-rising or most active first. Leave at descending unless you are looking for the... | `"desc"` |

Proxy is configured through the standard `proxyConfiguration` object; the defaults shipped with this Actor are already tuned for the target site.

### Example output

```json
{
  "markets": ["america"],
  "preset": "large-cap",
  "columnSet": "fundamentals",
  "sectors": ["Technology Services", "Electronic Technology"],
  "minMarketCap": 10000000000,
  "maxItems": 500
}
```

### How much does it cost to scrape TradingView?

This Actor runs on **pay per result** pricing: **$0.0007 per row** ($0.7 per 1,000).

| Results | Approximate cost |
| --- | --- |
| 1,000 | $0.70 |
| 10,000 | $7.00 |
| 100,000 | $70.00 |

You pay for rows you actually receive, so a search that returns nothing costs nothing beyond the start fee. Every Apify account includes free monthly usage credit, so you can trial TradingView Screener Scraper at no cost.

### What can you build with TradingView data?

#### Build systematic stock screens

Fundamentals and technicals in the same row mean a screen can combine a P/E filter with an RSI condition without joining two data sources.

#### Scan global markets in one query

60+ country markets in a single run is far faster than running a screener per exchange.

#### Monitor technical setups across a watchlist

Moving averages, RSI, and TradingView's own technical ratings arrive precomputed.

#### Research sector rotation

Sector and industry fields with performance columns show where capital is actually moving.

#### Feed a quantitative research pipeline

Consistent column names across asset classes make the output straightforward to load into a research notebook.

### TradingView scraping tips and limits

- Start from a `preset` and adjust rather than assembling a column set from scratch — it is much faster to get a working query.
- Column names are validated, so an error means a typo. Fix the name rather than assuming the market is empty.
- `primaryListingsOnly` removes duplicate cross-listings, which otherwise inflate counts on global scans.
- This is market data for research. It is not a trading feed, and it carries no execution or real-time guarantee.

### Integrations and automation

Run TradingView Screener Scraper on a [schedule](https://docs.apify.com/platform/schedules) to keep a TradingView dataset fresh, or trigger it from your own stack through the [Apify API](https://docs.apify.com/api/v2) and the official [JavaScript](https://docs.apify.com/sdk/js) and [Python](https://docs.apify.com/sdk/python) clients. Native [integrations](https://docs.apify.com/platform/integrations) push results into Google Sheets, Slack, Airtable, Zapier, Make, GitHub, or any webhook endpoint. The Actor also works as an [MCP](https://docs.apify.com/platform/integrations/mcp) tool, so an AI agent can call it directly.

### Related scrapers

| Actor | What it does |
| --- | --- |
| [Google Trends Scraper](https://apify.com/cirkit/google-trends-scraper) | Retail search interest in tickers and sectors. |
| [Google News Scraper](https://apify.com/cirkit/google-news-scraper) | News flow around the instruments you screen. |
| [Reddit Posts Scraper - Subreddit, Search, User Posts API](https://apify.com/cirkit/reddit-posts-scraper) | Retail sentiment from investing communities. |
| [ClinicalTrials.gov Study Search Scraper](https://apify.com/cirkit/clinicaltrials-study-search-scraper) | Trial catalysts for biotech names. |

### Frequently asked questions

#### Which markets and asset classes are covered?

60+ country equity markets plus crypto, forex, futures, bonds, and CFDs, selected through `markets` and `instrumentTypes`.

#### What happens if I request a column that does not exist?

The run reports a validation error naming the bad column. That is deliberate — an unvalidated screener query with a typo returns an empty result that is easily mistaken for 'no matches'.

#### Do I need a TradingView API key?

No. TradingView Screener Scraper reads publicly available TradingView pages and endpoints directly, so there is no key to obtain, no OAuth app to register, and no account to connect.

#### Can I export TradingView data to CSV, Excel, or Google Sheets?

Yes. Every run stores results in an Apify dataset that exports to JSON, JSONL, CSV, Excel, XML, or HTML with one click, and the Google Sheets integration writes rows straight into a spreadsheet.

#### Can I run TradingView Screener Scraper on a schedule?

Yes. Apify schedules run the Actor hourly, daily, weekly, or on any cron expression, and webhooks can notify your systems the moment a run finishes.

#### Is it legal to scrape TradingView?

Scraping publicly available data is broadly lawful in the US and EU, but the answer depends on what you collect and how you use it. This Actor is built to gather public market screener data TradingView publishes publicly — this is informational market data, not a licensed real-time feed, so check TradingView's terms before redistributing it. Personal data carries extra obligations under GDPR and CCPA. Read Apify's guide on [whether web scraping is legal](https://blog.apify.com/is-web-scraping-legal/) and take your own legal advice for your use case.

### Support and feedback

Found a bug, a missing field, or a TradingView page shape this Actor does not handle yet? Open an issue from the **Issues** tab on the Actor page. Feature requests and custom-scraper enquiries are welcome there too.

# Actor input Schema

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

Which TradingView markets to screen. Every market is a separate universe, so listing several widens the result set. Equity markets include america, canada, uk, germany, france, italy, spain, netherlands, switzerland, sweden, japan, india, australia, brazil, hongkong, singapore, korea, mexico and about fifty more. Non-equity markets are crypto, coin, forex, futures, bond, cfd and economics2. An unknown market is reported by name instead of quietly returning nothing.

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

A ready-made screen. Each one sets its own filter and sort, so you get a useful result without writing any filter JSON. Choose "Everything" and use the filters below to build your own.

## `columnSet` (type: `string`):

How much detail each row carries. Every set returns the same 28 core fields (price, change, volume, market cap, P/E, EPS, dividend yield, sector, industry, RSI, technical rating, 50 and 200 day moving averages, five performance windows and the 52 week range). The larger sets add more on top. Extra fields do not change the price: you are charged per row, not per column.

## `maxItems` (type: `integer`):

Hard cap on how many rows this run returns, and therefore on what it costs. Filters and de-duplication are applied before the cap, so a cap of 500 returns 500 rows that match, not 500 candidates. Set to 0 to run nothing and be charged nothing.

## `tickers` (type: `array`):

Screen only these instruments instead of a whole market. Write them as EXCHANGE:TICKER (NASDAQ:AAPL, NYSE:KO, CRYPTO:BTCUSD) for an exact match. A bare ticker such as AAPL also works and is matched by symbol name. TradingView drops symbols it does not recognise without complaining, so any that come back missing are listed in the run log.

## `primaryListingsOnly` (type: `boolean`):

Drop OTC mirrors and secondary listings of the same company. On the US market this takes 19,837 rows down to 13,698 and removes most of the duplicate-looking noise. Turn it off if you specifically want OTC and cross-listed tickers.

## `instrumentTypes` (type: `array`):

Restrict to particular instrument types on equity markets: stock, fund (ETFs and funds), dr (depositary receipts), structured. Leave empty for all of them. This filter is skipped automatically on crypto, forex, futures, bond and cfd, where it would match nothing.

## `sectors` (type: `array`):

Keep only these sectors, written exactly as TradingView spells them: Technology Services, Electronic Technology, Finance, Health Technology, Retail Trade, Energy Minerals, Consumer Durables, Producer Manufacturing, Utilities, Commercial Services, Non-Energy Minerals, Process Industries, Transportation, Communications, Distribution Services, Consumer Non-Durables, Consumer Services, Industrial Services, Health Services, Miscellaneous.

## `minMarketCap` (type: `integer`):

Keep only instruments with at least this market capitalisation, in the market's own currency. 1000000000 is one billion.

## `maxMarketCap` (type: `integer`):

Keep only instruments at or below this market capitalisation.

## `minPrice` (type: `integer`):

Keep only instruments trading at or above this last price.

## `maxPrice` (type: `integer`):

Keep only instruments trading at or below this last price.

## `minVolume` (type: `integer`):

Keep only instruments that traded at least this many units today. Useful for cutting illiquid tickers out of a screen.

## `minChangePercent` (type: `integer`):

Keep only instruments up at least this much today. Use a negative value to keep everything above a given loss.

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

TradingView field name to sort on, for example market\_cap\_basic, change, volume, RSI, dividends\_yield or Perf.Y. Leave empty to use the sort that belongs to the chosen screen. Sorting is always applied: without it TradingView returns an arbitrary slice and two identical runs disagree.

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

Descending puts the largest, fastest-rising or most active first. Leave at descending unless you are looking for the bottom of a list.

## `extraColumns` (type: `array`):

Any additional TradingView field names to append to every row, delivered under "extra". TradingView publishes 3,771 of them per market and answers an unrecognised name with a silent null rather than an error, so every name here is checked against the market's own field catalogue first and anything unknown is named in the run log instead of becoming a column of nulls.

## `advancedFilters` (type: `array`):

Raw TradingView filter clauses for anything the fields above do not cover, as objects of the form {"left": "price\_earnings\_ttm", "operation": "less", "right": 15}. Operations are greater, egreater, less, eless, equal, nequal, in\_range, not\_in\_range, match, empty and nempty. Clauses are combined with AND. A clause naming a field the market does not publish is dropped and reported, because TradingView answers those with zero rows instead of an error.

## `maxRunSeconds` (type: `integer`):

Stop starting new work after this many seconds and push whatever has been collected. Guards against a run being killed by the platform timeout and billing for the full window.

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

Optional. TradingView's scanner endpoint is public and unauthenticated, and it answers Apify's datacenter egress exactly as it answers a home connection, so this Actor needs no proxy and is cheaper without one. Configure it only if your own network policy requires it.

## Actor input object example

```json
{
  "markets": [
    "america"
  ],
  "preset": "all",
  "columnSet": "core",
  "maxItems": 100,
  "tickers": [],
  "primaryListingsOnly": true,
  "instrumentTypes": [],
  "sectors": [],
  "sortOrder": "desc",
  "extraColumns": [],
  "advancedFilters": [],
  "maxRunSeconds": 3300,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every instrument collected in this run, as JSON.

## `resultsCsv` (type: `string`):

The same rows as a CSV download.

## `resultsExcel` (type: `string`):

The same rows as an Excel workbook.

# 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"
    ],
    "preset": "all",
    "columnSet": "core",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/tradingview-screener-scraper").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"],
    "preset": "all",
    "columnSet": "core",
    "maxItems": 100,
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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"
  ],
  "preset": "all",
  "columnSet": "core",
  "maxItems": 100
}' |
apify call cirkit/tradingview-screener-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cirkit/tradingview-screener-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cyVGm7EFZOwhpXJq5/builds/ks8f9eGaOVF9HNXE6/openapi.json