# Stock News Monitor - Headlines, Buzz and Sentiment per Ticker (`saekoto/stock-news-monitor`) Actor

Monitor a list of tickers for news: Google News and Yahoo Finance headlines with a sentiment label, new headlines since the last run, Stocktwits bull/bear ratio and price context. No API keys, $5 per 1,000 tickers.

- **URL**: https://apify.com/saekoto/stock-news-monitor.md
- **Developed by:** [Soproni Dániel](https://apify.com/saekoto) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 ticker checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## Stock News Monitor - Headlines, Buzz and Sentiment per Ticker

Give it a list of tickers and get one flat row per ticker: every headline Google News and Yahoo Finance published about the company in the last N days, deduplicated and counted, each one labelled positive / negative / neutral by a transparent finance lexicon, the share of Stocktwits posters tagging the symbol bullish, the last price with 1-day / 5-day / 30-day change and volume versus its 20-day average, and, on a Schedule, how many headlines are new since the previous run. Every source is public and key-free, read over plain HTTP: no browser, no login, no API keys. Pricing is pay-per-event, $5 per 1,000 tickers checked and $0.50 per 1,000 headline rows, no start fee, and nothing is charged for a ticker Yahoo does not know or for one where both news feeds failed.

Source on GitHub, MIT licensed. Not investment advice: this actor counts and labels public headlines, it does not predict prices, and nothing in its output is a recommendation to buy or sell anything.

Three things set it apart from the news scrapers in the Store:

- **One row per ticker, priced per ticker.** `headline_count`, `headline_count_24h`, the positive / negative / neutral split with an average score, the top sources, the five latest headlines and the Stocktwits and price context, in a single flat row you can drop into a sheet, a dashboard or an alert.
- **Only headlines that are actually about the company.** Yahoo's per-ticker feed pads with unrelated market stories (15 of the 17 NVDA items on 2026-10-29 did not mention Nvidia). A mention filter drops them and `headlines_fetched` tells you how many were dropped. Turn it off if you want everything.
- **Run-to-run change detection.** Turn on `trackChanges`, put the actor on a Schedule, and every run reports how many headlines are new since the last one and how the count moved. Free. Headline rows carry `is_new_since_last_run`.

### What you get

One real ticker row for `PLTR`, from a live run on 2026-10-29 with the default settings (`mode: "summary"`, 7-day window, Stocktwits 1 page, change tracking off):

```json
{
  "row_type": "ticker",
  "ticker": "PLTR",
  "company_name": "Palantir Technologies Inc.",
  "exchange": "NASDAQ",
  "checked_at": "2026-10-29T19:14:11.188Z",
  "window_days": 7,
  "status": "ok",
  "headline_count": 66,
  "headlines_fetched": 72,
  "headline_count_24h": 19,
  "headlines_per_day": 9.4,
  "google_news_capped": false,
  "sentiment_label": "positive",
  "sentiment_score": 0.162,
  "sentiment_positive": 18,
  "sentiment_negative": 8,
  "sentiment_neutral": 40,
  "buzz_flag": null,
  "buzz_ratio": null,
  "stocktwits_bull_ratio": 0.625,
  "price_last": 193.61,
  "price_change_1d_pct": -1.63,
  "gdelt": null,
  "stocktwits": {
    "messages_sampled": 30,
    "bullish": 5,
    "bearish": 3,
    "unlabeled": 22,
    "bull_ratio": 0.625,
    "messages_per_hour": 14.2,
    "span_hours": 2.04,
    "watchlist_count": 325472,
    "newest_message_at": "2026-10-29T19:11:05.000Z",
    "oldest_message_at": "2026-10-29T17:08:36.000Z",
    "pages_read": 1
  },
  "price": {
    "currency": "USD",
    "exchange": "NasdaqGS",
    "last": 193.61,
    "prev_close": 196.81,
    "change_1d_pct": -1.63,
    "change_5d_pct": -1.32,
    "change_30d_pct": 3.51,
    "volume_last": 12892802,
    "volume_avg_20d": 22486000,
    "volume_ratio": 0.573,
    "as_of": "2026-10-29T19:11:45.000Z"
  },
  "top_sources": [
    { "source": "Yahoo Finance", "count": 9 },
    { "source": "TradingView", "count": 5 },
    { "source": "Benzinga", "count": 4 },
    { "source": "finance.yahoo.com", "count": 4 },
    { "source": "Investing.com Canada", "count": 3 }
  ],
  "top_headlines": [
    {
      "title": "Why J.P. Morgan Believes Palantir Stock Is Just Getting Going After a Lackluster 2026",
      "source": "finance.yahoo.com",
      "url": "https://finance.yahoo.com/m/ea73e0e6-1f97-3d96-9c86-0b7e89d1ec67/why-j.p.-morgan-believes.html",
      "published_at": "2026-10-29T18:00:00.000Z",
      "sentiment_label": "negative"
    },
    {
      "title": "Palantir Seen Beating Revenue Estimates, Raising Guidance, Oppenheimer Says",
      "source": "finance.yahoo.com",
      "url": "https://finance.yahoo.com/markets/stocks/articles/palantir-seen-beating-revenue-estimates-164852851.html",
      "published_at": "2026-10-29T16:48:52.000Z",
      "sentiment_label": "positive"
    },
    {
      "title": "Palantir Stock Drops: What's Going On?",
      "source": "Benzinga",
      "url": "https://news.google.com/rss/articles/CBMinAFBVV95cUxQVGpLYjRGQnpoT2JSNlV0YjR4WFg2WHhGMFZfU0huVzZNZEdyQURGLXJjWHRoMHMxUU5rMUFzRmhkQ2hoSEs1MGY5QzNkeU1QX0F5Qm13a0pnUEJPdFRiRHluekRsellSbE5nMFExYW5CMV95MHV1YVlTMkNzbW5DX2NmQWVrU0g4QkM1eWFTWkdqMGJ6aGpmeDBwSFc?oc=5",
      "published_at": "2026-10-29T16:12:16.000Z",
      "sentiment_label": "negative"
    }
  ],
  "change_tracking": null,
  "sources_ok": ["yahoo_search", "yahoo_rss", "stocktwits", "google_news", "yahoo_chart"],
  "warnings": [],
  "error": null
}
```

Reading it: in the last 7 days the two feeds returned 72 headlines tagged PLTR, 66 of which name Palantir; 19 of those were published in the last 24 hours, about 9 a day over the week. 18 read positive and 8 negative by the lexicon, so the week nets mildly positive. Of the 30 most recent Stocktwits posts, 5 were tagged bullish and 3 bearish; the rest carried no tag. The stock was down 1.6% on the day on roughly half its usual volume.

One real headline row (`mode: "headlines"` or `"both"`), the first for the same ticker:

```json
{
  "row_type": "headline",
  "ticker": "PLTR",
  "headline_key": "960376a717bd257e",
  "title": "Palantir Seen Beating Revenue Estimates, Raising Guidance, Oppenheimer Says",
  "source": "finance.yahoo.com",
  "url": "https://finance.yahoo.com/markets/stocks/articles/palantir-seen-beating-revenue-estimates-164852851.html",
  "published_at": "2026-10-29T16:48:52.000Z",
  "origin": "yahoo_finance",
  "mentions_company": true,
  "sentiment_label": "positive",
  "sentiment_score": 1,
  "positive_terms": ["beating", "raising guidance"],
  "negative_terms": [],
  "is_new_since_last_run": null,
  "scraped_at": "2026-10-29T19:14:11.188Z"
}
```

`positive_terms` and `negative_terms` are the exact lexicon hits that produced the score, so you can audit any label, filter on specific terms, or re-score the title with your own model.

### Use cases

**Daily market recap, newsletter or video research.** Run `mode: "both"` on your coverage list every morning. The ticker rows tell you which names had a loud day and which way the headlines leaned; the headline rows give you the deduplicated reading list with links. 20 tickers a day is 20 checks plus about 1,500 headline rows, roughly $0.85 a day.

**Investor-relations and PR monitoring.** Put your own ticker and your peers on an hourly Schedule with `trackChanges: true` and `mode: "both"`. `change_tracking.new_headlines` on the ticker row and `is_new_since_last_run` on the headline rows give you only what is new since the last hour, ready for a Slack or email integration. Media-monitoring suites charge hundreds a month for this.

**A research journal for your own watchlist.** Run it daily on the names you follow and keep the dataset. In a few months you have, for every day, what was written, how it leaned and what the price did next, which is the raw material for an honest look at whether the news you react to actually meant anything. It will not tell you what to buy. It will show you what you were reading when you decided.

### Input

| Field | Type | Default | Notes |
| --- | --- | --- | --- |
| `tickers` | string\[] | `["NVDA","AAPL","TSLA"]` (prefill) | Yahoo Finance symbols: `NVDA`, `BRK-B`, `ASML.AS`, `7203.T`, `^GSPC`. A leading `$` is stripped, case is ignored, duplicates are removed. Soft cap 1,000 per run. |
| `mode` | `summary` / `headlines` / `both` | `summary` | One row per ticker, one row per headline, or both in one dataset (`row_type` tells them apart). |
| `windowDays` | 1-30 | `7` | How far back headlines are collected and counted. |
| `requireMention` | boolean | `true` | Keep a headline only when its title contains the ticker or a distinctive word of the company name. `headlines_fetched` always reports the unfiltered count. |
| `maxHeadlinesPerTicker` | 1-500 | `100` | Cap on headline rows per ticker in `headlines` / `both` mode, newest first. The ticker row always counts every headline collected. |
| `stocktwitsPages` | 0-10 | `3` | Pages of 30 recent Stocktwits posts to aggregate. `0` skips Stocktwits. Only counts are emitted, never posts or users. |
| `includePrice` | boolean | `true` | Last price, 1d / 5d / 30d change and volume vs 20-day average from Yahoo Finance. |
| `includeGdelt` | boolean | `false` | Experimental: 30-day daily mention-volume series from the GDELT DOC API for `buzz_ratio` / `buzz_flag`. GDELT throttles hard (see limits), so it is off by default. |
| `trackChanges` | boolean | `false` | Remember the headlines seen per ticker and report what is new next run. Free. |
| `stateStoreName` | string | `stock-news-monitor-state` | Key-value store that holds the per-ticker snapshot. Use one name per watchlist. |
| `proxyConfiguration` | proxy | Apify datacenter | All sources are public, but Yahoo and Stocktwits throttle shared datacenter IPs. Switch to `RESIDENTIAL` if a run reports many 403 / 429 warnings. |
| `requestDelayMs` | 100-10000 | `500` | Minimum gap between two requests to the same host across the whole run. GDELT is always paced at 10 s. |
| `maxConcurrency` | 1-8 | `4` | Tickers processed in parallel. |

### Output

#### Ticker row (`row_type: "ticker"`, event `ticker-check`)

| Field | Meaning |
| --- | --- |
| `ticker`, `company_name`, `exchange` | The symbol as normalised, and what Yahoo Finance calls it. |
| `checked_at`, `window_days` | When the row was built and the window it covers. |
| `status` | `ok`, `not_found` (Yahoo knows no such symbol, not charged) or `error` (both news feeds failed, not charged). |
| `headline_count` | Deduplicated headlines inside the window after the mention filter. |
| `headlines_fetched` | The same before the mention filter. |
| `headline_count_24h`, `headlines_per_day` | Headlines published in the last 24 hours, and the average per day over the window. |
| `google_news_capped` | `true` when Google News returned its maximum of 100 items, so the window is only sampled (see limits). |
| `sentiment_label`, `sentiment_score` | Average headline score over the window and the label it implies (`positive` above 0.15, `negative` below -0.15, else `neutral`). `null` with no headlines. |
| `sentiment_positive`, `sentiment_negative`, `sentiment_neutral` | How many headlines fell in each bucket. |
| `stocktwits_bull_ratio`, `stocktwits` | `bullish / (bullish + bearish)` over the sampled posts, plus the counts, posts per hour, the span sampled and the symbol's watchlist count. `null` when the symbol is not on Stocktwits (most non-US listings). |
| `price_last`, `price_change_1d_pct`, `price` | Last regular-market price, the change against the previous close, and the full context object (5d / 30d change, volume and its 20-day average, currency, exchange, timestamp). |
| `buzz_flag`, `buzz_ratio`, `gdelt` | Only with `includeGdelt`: latest GDELT day's mention volume divided by the mean of the previous days, flagged `unusual_high` (2x or more), `elevated` (1.3x), `normal` or `quiet` (0.5x or less). `null` otherwise. |
| `top_sources` | The five publishers with the most headlines in the window. |
| `top_headlines` | The five most recent headlines with source, link, time and label. |
| `change_tracking` | With `trackChanges`: `previous_run_at`, `previous_headline_count`, `new_headlines` (never seen in an earlier run) and `headline_count_change_pct`. `null` otherwise. |
| `sources_ok`, `warnings` | Which of the six sources answered, and one line per source that did not (the ticker is still delivered). |
| `error` | Only on `not_found` / `error` rows. |

#### Headline row (`row_type: "headline"`, event `headline-row`)

| Field | Meaning |
| --- | --- |
| `ticker`, `headline_key` | The ticker and a stable 16-hex id derived from the normalised title (the same story from both feeds gets one key). |
| `title`, `source`, `url`, `published_at` | The headline, the publisher, the link and the publication time. Yahoo links are direct; Google News links are Google redirect URLs. |
| `origin` | `google_news` or `yahoo_finance`: which feed delivered it first. |
| `mentions_company` | Whether the title names the company or ticker. Always `true` when `requireMention` is on. |
| `sentiment_label`, `sentiment_score` | `positive` / `negative` / `neutral` and `(positive - negative) / (positive + negative)` over the matched terms. |
| `positive_terms`, `negative_terms` | The lexicon hits, with `not ...` prefixes where a negator flipped a term. |
| `is_new_since_last_run` | With `trackChanges`: `true` when no earlier run saw this key. `null` otherwise. |
| `scraped_at` | When the row was built. |

Run metrics (requests, blocked requests, failures per source, tickers by outcome, charge counters) are stored in the `OUTPUT` record of the run's default key-value store.

### Pricing

| Event | Price | Charged when |
| --- | --- | --- |
| `ticker-check` | $0.005 | A ticker row with `status: "ok"` is pushed (`summary` and `both` modes). Never for `not_found` or `error` rows. |
| `headline-row` | $0.0005 | A headline row is pushed (`headlines` and `both` modes), deduplicated by title within the run. |

No start fee. 1,000 tickers in `summary` mode cost $5.00. With the defaults a ticker is 5 to 7 requests (search, Google News, Yahoo RSS, chart, 3 Stocktwits pages) and about 250 KB of transfer, which is under $0.001 of platform usage on datacenter proxies, so the check price is almost entirely the product.

The maximum total charge you set on the run is respected: the actor stops taking new tickers once the budget would be exceeded and reports how many were not delivered. A ticker is never charged without its row in the dataset.

### Limits, honestly

- **Google News returns at most 100 items per query.** For heavily covered names (NVDA, AAPL, TSLA) a 7-day window hits that cap, `google_news_capped` is `true`, and `headline_count` is a sample, not a census. The sample also rotates slightly between runs, which inflates `new_headlines` for capped tickers until a few runs have been seen. Use a shorter `windowDays` for busy names if you need completeness.
- **Sentiment is a keyword count, not understanding.** It uses a finance lexicon of about 300 words and phrases with simple negation. It sorts a day's headlines into "mostly bad" / "mostly good" well enough and gets individual headlines wrong regularly ("gained access" counts as a gain). Every row carries the matched terms so you can see exactly why. In the live runs about a third of headlines received a label and the rest stayed neutral.
- **Stocktwits sentiment is self-reported** by the fraction of posters who tag a post, typically a third. `bull_ratio` is that fraction's lean, nothing more, and the symbol stream only exists for US-listed names.
- **Price context is context.** The last price is Yahoo's regular-market quote at run time, which during the session is intraday. Volume ratios during the session compare a partial day with full days.
- **GDELT (`includeGdelt`) is experimental.** The free DOC API allows about one request every 5 to 10 seconds per IP and imposes a cooldown after a burst; from a shared IP it often refuses. When it does, the buzz fields are `null`, the warning says so and the ticker is delivered and charged normally. It also lags one to two days.
- **Yahoo Finance and Stocktwits throttle datacenter IPs.** Blocks are retried on a fresh proxy session; a source that stays blocked is reported in `warnings` and the ticker is still delivered from the sources that answered. If every news source is blocked for every ticker, the run fails with a clear message instead of finishing green with an empty dataset.
- **Google News links are redirects** (`news.google.com/rss/articles/...`). The publisher's home is in the source; resolving the final article URL would cost one request per headline and is not done.
- **Not investment advice.** The author is not a licensed advisor. The actor reports what was published; it has no opinion about what a security is worth.

### Change tracking

With `trackChanges: true` the actor keeps one record per ticker in the key-value store named by `stateStoreName`: the time of the last run, its headline count and the keys of every headline seen with the date it was first seen (pruned after 90 days). On each run, a headline whose key is absent from the snapshot is new. The snapshot is written only after the ticker's rows were delivered, so a run that stops at the charge limit re-diffs the undelivered tickers next time. Use a different store name for each watchlist; the first run on a new store reports every headline as new.

### Changelog and support

Source-side observations (endpoints, payload shapes, throttling) are recorded in the changelog with the date they were verified. Issues are answered within 24 hours.

# Changelog

This Actor's version history is a separate document: https://apify.com/saekoto/stock-news-monitor/changelog.md

# Actor input Schema

## `tickers` (type: `array`):

Stock symbols as Yahoo Finance spells them, one per line (NVDA, AAPL, BRK-B, ASML.AS, 7203.T). A leading $ is stripped, case is ignored and duplicates are removed. Soft cap 1,000 per run.

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

summary = one row per ticker (event ticker-check). headlines = one row per headline (event headline-row). both = both row types in the same dataset; the row_type field tells them apart.

## `windowDays` (type: `integer`):

How far back headlines are collected and counted. Google News returns at most 100 items per query, so busy tickers are capped at 100 headlines for any window (the google_news_capped field says when that happened).

## `requireMention` (type: `boolean`):

Keep a headline only when its title contains the ticker or a distinctive word of the company name. Yahoo's per-ticker feed pads with unrelated market stories (15 of 17 NVDA items on 2026-10-29 did not mention Nvidia); this drops them. Turn off to count everything the feeds returned. headlines_fetched always reports the unfiltered number.

## `maxHeadlinesPerTicker` (type: `integer`):

Cap on headline rows emitted per ticker in headlines and both modes, newest first. The summary row always counts every headline collected.

## `stocktwitsPages` (type: `integer`):

Pages of 30 messages read from the public Stocktwits symbol stream to compute the bullish/bearish ratio and the messages-per-hour rate. 0 skips Stocktwits. Individual messages are never emitted, only the counts.

## `includeGdelt` (type: `boolean`):

Read the 30-day daily news-volume series for the company name from the free GDELT DOC API to compute buzz_ratio and buzz_flag. GDELT throttles hard (one request per 5-10 seconds per IP, with a cooldown after a burst), so this adds about 10 seconds per ticker and may be refused on shared IPs; when it is, the buzz fields are null and the ticker is still delivered and charged normally. Off by default.

## `includePrice` (type: `boolean`):

Add last price, 1-day / 5-day / 30-day change and the volume-versus-20-day-average ratio from the public Yahoo Finance chart endpoint. Context only, not a signal.

## `trackChanges` (type: `boolean`):

Remember the headlines seen per ticker in a named key-value store and report how many are new on the next run, plus the change in headline count. Free. Combine with a Schedule for monitoring.

## `stateStoreName` (type: `string`):

Name of the key-value store that holds the per-ticker headline snapshot used by change tracking (3-63 letters, digits or hyphens, not starting or ending with a hyphen). Use a different name per watchlist.

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

All sources are public and key-free, but Yahoo Finance and Stocktwits throttle shared datacenter IPs. Apify datacenter proxies are the default; switch to RESIDENTIAL if a run reports many HTTP 403/429 warnings for those sources.

## `requestDelayMs` (type: `integer`):

Minimum pause between two requests to the same host across the whole run. GDELT is always paced at 10,000 ms regardless of this value.

## `maxConcurrency` (type: `integer`):

How many tickers are processed at the same time. Each ticker makes 5 to 15 requests across five hosts.

## Actor input object example

```json
{
  "tickers": [
    "NVDA",
    "AAPL",
    "TSLA"
  ],
  "mode": "summary",
  "windowDays": 7,
  "requireMention": true,
  "maxHeadlinesPerTicker": 100,
  "stocktwitsPages": 3,
  "includeGdelt": false,
  "includePrice": true,
  "trackChanges": false,
  "stateStoreName": "stock-news-monitor-state",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestDelayMs": 500,
  "maxConcurrency": 4
}
```

# Actor output Schema

## `results` (type: `string`):

Ticker rows and/or headline rows, see the dataset schema views for the fields.

## `metrics` (type: `string`):

Requests, failures per source, tickers by outcome and charge counters for this 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 = {
    "tickers": [
        "NVDA",
        "AAPL",
        "TSLA"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("saekoto/stock-news-monitor").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 = {
    "tickers": [
        "NVDA",
        "AAPL",
        "TSLA",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("saekoto/stock-news-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "tickers": [
    "NVDA",
    "AAPL",
    "TSLA"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call saekoto/stock-news-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,saekoto/stock-news-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/mqeNGEEcLNrGM36Iu/builds/b9eEEuz8t8DTSIiwh/openapi.json