# TradingView Scraper (`khadinakbar/tradingview-scraper`) Actor

Scrape TradingView screener, technical-analysis ratings, and quotes for stocks, crypto, forex, and futures. MCP-ready, $0.005 per result.

- **URL**: https://apify.com/khadinakbar/tradingview-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** MCP servers, AI, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result returneds

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 Scraper

Pull TradingView's three highest-value surfaces — the **screener**, the **multi-timeframe technical-analysis gauge** (Strong Buy → Strong Sell), and **quote snapshots** — as clean JSON. No login, no API key, no browser. One actor, three modes, every market TradingView supports.

Built for algo-trading agents, quants, fintech developers, and AI traders who need TradingView's signals in code without scraping the chart UI.

### What you get

| Mode | What it returns | Use it for |
|---|---|---|
| `screener` | Top-N symbols of any market, sorted by market cap / volume / change / gauge / RSI, with 60+ fields | Discovering setups across thousands of stocks/coins |
| `technicals` | The famous **Strong Buy/Sell gauge** + RSI, MACD, Stochastic for specific symbols across up to 10 timeframes (1m → 1M) | Multi-timeframe signal stacks for a watchlist |
| `quotes` | Price, change, volume, market cap, P/E, EPS, dividend yield, performance over 6 windows | Fast price + fundamentals snapshot |

**Markets covered:** US stocks (`america`), 30+ country equity markets, crypto (`crypto`), forex (`forex`), futures (`futures`), bonds (`bond`), CFDs (`cfd`).

**Pricing:** `$0.005 per result` returned (10× cheaper than the closest competitor). Charged per row pushed; `$0.00005` flat start fee. Hard cap of 500 results per run.

### Quick start

#### Screener — top 50 US stocks by market cap with full TA

