# TradingView News Scraper (`automation-lab/tradingview-news-scraper`) Actor

Monitor public TradingView market news by feed, provider, market, or symbol. Export exact timestamps, article links, paywall flags, and related symbols to JSON, CSV, or Excel — no login required.

- **URL**: https://apify.com/automation-lab/tradingview-news-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 News Scraper

Extract **public TradingView market news** into structured, timestamped records with TradingView News Scraper.

Collect headlines from the main news landing page, market feeds, provider feeds, or selected symbols — without a TradingView account or API key.

Use the results in trading research, alerts, newsletters, dashboards, spreadsheets, and AI workflows.

### What does TradingView News Scraper do?

TradingView News Scraper turns public [TradingView News](https://www.tradingview.com/news/) feeds into clean JSON, CSV, Excel, XML, or RSS-ready data.

It extracts one record per headline, including:

- 📰 Headline and TradingView article URL
- 🕒 Exact publication time in ISO and Unix formats
- 🏢 Provider name and stable provider ID
- 📈 Primary and related exchange-qualified symbols
- 🔒 Paywall and content-permission indicators
- 🎯 Market, provider, symbol, feed, and section context

The Actor uses lightweight HTTP extraction rather than a browser, so scheduled monitoring starts quickly and avoids unnecessary rendering overhead.

Start with the prefilled main news URL and a limit of 10 headlines for a fast first run.

### Who is TradingView News Scraper for?

**Traders and analysts**

- Monitor headlines related to watched stocks, cryptocurrencies, forex pairs, or indices.
- Add publication times and providers to a research notebook.
- Build a repeatable pre-market or post-market news review.

**Financial-data teams**

- Feed structured headline metadata into a warehouse or search index.
- Deduplicate news with the stable TradingView news ID.
- Join related symbols to quote, screener, or calendar datasets.

**Newsletter and alert operators**

- Run the scraper on a schedule and detect newly published records.
- Route symbol-specific news to Slack, Discord, email, or a webhook.
- Curate provider-specific feeds without manually checking TradingView.

**AI and automation developers**

- Give an agent recent market-news context through the Apify API or MCP.
- Trigger analysis, categorization, or summarization after each run.
- Export predictable primitive columns for low-code tools.

### Why use this TradingView news extractor?

- ✅ **No login required** for the supported public headline metadata.
- ✅ **Exact timestamps**, not only human-readable “hours ago” labels.
- ✅ **Market, provider, and symbol filters** for focused monitoring.
- ✅ **Feed URL support** for familiar TradingView news routes.
- ✅ **Stable IDs and deduplication** across overlapping sections.
- ✅ **Clear paywall metadata** without claiming to bypass publishers.
- ✅ **API, scheduling, webhooks, datasets, and exports** supplied by Apify.
- ✅ **Optional proxy fallback** while direct anonymous HTTP stays the default.

This v1 product deliberately focuses on useful headline metadata. Full external publisher article bodies are not included because access rights and paywalls vary by source.

### What TradingView news data can you extract?

| Category | Fields | Why it matters |
|---|---|---|
| Identity | `newsId`, `title`, `articleUrl` | Deduplicate and open the TradingView story |
| Time | `publishedAt`, `publishedUnix`, `relativeAge`, `scrapedAt` | Sort, monitor, and calculate freshness |
| Provider | `provider`, `providerId`, `permission`, `paywalled` | Attribute and filter sources correctly |
| Instruments | `primarySymbol`, `symbols`, `symbolLogoUrl` | Connect headlines to market instruments |
| Context | `feedUrl`, `feedType`, `marketFilter`, `providerFilter`, `symbolFilter` | Explain why each record matched |
| Signals | `urgency` | Preserve TradingView's public urgency value |

Every table column is a primitive string, number, or boolean. Related symbols are flattened into a comma-separated value for convenient spreadsheet and database exports.

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

This Actor uses **pay-per-event pricing**. A run currently costs a $0.005 start fee plus a tiered price for each saved headline.

| Apify plan tier | Price per headline |
|---|---:|
| Free | $0.000045464 |
| Starter / Bronze | $0.000039533 |
| Scale / Silver | $0.000030836 |
| Business / Gold | $0.000023720 |
| Platinum | $0.000015813 |
| Diamond | $0.000011069 |

At the Bronze price, 100 headlines cost about **$0.0090** including one start fee. Ten headlines cost about **$0.0054**.

Your Apify plan includes platform credits. The prefilled 10-headline run is intentionally small so you can inspect the data cheaply before scheduling a larger workflow.

Prices shown here will always be kept in sync with the live Actor pricing configuration.

### How to scrape TradingView market news

1. Open [TradingView News Scraper](https://apify.com/automation-lab/tradingview-news-scraper) on Apify.
2. Keep the prefilled `https://www.tradingview.com/news/` URL or add a supported market/provider feed.
3. Optionally select markets, provider IDs, or exchange-qualified symbols.
4. Set the maximum number of unique headlines.
5. Click **Start**.
6. Review the dataset and export it as JSON, CSV, Excel, XML, or another supported format.
7. Add a schedule or webhook when you are ready to automate monitoring.

A broad main-feed run:

```json
{
  "startUrls": [{ "url": "https://www.tradingview.com/news/" }],
  "maxItems": 30
}
````

A crypto feed run:

```json
{
  "startUrls": [{ "url": "https://www.tradingview.com/news/markets/crypto/" }],
  "maxItems": 30
}
```

A symbol monitor:

```json
{
  "startUrls": [{ "url": "https://www.tradingview.com/news/" }],
  "symbols": ["NASDAQ:AAPL", "NASDAQ:TSLA"],
  "maxItems": 30
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | TradingView main news URL | Public main, market, provider, or top-story feed URLs |
| `markets` | array | `[]` | TradingView market IDs such as `stock`, `crypto`, or `forex` |
| `providers` | array | `[]` | Provider slugs such as `reuters` or `tradingview` |
| `symbols` | array | `[]` | Exchange-qualified values such as `NASDAQ:AAPL` |
| `maxItems` | integer | `30` | Global maximum of 1–500 unique headlines |
| `proxyConfiguration` | object | Apify Proxy disabled | Optional fallback when direct requests fail |

Supported market IDs are `stock`, `crypto`, `forex`, `futures`, `index`, `bond`, `corp_bond`, `etf`, and `economic`.

Supported feed URL patterns are:

- `https://www.tradingview.com/news/`
- `https://www.tradingview.com/news/markets/<market>/`
- `https://www.tradingview.com/news/top-providers/<provider>/`
- `https://www.tradingview.com/news/top-stories/all/`

Unrelated TradingView pages and individual article URLs fail closed instead of silently changing the requested product scope.

### Output example

A dataset item looks like this:

```json
{
  "newsId": "tradingview:b3c5342bc094b:0",
  "title": "TSLA: Tesla Stock Steady Ahead of Q2 Earnings Report. What to Watch for.",
  "articleUrl": "https://www.tradingview.com/news/tradingview:b3c5342bc094b:0-tsla-tesla-stock-steady-ahead-of-q2-earnings-report-what-to-watch-for/",
  "publishedAt": "2026-07-20T07:38:40.000Z",
  "publishedUnix": 1784533120,
  "relativeAge": "1h",
  "provider": "TradingView",
  "providerId": "tradingview",
  "primarySymbol": "NASDAQ:TSLA",
  "symbols": "NASDAQ:TSLA",
  "symbolLogoUrl": "https://s3-symbol-logo.tradingview.com/tesla.svg",
  "urgency": 2,
  "paywalled": false,
  "permission": "",
  "feedUrl": "https://www.tradingview.com/news/",
  "feedType": "Top stories",
  "marketFilter": "",
  "providerFilter": "",
  "symbolFilter": "",
  "scrapedAt": "2026-07-20T08:40:00.000Z"
}
```

A headline can reference several symbols. In that case, `primarySymbol` stores the first symbol and `symbols` stores all symbols as a comma-separated string.

### Feed and filter recipes

**Latest TradingView headlines**

Use only the main `/news/` URL. This reads public server-rendered sections and deduplicates overlapping records.

**One news provider**

Use `/news/top-providers/reuters/` or add `"providers": ["reuters"]`.

**One market**

Use `/news/markets/crypto/` or add `"markets": ["crypto"]`.

**Several stocks**

Add exchange-qualified symbols:

```json
{
  "symbols": ["NASDAQ:AAPL", "NASDAQ:MSFT", "NASDAQ:NVDA"],
  "maxItems": 30
}
```

Filters are combined. A market plus provider request returns headlines matching the combined TradingView news-flow filter.

### Tips for reliable news monitoring

- Start with 10–30 records and inspect provider and symbol coverage.
- Use exchange-qualified symbols; `AAPL` alone is ambiguous, while `NASDAQ:AAPL` is precise.
- Keep a stable dataset or database keyed by `newsId` to detect newly published headlines.
- Schedule frequent small runs instead of rare oversized runs when freshness matters.
- Use `publishedAt` for event time and `scrapedAt` for collection time.
- Treat `paywalled: true` as a signal that the publisher may restrict article content.
- Leave proxy disabled unless your network receives a consistent source-side block.
- Check run logs if a provider or symbol naturally returns fewer current headlines than expected.

### TradingView News Scraper integrations

**TradingView News Scraper → Google Sheets**

Export fresh headlines to a sheet, use `newsId` for deduplication, and let analysts annotate provider, relevance, or sentiment.

**TradingView News Scraper → Slack or Discord**

Schedule a symbol-filtered run and post only unseen IDs to a market-alert channel through a webhook or Make scenario.

**TradingView News Scraper → Make or Zapier**

Trigger a workflow after a successful run, filter on `primarySymbol`, and create CRM notes, research tasks, or newsletter candidates.

**TradingView News Scraper → data warehouse**

Load the flattened dataset into BigQuery, Snowflake, PostgreSQL, or another destination for joins with prices and calendars.

**TradingView News Scraper → AI analysis**

Pass recent headlines to an LLM for clustering or summarization. Retain the source URL and provider so generated analysis remains traceable.

### Using the Apify API

You can run `automation-lab/tradingview-news-scraper` from any API client.

**Node.js**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tradingview-news-scraper').call({
  startUrls: [{ url: 'https://www.tradingview.com/news/' }],
  symbols: ['NASDAQ:AAPL'],
  maxItems: 30,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/tradingview-news-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.tradingview.com/news/'}],
    'providers': ['reuters'],
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tradingview-news-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.tradingview.com/news/markets/crypto/"}],"maxItems":30}'
```

Use the returned dataset ID to download results after the run succeeds.

### Use with AI agents via MCP

TradingView News Scraper is available to clients that support the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

**Claude Code setup**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/tradingview-news-scraper"
```

**Claude Desktop, Cursor, or VS Code setup**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/tradingview-news-scraper"
    }
  }
}
```

Your client uses OAuth to connect to your Apify account.

Example prompts:

- “Use `automation-lab/tradingview-news-scraper` to collect the latest 30 TradingView headlines related to NASDAQ:AAPL and summarize the themes.”
- “Extract recent Reuters headlines from TradingView and group the output by related symbol.”
- “Run a crypto-news scrape, return exact publication times and providers, and flag records marked as paywalled.”

### Scheduling a stock news monitor

Create an Apify schedule with a small symbol-filtered input and run it every 15 or 30 minutes.

Store the last-seen `newsId` values in your downstream system. When a new ID appears:

1. Verify its `publishedAt` time.
2. Inspect `provider` and `paywalled`.
3. Route the article link to the relevant channel.
4. Optionally enrich it with prices or calendar events.

The Actor returns a snapshot, not a permanently open streaming connection. Scheduled runs make that boundary explicit and easy to control.

### Data quality and limitations

- The supported scope is public TradingView headline metadata.
- Publisher article bodies are not extracted in v1.
- A provider can expose a headline while restricting the linked story.
- Market classification and related symbols come from TradingView's public data.
- Public feed availability and markup can change; the Actor validates the response and fails clearly on total extraction loss.
- Filtered public news-flow responses are bounded by the current TradingView public response size.
- Several landing sections can contain the same story; results are deduplicated by ID.
- `relativeAge` is calculated at scrape time and is intended for display, while `publishedAt` is the durable event timestamp.

### Is it legal to scrape TradingView news?

Scraping public web data is generally permitted in many jurisdictions, but rules depend on the data, website terms, and your use case.

This Actor accesses anonymous public headline metadata and does not bypass login controls or publisher paywalls.

You are responsible for using the data lawfully, respecting applicable terms, copyrights, privacy rules, database rights, and rate limits. Avoid collecting personal data without a valid legal basis. When in doubt, consult qualified legal counsel.

### Troubleshooting

**Why did my symbol filter return fewer headlines than `maxItems`?**

`maxItems` is a ceiling, not a promise. TradingView may currently expose fewer public headlines for that exact exchange-qualified symbol.

**Why is `paywalled` true?**

The public headline is available, but the provider may restrict the linked article. This Actor does not bypass that restriction.

**Why did my start URL fail validation?**

Only the documented public TradingView news-feed patterns are accepted. Use a feed URL, not an individual article, chart, screener, or profile URL.

**Why did the run fail instead of returning an empty dataset?**

A total extraction failure can indicate changed markup, endpoint behavior, or a network block. Failing clearly prevents a silent “successful” monitoring run with no useful data.

**Should I enable Apify Proxy?**

Usually no. Direct anonymous HTTP is the cheapest default. Configure a proxy only when your network consistently cannot reach the public source.

### FAQ

**How fast is TradingView News Scraper?**

Typical small runs use one or a few lightweight HTTP requests and usually finish well under two minutes. Runtime varies with the number of feeds and network conditions.

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

No. The Actor uses public anonymous TradingView headline surfaces for its supported scope.

**Can it scrape full Reuters or other publisher articles?**

No. It extracts TradingView headline metadata and clearly reports paywall status. Full external article bodies are outside v1.

**Can I monitor several symbols at once?**

Yes. Supply exchange-qualified values in `symbols`, such as `NASDAQ:AAPL` and `NASDAQ:TSLA`.

**Does it remove duplicate stories?**

Yes. Stories are deduplicated by TradingView's stable public news ID within each run.

**Can I export to CSV or Excel?**

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and other export formats.

**How is this different from a general TradingView scraper?**

This Actor is purpose-built for market-news headline monitoring. Screeners, quotes, ideas, and calendars are separate datasets and workflows.

### Related financial data actors

Combine news with other public market data from Automation Lab:

- [TradingView Scraper](https://apify.com/automation-lab/tradingview-scraper) — TradingView market and screener data.
- [TradingView Economic Calendar Scraper](https://apify.com/automation-lab/tradingview-economic-calendar-scraper) — scheduled macroeconomic events.
- [TradingView Earnings Calendar Scraper](https://apify.com/automation-lab/tradingview-earnings-calendar-scraper) — company earnings dates and metadata.
- [Google News Scraper](https://apify.com/automation-lab/google-news-scraper) — broader search-driven news discovery.
- [Yahoo Finance Scraper](https://apify.com/automation-lab/yahoo-finance-scraper) — public finance data and market context.
- [StockTwits Scraper](https://apify.com/automation-lab/stocktwits-scraper) — social-market discussion signals.

Use each Actor for its stated source and entity type, then join datasets by symbol, URL, or event time in your own workflow.

### Support and responsible use

If a run fails, include the run URL, a sanitized copy of the input, and the affected feed pattern when reporting the problem through the Actor's Issues tab.

Do not include private credentials or confidential portfolio information in a public issue.

For production monitors, start with a small schedule, validate the output, preserve source attribution, and alert on failed runs as well as new records.

# Actor input Schema

## `startUrls` (type: `array`):

Add public TradingView URLs such as /news/, /news/markets/crypto/, or /news/top-providers/reuters/.

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

Keep headlines classified for selected TradingView markets.

## `providers` (type: `array`):

Add TradingView provider slugs such as reuters, tradingview, stocktwits, or cointelegraph.

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

Add exchange-qualified symbols such as NASDAQ:AAPL, NASDAQ:TSLA, or BINANCE:BTCUSDT.

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

Stop after this many unique public headline records across all requested feeds.

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

Optional Apify Proxy settings used when direct requests fail.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tradingview.com/news/"
    }
  ],
  "markets": [],
  "providers": [],
  "symbols": [],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.tradingview.com/news/"
        }
    ],
    "markets": [],
    "providers": [],
    "symbols": [],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tradingview-news-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 = {
    "startUrls": [{ "url": "https://www.tradingview.com/news/" }],
    "markets": [],
    "providers": [],
    "symbols": [],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tradingview-news-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 '{
  "startUrls": [
    {
      "url": "https://www.tradingview.com/news/"
    }
  ],
  "markets": [],
  "providers": [],
  "symbols": [],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/tradingview-news-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView News Scraper",
        "description": "Monitor public TradingView market news by feed, provider, market, or symbol. Export exact timestamps, article links, paywall flags, and related symbols to JSON, CSV, or Excel — no login required.",
        "version": "0.1",
        "x-build-id": "fXQJuU35hmeNrYZNo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tradingview-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tradingview-news-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-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tradingview-news-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-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tradingview-news-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",
                "properties": {
                    "startUrls": {
                        "title": "TradingView news feed URLs",
                        "type": "array",
                        "description": "Add public TradingView URLs such as /news/, /news/markets/crypto/, or /news/top-providers/reuters/.",
                        "default": [
                            {
                                "url": "https://www.tradingview.com/news/"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "markets": {
                        "title": "Markets",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep headlines classified for selected TradingView markets.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "stock",
                                "crypto",
                                "forex",
                                "futures",
                                "index",
                                "bond",
                                "corp_bond",
                                "etf",
                                "economic"
                            ],
                            "enumTitles": [
                                "Stocks",
                                "Crypto",
                                "Forex",
                                "Futures",
                                "Indices",
                                "Government bonds",
                                "Corporate bonds",
                                "ETFs",
                                "Economics"
                            ]
                        },
                        "default": []
                    },
                    "providers": {
                        "title": "News provider IDs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Add TradingView provider slugs such as reuters, tradingview, stocktwits, or cointelegraph.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,79}$"
                        },
                        "default": []
                    },
                    "symbols": {
                        "title": "TradingView symbols",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Add exchange-qualified symbols such as NASDAQ:AAPL, NASDAQ:TSLA, or BINANCE:BTCUSDT.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z0-9_.-]{1,30}:[A-Za-z0-9_.-]{1,40}$"
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Maximum headlines",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after this many unique public headline records across all requested feeds.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings used when direct requests fail.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
