# TradingView Stock Screener Scraper (`automation-lab/tradingview-scraper`) Actor
Screen stocks, crypto, and forex using TradingView's Scanner API. Filter by sector, market cap, exchange. Returns price, change%, volume, market cap. No API key needed. 14 markets supported.
- **URL**: https://apify.com/automation-lab/tradingview-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet
## Pricing
Pay per event
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/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 Stock Screener Scraper
Extract stock screening data from TradingView's public Scanner API — **no API key, no login, no browser required.** Screen thousands of US stocks, crypto pairs, and forex instruments in seconds. Filter by sector, market cap, exchange, country, and any other TradingView screener column.
📊 [Try it on Apify Store →](https://apify.com/automation-lab/tradingview-scraper)
---
### What does TradingView Stock Screener Scraper do?
TradingView Stock Screener Scraper calls the **publicly accessible TradingView Scanner API** to retrieve screening data for stocks, crypto, and forex. It mirrors the same data powering the [TradingView Stock Screener](https://www.tradingview.com/screener/) web app — but in machine-readable JSON or CSV format, ready for analysis, alerts, or pipeline automation.
Supports **14 markets**: US stocks, crypto, forex, UK, Australia, Canada, Brazil, India, Germany, France, Spain, Italy, Netherlands, and Global. Handles **automatic pagination** for large result sets (thousands of tickers in a single run). Returns price, change%, volume, market cap, sector, industry, and any other column TradingView's screener exposes.
Pure HTTP — **no browser overhead, no Playwright, 256 MB memory.** Runs complete in under 60 seconds for typical screener queries.
---
### Who is it for?
**📈 Quantitative traders and algorithmic investors** who need fresh screener snapshots for backtesting, signal generation, or portfolio scanning. Schedule daily runs to capture opening/closing screener states without logging in.
**📊 Financial analysts and researchers** who export screener results to Excel, Google Sheets, or BI tools (Power BI, Tableau). Skip manual CSV exports — automate the pipeline and always have up-to-date data.
**🤖 Developers building fintech apps** who need a low-cost way to power stock screener features, watchlist apps, or market overview dashboards without subscribing to a paid market data API.
**📉 Hedge funds and family offices** running systematic screening across US, UK, European, and global equities — all from a single actor with consistent output schema.
**🧑💻 Data engineers** building financial data pipelines who need structured, paginated access to TradingView's screener without reverse-engineering the API themselves.
---
### Why use TradingView Stock Screener Scraper?
- ✅ **No API key or login required** — TradingView's Scanner API is public
- ✅ **14 markets in one actor** — US, crypto, forex, UK, EU, APAC, global
- ✅ **Full pagination** — fetch all matching tickers, not just the first page
- ✅ **Custom columns** — request only the fields you need (price, volume, RSI, EPS, etc.)
- ✅ **Flexible filters** — filter by sector, market cap range, exchange, P/E ratio, and any other screener field
- ✅ **Pure HTTP, 256 MB** — runs fast and costs pennies
- ✅ **Structured output** — named fields ready for CSV/JSON export or database insertion
- ✅ **Apify platform** — schedule runs, trigger via webhook, integrate with 5,000+ apps via Zapier and Make
- ✅ **No rate limit issues** — the Scanner API is designed for bulk queries
---
### What data can you extract?
The output depends on which columns you request. Default columns include:
| Field | Description | Example |
|-------|-------------|---------|
| `symbol` | Ticker symbol | `NVDA` |
| `exchange` | Exchange | `NASDAQ` |
| `fullSymbol` | Exchange:Symbol | `NASDAQ:NVDA` |
| `name` | Company/instrument name | `NVIDIA Corporation` |
| `price` | Current price (close) | `175.75` |
| `changePercent` | % change | `0.77` |
| `changeAbs` | Absolute price change | `1.35` |
| `volume` | Trading volume | `168132005` |
| `marketCap` | Market capitalization (USD) | `4270725000000` |
| `sector` | Sector classification | `Electronic Technology` |
| `industry` | Industry classification | `Semiconductors` |
| `country` | Country of listing | `United States` |
| `scrapedAt` | Timestamp | `2026-04-02T13:00:00.000Z` |
**Additional columns available** (add to `columns` input): `pe_ratio`, `eps_diluted`, `earnings_per_share_basic_ttm`, `dividends_yield`, `52_week_high`, `52_week_low`, `relative_volume`, `average_volume_10d_calc`, `price_earnings_ttm`, `return_on_equity`, `debt_to_equity`, and hundreds more — any field available in TradingView's screener can be requested.
---
### How much does it cost to scrape TradingView screener data?
This actor uses **Pay Per Event (PPE)** pricing. You are charged per ticker extracted plus a small start fee.
| Event | FREE plan | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|-------|-----------|--------|--------|------|----------|---------|
| Run started | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Per ticker | $0.00115 | $0.001 | $0.00078 | $0.0006 | $0.0004 | $0.00028 |
**Real-world cost examples:**
- Screen top 50 US stocks by market cap: ~$0.055 ($0.005 start + 50 × $0.001)
- Screen 500 tech stocks with filters: ~$0.505
- Full US market scan (19,000+ tickers): ~$19 + start fee
**Free plan estimate:** Apify gives $5 in free credits. That's ~4,300 tickers on the free plan — enough for multiple full US market scans.
---
### How to scrape TradingView screener data
1. **Go to** [TradingView Stock Screener Scraper on Apify Store](https://apify.com/automation-lab/tradingview-scraper)
2. **Click "Try for free"** — you'll get $5 in free credits on signup
3. **Select a market** — choose US Stocks, Crypto, Forex, or another market from the dropdown
4. **Set your filters** (optional) — add sector, market cap, or other screener conditions using JSON filter objects
5. **Choose columns** — select which data fields to return, or leave at defaults
6. **Set max results** — limit results or set to 0 for all matching tickers
7. **Click "Start"** — results appear in the Dataset tab, downloadable as JSON, CSV, or Excel
**Example: Screen large-cap tech stocks**
```json
{
"market": "america",
"filters": [
{"left": "sector", "operation": "equal", "right": "Technology Services"},
{"left": "market_cap_basic", "operation": "greater", "right": 10000000000}
],
"sortBy": "market_cap_basic",
"sortOrder": "desc",
"maxResults": 100
}
````
**Example: Top 20 crypto by market cap**
```json
{
"market": "crypto",
"columns": ["name", "description", "close", "change", "volume", "market_cap_calc"],
"sortBy": "market_cap_calc",
"sortOrder": "desc",
"maxResults": 20
}
```
**Example: Forex pairs sorted by daily change**
```json
{
"market": "forex",
"sortBy": "change",
"sortOrder": "desc",
"maxResults": 50
}
```
***
### Input parameters
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `market` | string | `america` | Market to screen: `america`, `crypto`, `forex`, `uk`, `australia`, `canada`, `brazil`, `india`, `germany`, `france`, `spain`, `italy`, `netherlands`, `global` |
| `columns` | array | see below | List of TradingView column IDs to return. Defaults to name, price, change%, volume, market cap, sector, industry, exchange, country |
| `sortBy` | string | `market_cap_basic` | Field to sort results by |
| `sortOrder` | string | `desc` | `desc` (highest first) or `asc` (lowest first) |
| `filters` | array | `[]` | Array of filter objects: `{left, operation, right}`. Operations: `equal`, `not_equal`, `greater`, `less`, `greater_or_equal`, `less_or_equal`, `in_range` |
| `maxResults` | integer | `200` | Maximum tickers to return. Set to `0` for all matching results |
**Default columns:**
```
name, description, close, change, change_abs, volume, market_cap_basic, sector, industry, exchange, country
```
***
### Output examples
**US Stock:**
```json
{
"symbol": "NVDA",
"exchange": "NASDAQ",
"fullSymbol": "NASDAQ:NVDA",
"name": "NVIDIA Corporation",
"price": 175.75,
"changePercent": 0.77,
"changeAbs": 1.35,
"volume": 168132005,
"marketCap": 4270725000000,
"sector": "Electronic Technology",
"industry": "Semiconductors",
"country": "United States",
"scrapedAt": "2026-04-02T13:00:00.000Z"
}
```
**Crypto:**
```json
{
"symbol": "BTCUSD",
"exchange": "BINANCE",
"fullSymbol": "BINANCE:BTCUSD",
"name": "Bitcoin / USD",
"price": 66100.0,
"changePercent": -2.99,
"changeAbs": null,
"volume": 2.14,
"marketCap": null,
"market_cap_calc": 1322066558689,
"scrapedAt": "2026-04-02T13:00:00.000Z"
}
```
***
### Tips for best results
- 💡 **Start with 50-100 results** to test your filter configuration before scaling up
- 💡 **Use `filters` to narrow results** — scanning 19,000 US stocks costs ~$19; filtering to 500 tech stocks costs ~$0.50
- 💡 **Request only needed columns** — fewer columns = faster response times
- 💡 **Check column names** by opening TradingView's screener, enabling a column, and noting its ID from the API URL
- 💡 **For crypto, use `market_cap_calc`** instead of `market_cap_basic` — crypto market cap uses a different field name
- 💡 **Schedule daily runs** using Apify's built-in scheduler for fresh market snapshots without manual intervention
- 💡 **Use `in_range` operation** for range filters: `{"left": "market_cap_basic", "operation": "in_range", "right": [1000000000, 10000000000]}`
- 💡 **`maxResults: 0` fetches all matching tickers** — useful for complete market snapshots
***
### Integrations
**TradingView Screener → Google Sheets:** Schedule a daily run at 9am EST. Use Apify's Google Sheets integration to automatically write screener results to a spreadsheet. Build live dashboards without manual exports.
**TradingView Screener → Slack alerts:** Combine with Apify webhooks + Slack webhook to get morning Slack messages listing top gainers or stocks meeting your criteria.
**TradingView Screener → Make (Integromat) / Zapier:** Trigger a workflow whenever the screener run completes. Push filtered stock data to Airtable, Notion, or your CRM.
**TradingView Screener → Python analysis pipeline:** Pull JSON results into Pandas for backtesting or statistical screening. No authentication headaches.
**Scheduled monitoring:** Run the screener every hour during market hours to capture intraday momentum shifts. Store snapshots in Apify's dataset for time-series analysis.
***
### API usage
#### Node.js
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('automation-lab/tradingview-scraper').call({
market: 'america',
filters: [
{ left: 'sector', operation: 'equal', right: 'Technology Services' },
{ left: 'market_cap_basic', operation: 'greater', right: 1000000000 }
],
sortBy: 'market_cap_basic',
sortOrder: 'desc',
maxResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} tickers`);
items.forEach(t => console.log(`${t.symbol}: $${t.price} (${t.changePercent}%)`));
```
#### Python
```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/tradingview-scraper').call(run_input={
'market': 'america',
'filters': [
{'left': 'sector', 'operation': 'equal', 'right': 'Technology Services'},
{'left': 'market_cap_basic', 'operation': 'greater', 'right': 1_000_000_000},
],
'sortBy': 'market_cap_basic',
'sortOrder': 'desc',
'maxResults': 100,
})
items = list(client.dataset(run['defaultDatasetId']).iterate_items())
print(f'Scraped {len(items)} tickers')
for ticker in items[:5]:
print(f"{ticker['symbol']}: ${ticker['price']} ({ticker['changePercent']:.2f}%)")
```
#### cURL
```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~tradingview-scraper/runs?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"market": "america",
"filters": [
{"left": "sector", "operation": "equal", "right": "Technology Services"}
],
"sortBy": "market_cap_basic",
"sortOrder": "desc",
"maxResults": 100
}'
```
***
### Use with AI agents via MCP
TradingView Stock Screener Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).
Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:
#### Setup for Claude Code
```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```
#### Setup for Claude Desktop, Cursor, or VS Code
Add this to your MCP config file:
```json
{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com"
}
}
}
```
Your AI assistant will use OAuth to authenticate with your Apify account on first use.
#### Example prompts
Once connected, try asking your AI assistant:
- "Use automation-lab/tradingview-scraper to find the top 50 US tech stocks by market cap and show me which ones are up more than 2% today"
- "Screen all crypto pairs on TradingView and find the ones with the highest 24h volume"
- "Get the current forex pairs sorted by daily change percent and identify the top movers"
Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).
***
### Legality — is it legal to scrape TradingView screener data?
TradingView's stock screener uses a **publicly accessible API** — the same endpoint used by their website, accessible without authentication or login. This actor only reads data that any website visitor can access through their browser.
We follow ethical web scraping principles:
- Only public, non-authenticated endpoints are accessed
- No user accounts or personal data are scraped
- Data is used for informational and analytical purposes
- Reasonable request rates are maintained
**Note:** This actor is not affiliated with or endorsed by TradingView. Users are responsible for ensuring their use complies with [TradingView's Terms of Service](https://www.tradingview.com/policies/). This tool is intended for personal research, analysis, and development use cases.
***
### FAQ
**How fast does the scraper run?**
Very fast. A typical run fetching 200 tickers completes in under 10 seconds. Even a full US market scan (19,000+ tickers) finishes in under 5 minutes. The Scanner API supports batches of 200 tickers per request.
**How much does it cost to screen 1,000 stocks?**
Approximately $1.005 on the BRONZE plan ($0.005 start + 1,000 × $0.001). On the GOLD plan, it's ~$0.605. Use filters to narrow results and reduce costs significantly.
**How is this different from the official TradingView API?**
TradingView offers a paid official API (Pine Script / broker integrations) but does not provide a public REST API for screener data. This actor uses the same undocumented Scanner API that powers TradingView's own web screener — giving you equivalent data without a paid TradingView subscription.
**Why are some fields returning null?**
Not all fields are available for all markets. For example, `market_cap_basic` is used for stocks but crypto uses `market_cap_calc`. `sector` and `industry` are only available for stocks. Check your `columns` input matches the correct field names for your chosen market.
**Why are results empty or fewer than expected?**
Your filter criteria may be too restrictive. Try removing filters one by one to identify which condition is too narrow. Also verify the field names — TradingView uses exact column IDs (e.g., `market_cap_basic`, not `marketCap`).
**Can I get real-time data?**
The Scanner API returns near-real-time data (delayed 15 minutes for most exchanges). For real-time quotes, a paid TradingView subscription with their official data feeds would be required.
**What TradingView screener columns are available?**
Hundreds of columns are available: fundamental data (P/E, EPS, revenue), technical indicators (RSI, MACD, moving averages), volume metrics, earnings dates, analyst ratings, and more. The exact list depends on the market. Explore TradingView's screener interface to discover column names.
***
### Related — other finance & market data scrapers
- 🔗 [DexScreener Scraper](https://apify.com/automation-lab/dexscreener-scraper) — Crypto token data across 60+ blockchains
- 🔗 [Amazon Bestsellers Scraper](https://apify.com/automation-lab/amazon-bestsellers-scraper) — Product rankings and pricing data
- 🔗 [Bing Search Scraper](https://apify.com/automation-lab/bing-search-scraper) — SERP data for market research
- 🔗 [Apify Store — Finance category](https://apify.com/store?category=FINANCE) — All finance data actors
# Actor input Schema
## `market` (type: `string`):
Select the market to screen. US Stocks covers NASDAQ, NYSE, AMEX. Crypto covers all crypto pairs across exchanges. Forex covers all currency pairs. UK Stocks covers LSE. Global covers all markets worldwide.
## `columns` (type: `array`):
Select which data fields to include in the output. Leave empty for the default set (name, price, change%, volume, market cap, sector, industry).
## `sortBy` (type: `string`):
Field to sort results by. Common options: market\_cap\_basic, volume, change, close.
## `sortOrder` (type: `string`):
Sort results in ascending or descending order.
## `filters` (type: `array`):
Optional array of filter conditions. Each filter is an object with left (field name), operation (equal, greater, less, in\_range, not\_equal), and right (value). Example: \[{"left": "sector", "operation": "equal", "right": "Technology Services"}, {"left": "market\_cap\_basic", "operation": "greater", "right": 1000000000}]
## `maxResults` (type: `integer`):
Maximum number of tickers to return. Set to 0 for no limit (can return thousands). TradingView paginates in batches of 200.
## Actor input object example
```json
{
"market": "america",
"columns": [
"name",
"description",
"close",
"change",
"change_abs",
"volume",
"market_cap_basic",
"sector",
"industry",
"exchange",
"country"
],
"sortBy": "market_cap_basic",
"sortOrder": "desc",
"filters": [],
"maxResults": 20
}
```
# Actor output Schema
## `overview` (type: `string`):
No description
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"market": "america",
"columns": [
"name",
"description",
"close",
"change",
"change_abs",
"volume",
"market_cap_basic",
"sector",
"industry",
"exchange",
"country"
],
"sortBy": "market_cap_basic",
"sortOrder": "desc",
"filters": [],
"maxResults": 20
};
// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"market": "america",
"columns": [
"name",
"description",
"close",
"change",
"change_abs",
"volume",
"market_cap_basic",
"sector",
"industry",
"exchange",
"country",
],
"sortBy": "market_cap_basic",
"sortOrder": "desc",
"filters": [],
"maxResults": 20,
}
# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
"market": "america",
"columns": [
"name",
"description",
"close",
"change",
"change_abs",
"volume",
"market_cap_basic",
"sector",
"industry",
"exchange",
"country"
],
"sortBy": "market_cap_basic",
"sortOrder": "desc",
"filters": [],
"maxResults": 20
}' |
apify call automation-lab/tradingview-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=automation-lab/tradingview-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "TradingView Stock Screener Scraper",
"description": "Screen stocks, crypto, and forex using TradingView's Scanner API. Filter by sector, market cap, exchange. Returns price, change%, volume, market cap. No API key needed. 14 markets supported.",
"version": "0.1",
"x-build-id": "KeE1Ruw4GDg803V23"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/automation-lab~tradingview-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~tradingview-scraper/runs": {
"post": {
"operationId": "runs-sync-automation-lab-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/automation-lab~tradingview-scraper/run-sync": {
"post": {
"operationId": "run-sync-automation-lab-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": [
"market"
],
"properties": {
"market": {
"title": "Market",
"enum": [
"america",
"crypto",
"forex",
"uk",
"australia",
"canada",
"brazil",
"india",
"germany",
"france",
"spain",
"italy",
"netherlands",
"global"
],
"type": "string",
"description": "Select the market to screen. US Stocks covers NASDAQ, NYSE, AMEX. Crypto covers all crypto pairs across exchanges. Forex covers all currency pairs. UK Stocks covers LSE. Global covers all markets worldwide.",
"default": "america"
},
"columns": {
"title": "Data columns to return",
"type": "array",
"description": "Select which data fields to include in the output. Leave empty for the default set (name, price, change%, volume, market cap, sector, industry).",
"default": [
"name",
"description",
"close",
"change",
"change_abs",
"volume",
"market_cap_basic",
"sector",
"industry",
"exchange",
"country"
],
"items": {
"type": "string"
}
},
"sortBy": {
"title": "Sort by",
"type": "string",
"description": "Field to sort results by. Common options: market_cap_basic, volume, change, close.",
"default": "market_cap_basic"
},
"sortOrder": {
"title": "Sort order",
"enum": [
"desc",
"asc"
],
"type": "string",
"description": "Sort results in ascending or descending order.",
"default": "desc"
},
"filters": {
"title": "Filters (advanced)",
"type": "array",
"description": "Optional array of filter conditions. Each filter is an object with left (field name), operation (equal, greater, less, in_range, not_equal), and right (value). Example: [{\"left\": \"sector\", \"operation\": \"equal\", \"right\": \"Technology Services\"}, {\"left\": \"market_cap_basic\", \"operation\": \"greater\", \"right\": 1000000000}]",
"default": []
},
"maxResults": {
"title": "Max results",
"minimum": 0,
"type": "integer",
"description": "Maximum number of tickers to return. Set to 0 for no limit (can return thousands). TradingView paginates in batches of 200.",
"default": 200
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```