```json
{
  "mode": "screener",
  "market": "america",
  "sortBy": "market_cap_basic",
  "sortOrder": "desc",
  "maxResults": 50
}
````

#### Technicals — multi-timeframe gauge on a watchlist

```json
{
  "mode": "technicals",
  "symbols": ["NASDAQ:AAPL", "NASDAQ:TSLA", "NASDAQ:NVDA", "apple"],
  "timeframes": ["1h", "4h", "1d", "1W"],
  "maxResults": 4
}
```

Free-text names like `"apple"` or `"bitcoin"` auto-resolve to the primary exchange listing.

#### Quotes — price snapshot

```json
{
  "mode": "quotes",
  "symbols": ["NASDAQ:NVDA", "BINANCE:BTCUSDT", "FX:EURUSD"],
  "maxResults": 3
}
```

#### Crypto screener

```json
{
  "mode": "screener",
  "market": "crypto",
  "sortBy": "market_cap_basic",
  "maxResults": 100
}
```

### Sample output (screener row)

```json
{
  "mode": "screener",
  "market": "america",
  "symbol": "NVDA",
  "exchange": "NASDAQ",
  "fullSymbol": "NASDAQ:NVDA",
  "name": "NVDA",
  "sector": "Electronic Technology",
  "industry": "Semiconductors",
  "country": "US",
  "currency": "USD",
  "close": 207.41,
  "changePct": -2.37,
  "volume": 125228691,
  "marketCapUsd": 5019321927899,
  "peRatio": 47.2,
  "recommendAll": -0.22,
  "recommendAllLabel": "Sell",
  "recommendMA": 0.4,
  "recommendOther": -0.5,
  "rsi": 41.8,
  "macd": -1.97,
  "macdSignal": -1.42,
  "ema50": 215.4,
  "sma200": 178.1,
  "perfWeek": -3.5,
  "perfYTD": 32.9,
  "url": "https://www.tradingview.com/symbols/NASDAQ-NVDA/",
  "scrapedAt": "2026-06-17T02:35:00Z"
}
```

### Sample output (technicals row)

```json
{
  "mode": "technicals",
  "symbol": "AAPL",
  "exchange": "NASDAQ",
  "fullSymbol": "NASDAQ:AAPL",
  "close": 299.24,
  "recommendAll": 0.15,
  "recommendAllLabel": "Buy",
  "rsi": 52.12,
  "timeframes": {
    "1h": { "recommendAll": 0.29, "recommendAllLabel": "Buy", "rsi": 59.15 },
    "4h": { "recommendAll": 0.07, "recommendAllLabel": "Neutral", "rsi": 54.30 },
    "1d": { "recommendAll": 0.15, "recommendAllLabel": "Buy", "rsi": 52.12 },
    "1W": { "recommendAll": 0.49, "recommendAllLabel": "Buy", "rsi": 61.04 }
  },
  "url": "https://www.tradingview.com/symbols/NASDAQ-AAPL/technicals/",
  "scrapedAt": "2026-06-17T02:35:00Z"
}
```

### How the gauge works

TradingView's `Recommend.All` returns a score from `-1` to `+1`. We map it to the same five-tier label TradingView uses:

| Score range | Label |
|---|---|
| ≥ 0.50 | **Strong Buy** |
| 0.10 to 0.50 | Buy |
| -0.10 to 0.10 | Neutral |
| -0.50 to -0.10 | Sell |
| ≤ -0.50 | **Strong Sell** |

`recommendMA` is the MA-only sub-score, `recommendOther` is the oscillator-only sub-score. In `technicals` mode you get the full split per timeframe.

### Use cases

- **Algo trading signal feed.** Pull `recommendAll` across `1h`/`4h`/`1d`/`1W` for your watchlist every cron tick.
- **Multi-market scanner.** Run screener on `america`, `crypto`, `forex` in one workflow.
- **Backtesting data pull.** Snapshot fundamentals + technicals at run time, archive to your warehouse.
- **AI trading agent (MCP).** Registered in Apify MCP as `apify--khadinakbar/tradingview-scraper` — Claude / GPT / your custom agent can call it directly. The tool description front-loads the buy/sell-gauge keyword so agents pick it confidently.
- **Daily watchlist email.** Schedule a `screener` run with `sortBy=Recommend.All`, push the top 10 to Slack.

### Inputs reference

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | string | `screener` | `screener` | `technicals` | `quotes` |
| `market` | string | `america` | 30+ country codes + `crypto`, `forex`, `futures`, `bond`, `cfd` |
| `symbols` | string\[] | `[]` | `EXCHANGE:SYMBOL` or free text; required for `technicals`/`quotes` |
| `timeframes` | string\[] | `["1h","4h","1d","1W"]` | `1m,5m,15m,30m,1h,2h,4h,1d,1W,1M` |
| `minMarketCapUsd` | int | `0` | Screener filter |
| `sortBy` | string | `market_cap_basic` | Screener sort key |
| `sortOrder` | string | `desc` | `desc` | `asc` |
| `maxResults` | int | `50` | Hard cap 500, also caps PPE billing |
| `proxyConfiguration` | object | Apify proxy | Datacenter is sufficient |

### Pricing

| Event | Price |
|---|---|
| Actor start | $0.00005 (scaled by RAM) |
| Result returned | **$0.005** per row pushed to the dataset |

Run cost is bounded — `maxResults * $0.005` plus the start fee. Status message prints the cost cap before the first charge fires. End-of-run status reports the actual billed amount.

The closest comparable Apify actor charges $0.05 per stock. This one is 10× cheaper, returns 3× more fields, adds multi-timeframe technicals, and resolves free-text symbols.

### Data freshness & accuracy

TradingView publishes delayed market data on its public scanner endpoint (typically 15–20 minutes for US equities, real-time for crypto). For live tick data you need a paid broker feed; this actor is the right tool for screening, ranking, signal aggregation, and watchlist monitoring, not for HFT entries.

### Reliability

The actor calls `https://scanner.tradingview.com/{market}/scan` directly — no browser, no headless Chrome. Each POST is retried up to 3× with exponential backoff on 408/429/5xx. Symbol resolution falls back gracefully — if `apple` can't be resolved we log a warning and move on, never crashing the run.

