# TradingView Screener Scraper — Stocks, Crypto & Forex (`haketa/tradingview-scraper`) Actor

Scrape TradingView's screener for stocks, crypto and forex: symbol, price, % change, volume, market cap, sector, RSI, P/E, EPS, dividend yield and 52-week range. Filter by market cap, RSI, sector; sort and paginate. Fast, no key, no login.

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

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## TradingView Screener Scraper — Stocks, Crypto & Forex Data

> **Screen thousands of stocks, cryptocurrencies and forex pairs from TradingView — with price, % change, volume, market cap, sector, RSI, P/E, EPS, dividend yield and 52-week range.** Filter by market cap, RSI or sector, sort, and export clean JSON/CSV/Excel in seconds. No API key, no login.

[![TradingView Data](https://img.shields.io/badge/TradingView-Screener-2962ff)]()
[![Markets](https://img.shields.io/badge/Markets-Stocks%20%2B%20Crypto%20%2B%20Forex-blue)]()
[![No Key](https://img.shields.io/badge/Auth-None%20Required-brightgreen)]()
[![Coverage](https://img.shields.io/badge/Coverage-20K%2B%20US%20stocks%2C%2064K%2B%20crypto-purple)]()

***

### What This Actor Does

The **TradingView Screener Scraper** turns TradingView's powerful screener into a structured dataset. Pick a market and it returns each symbol as a clean row with:

- **Identity** — symbol, ticker, name, exchange, TradingView link
- **Price action** — last price, % change, volume
- **Fundamentals** — market cap, sector, industry, P/E ratio, EPS, dividend yield
- **Technicals** — 14-day RSI, 52-week high/low
- Plus any **extra TradingView field** you add (MACD, volatility, moving averages, and hundreds more)

Screen **US stocks** (20,000+), **crypto** (64,000+ pairs), **forex** (6,000+), or the stock market of Turkey, Germany, UK, India, Canada, Australia, France, Spain, Italy, Brazil or Japan. Filter, sort and paginate through the whole result set.

***

### Why Use This

- TradingView's data is behind a **JSON screener** whose field names and request format are undocumented and easy to get wrong — this Actor speaks it fluently.
- Values like `market_cap_basic`, `dividends_yield`, `total_value_traded`, `RSI` differ **by market** (stocks vs. crypto) — handled for you with the right preset per market.
- You get an **analysis-ready table** (symbol, price, change, market cap, sector, RSI, P/E…) instead of raw indexed arrays.
- Built-in **filters** (market cap, RSI oversold/overbought, sector) and **sorting** so you can build real screens, not just dumps.

***

### Quick Start

#### Run it in the console (no code)

1. Open the Actor and click **Try for free**.
2. Choose a **Market** (US Stocks, Crypto, Forex, or a country).
3. Optionally set filters: **Min market cap**, **Max RSI** (oversold), **Min RSI** (overbought), **Sector**, **Min volume**.
4. Set **Sort by** + **Max symbols** and click **Start**.
5. Export as **JSON, CSV, Excel, or HTML**, or push to Google Sheets, a webhook or a database.

#### Run it via API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "market": "america",
    "minMarketCap": 1000000000,   # $1B+
    "sortBy": "change",
    "sortOrder": "desc",
    "maxItems": 200,
}

run = client.actor("YOUR_USERNAME/tradingview-scraper").call(run_input=run_input)

for s in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(s["ticker"], s["price"], s["changePercent"], "%  RSI", s["rsi"])
```

#### Oversold large-cap screen (Python)

```python
run_input = {
    "market": "america",
    "minMarketCap": 10000000000,   # $10B+
    "maxRSI": 30,                  # oversold
    "sortBy": "market_cap_basic",
    "maxItems": 100,
}
run = client.actor("YOUR_USERNAME/tradingview-scraper").call(run_input=run_input)
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
for r in rows:
    print(f'{r["ticker"]:6} RSI {r["rsi"]:.0f}  div {r.get("dividendYield")}  {r["name"]}')
```

#### Crypto by market cap (Node.js)

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('YOUR_USERNAME/tradingview-scraper').call({
    market: 'crypto',
    sortBy: 'market_cap_calc',
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map(i => `${i.ticker} $${i.price}`));
```

***

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `market` | select | `america`, `crypto`, `forex`, or a country (`turkey`, `germany`, `uk`, `india`, `canada`, `australia`, `france`, `spain`, `italy`, `brazil`, `japan`). |
| `minMarketCap` | integer | Only symbols with market cap ≥ this (e.g. `1000000000` = $1B). |
| `maxRSI` | integer | Only symbols with 14-day RSI ≤ this (e.g. `30` = oversold). |
| `minRSI` | integer | Only symbols with 14-day RSI ≥ this (e.g. `70` = overbought). |
| `sector` | string | Filter stocks by sector (e.g. `Technology Services`, `Finance`, `Energy Minerals`). |
| `minVolume` | integer | Only symbols with volume ≥ this. |
| `sortBy` | string | TradingView field to sort by. Default: market cap. (e.g. `change`, `volume`, `RSI`, `close`). |
| `sortOrder` | select | `desc` or `asc`. |
| `extraColumns` | array | Extra TradingView fields to include (e.g. `MACD.macd`, `Volatility.D`, `average_volume_10d_calc`). |
| `maxItems` | integer | Maximum symbols to return. Default `100`. |
| `proxyConfiguration` | object | Optional. Works fine without a proxy. |

***

### Output

Each symbol is one dataset record. Example (US stock):

```json
{
  "symbol": "NASDAQ:PLTR",
  "ticker": "PLTR",
  "name": "Palantir Technologies Inc.",
  "exchange": "NASDAQ",
  "price": 191.45,
  "changePercent": 3.49,
  "changeAbs": 6.45,
  "volume": 54666468,
  "marketCap": 430814384136,
  "sector": "Technology Services",
  "industry": "Packaged Software",
  "rsi": 66.7,
  "peRatio": 163.14,
  "eps": 1.17,
  "dividendYield": null,
  "high52Week": 207.5,
  "low52Week": 21.2,
  "tradingViewUrl": "https://www.tradingview.com/symbols/NASDAQ-PLTR/",
  "scrapedAt": "2026-09-23T19:30:00.000Z"
}
```

Crypto rows carry `ticker`, `name`, `price`, `changePercent`, `volume24h`, `marketCap`, `circulatingSupply`, `rsi`. Forex rows carry `ticker`, `name`, `price`, `changePercent`, `bid`, `ask`.

***

### Use Cases

#### 1. Stock screening

Build any screen: large-cap tech under RSI 30, high-dividend financials, top gainers by % change, most-active by volume. Filter + sort exactly like the TradingView screener, but exportable.

#### 2. Oversold / overbought signals

`maxRSI: 30` for oversold candidates, `minRSI: 70` for overbought — across any market, sorted by market cap or volume.

#### 3. Sector & market analysis

Pull an entire sector or country market and analyze valuation (P/E), momentum (RSI, % change) and size (market cap) distributions.

#### 4. Crypto market scan

Rank 64,000+ crypto pairs by market cap or 24h volume; track price and RSI across exchanges.

#### 5. Dividend income screening

Sort stocks by `dividends_yield` and filter by market cap to find quality income candidates.

#### 6. Quant & backtesting datasets

Assemble clean, structured cross-sectional market data (price, fundamentals, technicals) for research, models and dashboards. Schedule it for a daily snapshot time series.

***

### Markets & Fields

**Markets:** US & 11 country stock markets, plus Crypto and Forex. **Stock fields** include price, % change, volume, market cap, sector, industry, RSI, P/E, EPS, dividend yield, 52-week high/low. **Crypto** adds 24h volume, circulating supply. Add any other TradingView field via `extraColumns`.

***

### Frequently Asked Questions

**Do I need a TradingView account or API key?**
No. The Actor reads publicly available screener data — no login or key.

**How many symbols can I get?**
As many as match your filters (US stocks alone are 20,000+). Set `maxItems` to cap it.

**How do I filter by sector?**
Set `sector` to a TradingView sector name (e.g. `Technology Services`, `Finance`, `Health Technology`).

**Can I add fields that aren't in the presets?**
Yes — put TradingView field names in `extraColumns` (e.g. `MACD.macd`, `Volatility.D`).

**How fresh are the numbers?**
They reflect the latest screener values at scrape time (real-time/slightly delayed depending on the exchange, same as the TradingView site).

**What export formats are supported?**
JSON, CSV, Excel, HTML, or via API — plus Google Sheets, webhooks, Make, and Zapier.

**Can I schedule it?**
Yes — use Apify Schedules for a daily market snapshot and build a time series.

***

### Legal & Responsible Use

This Actor collects only publicly available market data for research and informational purposes. **It is not financial, investment, or trading advice.** Market data may be delayed and should not be relied upon for trading decisions. You are responsible for complying with the laws and terms that apply to you. Please:

- Respect TradingView's Terms of Service and robots directives.
- Do not use the data for unlawful purposes.
- Use reasonable request volumes and scheduling.

This project is an independent tool and is not affiliated with, endorsed by, or sponsored by TradingView.

# Actor input Schema

## `market` (type: `string`):

Which TradingView market to screen.

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

Only symbols with market cap ≥ this value (e.g. 1000000000 for $1B). Leave empty for no minimum.

## `maxRSI` (type: `integer`):

Only symbols with 14-day RSI ≤ this (e.g. 30 for oversold). Leave empty to skip.

## `minRSI` (type: `integer`):

Only symbols with 14-day RSI ≥ this (e.g. 70 for overbought). Leave empty to skip.

## `sector` (type: `string`):

Filter stocks by sector, e.g. Technology Services, Electronic Technology, Finance, Health Technology, Energy Minerals. Leave empty for all.

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

Only symbols with volume ≥ this value. Leave empty for no minimum.

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

TradingView field to sort by. Default: market cap. Examples: change, volume, RSI, close, price\_earnings\_ttm.

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

Sort direction (descending or ascending).

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

Additional TradingView field names to include, e.g. MACD.macd, Volatility.D, average\_volume\_10d\_calc, price\_earnings\_growth\_ttm.

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

Maximum number of symbols to return.

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

Optional. Works fine without a proxy.

## Actor input object example

```json
{
  "market": "america",
  "sortOrder": "desc",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `symbol` (type: `string`):

Exchange:Ticker

## `ticker` (type: `string`):

Ticker

## `name` (type: `string`):

Full name

## `exchange` (type: `string`):

Exchange

## `price` (type: `string`):

Last price

## `changePercent` (type: `string`):

Percent change

## `volume` (type: `string`):

Volume

## `marketCap` (type: `string`):

Market cap

## `sector` (type: `string`):

Sector

## `industry` (type: `string`):

Industry

## `rsi` (type: `string`):

14-day RSI

## `peRatio` (type: `string`):

Price/earnings TTM

## `eps` (type: `string`):

Earnings per share TTM

## `dividendYield` (type: `string`):

Dividend yield

## `high52Week` (type: `string`):

52-week high

## `low52Week` (type: `string`):

52-week low

## `tradingViewUrl` (type: `string`):

TradingView symbol URL

## `scrapedAt` (type: `string`):

ISO timestamp

# 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 = {
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/tradingview-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 = {
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/tradingview-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 '{
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/tradingview-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/tradingview-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/8ahYvUDRn3c0iHiHJ/builds/Gck1Y4stq5TvVvgHf/openapi.json