# 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, 1 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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&lt;string&gt; | `["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&lt;object&gt; | `[]` | Conditions, AND-combined: `{"left": field, "operation": op, "right": value}`. |
| `columns` | array&lt;string&gt; | preset/default | Native TradingView field names to return. Empty ⇒ preset columns, else a sensible stock default. |
| `symbols` | array&lt;string&gt; | `[]` (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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView Screener",
        "description": "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",
        "version": "0.0",
        "x-build-id": "UbCRhEd165RZrooRv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapix~tradingview-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapix-tradingview-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapix~tradingview-screener/runs": {
            "post": {
                "operationId": "runs-sync-scrapix-tradingview-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapix~tradingview-screener/run-sync": {
            "post": {
                "operationId": "run-sync-scrapix-tradingview-screener",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "markets": {
                        "title": "Markets",
                        "type": "array",
                        "description": "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.",
                        "default": [
                            "america"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "preset": {
                        "title": "Preset screen",
                        "enum": [
                            "none",
                            "top_gainers",
                            "top_losers",
                            "most_active",
                            "oversold_rsi",
                            "overbought_rsi",
                            "high_dividend",
                            "high_volume_breakouts",
                            "large_cap_leaders",
                            "full_technicals"
                        ],
                        "type": "string",
                        "description": "Optional ready-made screen. Seeds filters, columns, and sort; your own filters/columns/sort below merge on top. Presets target equity markets.",
                        "default": "none"
                    },
                    "filters": {
                        "title": "Filters",
                        "type": "array",
                        "description": "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": {
                        "title": "Columns",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "symbols": {
                        "title": "Symbols (optional)",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "type": "string",
                        "description": "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": {
                        "title": "Sort order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Sort direction.",
                        "default": "desc"
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Total rows to return across all markets. The actor paginates past TradingView's 500-row response cap to reach this number.",
                        "default": 100
                    },
                    "decimals": {
                        "title": "Round numbers to N decimals",
                        "minimum": 0,
                        "maximum": 12,
                        "type": "integer",
                        "description": "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.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach TradingView's scanner. Datacenter proxies are usually fine; enable if you hit rate limits.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