A run with zero pushed results in `technicals` or `quotes` mode terminates with a `WARNING` status message naming the unresolved symbols, so failures are visible, not silent.

### MCP / agent integration

Add this actor to any MCP client (Claude Desktop, Cursor, custom agent):

```
https://mcp.apify.com?tools=khadinakbar/tradingview-scraper
```

The tool name agents see is `apify--khadinakbar/tradingview-scraper`. Tool description, input descriptions, and output keys are all written for an LLM reader; expect single-shot correct calls without prompt-engineering the inputs.

### FAQ

**Does TradingView block this?**
No — the scanner endpoint is public and used by their own web UI. We've probed it across all advertised markets; HTTP 200 every time, sub-second latency, no auth headers required. If they ever lock it down, this actor will return a clear status message and we'll publish an update.

**Can I get options chains, futures contracts, individual broker prices?**
No — this actor wraps TradingView's scanner. For options chains use a dedicated options-data scraper; for live broker quotes use a broker API.

**Can I scan all 13,000+ US stocks in one run?**
Per-run cap is 500 to respect TradingView's endpoint and keep your run cost predictable (500 × $0.005 = $2.50 max). For larger sweeps, run the actor in batches with `sortOrder=desc` and `sortBy=market_cap_basic`, then paginate via repeated runs with different `minMarketCapUsd` floors.

**Why are some technical fields `null`?**
TradingView returns `null` for indicators that haven't reached enough bars (e.g., SMA200 for a newly listed coin). We pass that through; we don't synthesise data.

**Is this an official TradingView API?**
No. TradingView does not publish an official screener API. This actor uses the same public endpoint that powers the screener page on tradingview.com. Use within their Terms of Service and respect their rate-limits.

### Legal

Data accessed via TradingView's public scanner endpoint. This actor does not bypass any authentication, paywall, or anti-scraping measures. The data and brand names belong to TradingView and the underlying exchanges. You are responsible for complying with TradingView's [Terms of Service](https://www.tradingview.com/policies/) and any redistribution restrictions on the data. Not investment advice — use at your own risk.

### Other finance actors by `khadinakbar`

- [**yahoo-finance-scraper**](https://apify.com/khadinakbar/yahoo-finance-scraper) — Yahoo Finance quotes, OHLC, financials, options, holders
- [**stock-price-tracker**](https://apify.com/khadinakbar/stock-price-tracker) — multi-asset real-time quotes
- [**crypto-price-tracker**](https://apify.com/khadinakbar/crypto-price-tracker) — 17K+ coins via CoinGecko + Binance
- [**sec-edgar-all-in-one-scraper**](https://apify.com/khadinakbar/sec-edgar-all-in-one-scraper) — 10-K, 10-Q, 8-K, Form 4, 13F
- [**google-finance-stock-news-scraper**](https://apify.com/khadinakbar/google-finance-stock-news-scraper) — stock news + price headers

# Actor input Schema

## `mode` (type: `string`):

What to scrape. 'screener' = scan a market for stocks/coins matching filters (returns ranked list). 'technicals' = TradingView's Strong-Buy→Strong-Sell gauge + RSI/MACD/Stochastic for specific symbols across timeframes. 'quotes' = price/change/volume/fundamentals snapshot for specific symbols. NOT a chart-image or news scraper.

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

TradingView market to scan. 'america' = US stocks (NASDAQ/NYSE/AMEX). 'crypto' = all crypto pairs across exchanges. 'forex' = currency pairs. 'futures' = commodity/index futures. Other country codes scan that country's equities. Required for screener mode; ignored for technicals/quotes when symbols are tickers like 'NASDAQ:AAPL'.

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

Specific tickers like 'NASDAQ:AAPL', 'NYSE:TSLA', 'BINANCE:BTCUSDT', 'FX:EURUSD'. Free-text names like 'apple' or 'bitcoin' auto-resolve to the primary exchange. Required for 'technicals' and 'quotes' modes. Optional for 'screener' (when set, screener filters to only these symbols). Up to 500 per run.

## `timeframes` (type: `array`):

Intervals for the buy/sell gauge and oscillators in 'technicals' mode. '1m','5m','15m','30m','1h','2h','4h','1d','1W','1M'. Each adds a separate Recommend.All gauge + RSI/MACD column to every row. Ignored in screener/quotes modes. Default \['1h','4h','1d','1W'] balances signal vs cost.

## `minMarketCapUsd` (type: `integer`):

Exclude symbols below this market cap in 'screener' mode. Example: 1000000000 = $1B floor. Set 0 to disable. Ignored in technicals/quotes. Use to filter penny stocks or microcap noise.

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

Column to sort screener results by. 'market\_cap\_basic' = market cap. 'volume' = today's volume. 'change' = % price change. 'Recommend.All' = TradingView gauge score. 'RSI' = relative-strength index. Ignored in technicals/quotes. Default 'market\_cap\_basic'.

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

Direction of sortBy. 'desc' = largest first. 'asc' = smallest first. Ignored in technicals/quotes.

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

Caps total dataset rows AND total PPE billing for the run. Screener mode returns top-N by sortBy. Technicals/quotes return min(maxResults, symbols.length). Hard cap 500 per run to stay polite to TradingView's endpoint.

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

Apify proxy used for TradingView requests. Datacenter is sufficient (endpoint is public, no anti-bot). Override with residential only if you hit 429s from running massive bursts.

## Actor input object example

```json
{
  "mode": "screener",
  "market": "america",
  "symbols": [
    "NASDAQ:AAPL",
    "NASDAQ:TSLA",
    "NASDAQ:NVDA"
  ],
  "timeframes": [
    "1h",
    "4h",
    "1d",
    "1W"
  ],
  "minMarketCapUsd": 1000000000,
  "sortBy": "market_cap_basic",
  "sortOrder": "desc",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

One record per scraped symbol. See dataset\_schema.json for field documentation.

## `summary` (type: `string`):

Aggregate counts and any errors collected during the run.

# 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 = {
    "mode": "screener",
    "market": "america",
    "symbols": [
        "NASDAQ:AAPL",
        "NASDAQ:TSLA",
        "NASDAQ:NVDA"
    ],
    "timeframes": [
        "1h",
        "4h",
        "1d",
        "1W"
    ],
    "minMarketCapUsd": 1000000000,
    "sortBy": "market_cap_basic",
    "sortOrder": "desc",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "mode": "screener",
    "market": "america",
    "symbols": [
        "NASDAQ:AAPL",
        "NASDAQ:TSLA",
        "NASDAQ:NVDA",
    ],
    "timeframes": [
        "1h",
        "4h",
        "1d",
        "1W",
    ],
    "minMarketCapUsd": 1000000000,
    "sortBy": "market_cap_basic",
    "sortOrder": "desc",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/tradingview-scraper").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 '{
  "mode": "screener",
  "market": "america",
  "symbols": [
    "NASDAQ:AAPL",
    "NASDAQ:TSLA",
    "NASDAQ:NVDA"
  ],
  "timeframes": [
    "1h",
    "4h",
    "1d",
    "1W"
  ],
  "minMarketCapUsd": 1000000000,
  "sortBy": "market_cap_basic",
  "sortOrder": "desc",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call khadinakbar/tradingview-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView Scraper",
        "description": "Scrape TradingView screener, technical-analysis ratings, and quotes for stocks, crypto, forex, and futures. MCP-ready, $0.005 per result.",
        "version": "0.2",
        "x-build-id": "E6F25heb4nhePHl6h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~tradingview-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-tradingview-scraper",
                "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/khadinakbar~tradingview-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-tradingview-scraper",
                "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/khadinakbar~tradingview-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-tradingview-scraper",
                "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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scrape mode",
                        "enum": [
                            "screener",
                            "technicals",
                            "quotes"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'screener' = scan a market for stocks/coins matching filters (returns ranked list). 'technicals' = TradingView's Strong-Buy→Strong-Sell gauge + RSI/MACD/Stochastic for specific symbols across timeframes. 'quotes' = price/change/volume/fundamentals snapshot for specific symbols. NOT a chart-image or news scraper.",
                        "default": "screener"
                    },
                    "market": {
                        "title": "Market",
                        "enum": [
                            "america",
                            "crypto",
                            "forex",
                            "futures",
                            "bond",
                            "cfd",
                            "coin",
                            "uk",
                            "germany",
                            "france",
                            "italy",
                            "spain",
                            "switzerland",
                            "netherlands",
                            "australia",
                            "canada",
                            "brazil",
                            "mexico",
                            "argentina",
                            "japan",
                            "china",
                            "hongkong",
                            "india",
                            "korea",
                            "taiwan",
                            "singapore",
                            "indonesia",
                            "malaysia",
                            "thailand",
                            "vietnam",
                            "philippines",
                            "uae",
                            "saudiarabia",
                            "turkey",
                            "egypt",
                            "southafrica",
                            "russia",
                            "poland"
                        ],
                        "type": "string",
                        "description": "TradingView market to scan. 'america' = US stocks (NASDAQ/NYSE/AMEX). 'crypto' = all crypto pairs across exchanges. 'forex' = currency pairs. 'futures' = commodity/index futures. Other country codes scan that country's equities. Required for screener mode; ignored for technicals/quotes when symbols are tickers like 'NASDAQ:AAPL'.",
                        "default": "america"
                    },
                    "symbols": {
                        "title": "Symbols (for technicals/quotes; optional filter for screener)",
                        "type": "array",
                        "description": "Specific tickers like 'NASDAQ:AAPL', 'NYSE:TSLA', 'BINANCE:BTCUSDT', 'FX:EURUSD'. Free-text names like 'apple' or 'bitcoin' auto-resolve to the primary exchange. Required for 'technicals' and 'quotes' modes. Optional for 'screener' (when set, screener filters to only these symbols). Up to 500 per run.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "timeframes": {
                        "title": "Timeframes (technicals mode)",
                        "type": "array",
                        "description": "Intervals for the buy/sell gauge and oscillators in 'technicals' mode. '1m','5m','15m','30m','1h','2h','4h','1d','1W','1M'. Each adds a separate Recommend.All gauge + RSI/MACD column to every row. Ignored in screener/quotes modes. Default ['1h','4h','1d','1W'] balances signal vs cost.",
                        "default": [
                            "1h",
                            "4h",
                            "1d",
                            "1W"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minMarketCapUsd": {
                        "title": "Min market cap (USD, screener only)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Exclude symbols below this market cap in 'screener' mode. Example: 1000000000 = $1B floor. Set 0 to disable. Ignored in technicals/quotes. Use to filter penny stocks or microcap noise.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort field (screener only)",
                        "enum": [
                            "market_cap_basic",
                            "volume",
                            "change",
                            "Recommend.All",
                            "RSI",
                            "close",
                            "name"
                        ],
                        "type": "string",
                        "description": "Column to sort screener results by. 'market_cap_basic' = market cap. 'volume' = today's volume. 'change' = % price change. 'Recommend.All' = TradingView gauge score. 'RSI' = relative-strength index. Ignored in technicals/quotes. Default 'market_cap_basic'.",
                        "default": "market_cap_basic"
                    },
                    "sortOrder": {
                        "title": "Sort order (screener only)",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Direction of sortBy. 'desc' = largest first. 'asc' = smallest first. Ignored in technicals/quotes.",
                        "default": "desc"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Caps total dataset rows AND total PPE billing for the run. Screener mode returns top-N by sortBy. Technicals/quotes return min(maxResults, symbols.length). Hard cap 500 per run to stay polite to TradingView's endpoint.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy used for TradingView requests. Datacenter is sufficient (endpoint is public, no anti-bot). Override with residential only if you hit 429s from running massive bursts.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
