# News Mention Alert Engine (`datapilot/news-mention-alert-engine`) Actor

A powerful multi-source developer tools scraper that collects packages, repositories, and extensions from PyPI, npm, GitHub, and the VS Code Marketplace. It extracts versions, authors, downloads, licenses, ratings, and metadata to help discover and analyze developer resources efficiently.

- **URL**: https://apify.com/datapilot/news-mention-alert-engine.md
- **Developed by:** [Data Pilot](https://apify.com/datapilot) (community)
- **Categories:** Jobs, News, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 scraped results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## News Mention Alert Engine

📰 **News Mention Alert Engine** is a powerful Apify Actor designed to monitor, detect, and analyze **News Mention** data from Google News across brands, products, persons, and keywords. This tool provides real-time **News Mention** alerts with sentiment analysis, entity extraction, and comprehensive intelligence metrics. Whether you're monitoring brand reputation, tracking competitors, or conducting market intelligence, the News Mention Alert Engine delivers actionable **News Mention** insights efficiently.

With Google News RSS integration, multi-dimensional search (brands/products/persons/keywords), advanced NLP sentiment analysis, entity extraction, deduplication, and PPE billing support, the News Mention Alert Engine ensures comprehensive **News Mention** discovery and tracking. It focuses on key **News Mention** metrics including sentiment, relevance, entity mentions, and alert classification, making it an essential tool for **News Mention** research and reputation management.

---

### 📋 Table of Contents

- [Features](#-features)
- [How It Works](#-how-it-works)
- [Input](#-input)
- [Output](#-output)
- [Technical Stack](#-technical-stack)
- [Data Fields](#-data-fields)
- [Sentiment Analysis](#-sentiment-analysis)
- [Entity Extraction](#-entity-extraction)
- [Use Cases](#-use-cases)
- [Quick Start](#-quick-start)
- [Configuration](#-configuration)
- [Performance](#-performance)
- [Billing](#-billing)
- [Important Notes](#-important-notes)
- [Keywords](#-keywords)
- [Changelog](#-changelog)
- [Support](#-support)

---

### 🔥 Features

- **Multi-Dimensional Search** – Search **News Mention** across brands, products, persons, and keywords simultaneously.
- **Google News Integration** – Direct extraction of **News Mention** from Google News RSS feeds.
- **Brand Monitoring** – Track brand mentions in real-time news.
- **Product Monitoring** – Monitor product launches, reviews, and discussions.
- **Person Monitoring** – Track mentions of executives, influencers, or public figures.
- **Keyword Monitoring** – Monitor general keywords and industry terms.
- **Sentiment Analysis** – Advanced NLP sentiment classification (positive/negative/neutral).
- **Sentiment Scoring** – Quantitative sentiment score for each **News Mention**.
- **Relevance Scoring** – Ranks mentions by relevance to queries.
- **Entity Extraction** – Automatically extracts companies, people, and locations.
- **Alert Classification** – Categorizes mentions by type (brand, product, person, keyword).
- **Deduplication** – Removes duplicate **News Mention** across searches.
- **Duplicate Tracking** – Identifies new vs. previously seen mentions via KeyValueStore.
- **News Source Tracking** – Captures and ranks news sources.
- **Publication Date** – Records when **News Mention** was published.
- **News URL Capture** – Captures direct links to **News Mention** articles.
- **Summary Generation** – Generates comprehensive **News Mention** summaries.
- **Sentiment Distribution** – Calculates sentiment percentages.
- **Top Entities** – Identifies top mentioned companies and people.
- **Positive/Negative Highlights** – Extracts top positive and negative **News Mention**.
- **PPE Billing Integration** – Pay-per-event billing per **News Mention** detected.
- **Charge Limit Handling** – Respects user's maximum PPE charge limits.
- **Proxy Support** – Apify residential proxy support for reliability.
- **Real-Time Dataset Push** – Pushes results to Apify Dataset with metadata.
- **Detailed Logging** – Comprehensive logging of charges and progress.
- **Asyncio-Friendly** – Non-blocking async/await architecture.

---

### ⚙️ How It Works

The News Mention Alert Engine accepts lists of brands, products, persons, and keywords to monitor. It queries Google News RSS for each search term, fetches articles, performs sentiment analysis, extracts entities, and classifies alert types. Mentions are deduplicated using persistent KeyValueStore to track previously seen articles. New mentions are identified and highlighted. All mentions are analyzed and charged via PPE billing. A comprehensive summary is generated with sentiment distribution, top entities, and highlights.

**Key Processing Steps:**

1. **Input Parsing** – Accept brands, products, persons, keywords
2. **Proxy Setup** – Configure Apify residential proxy
3. **Query Generation** – Build search queries from inputs
4. **KeyValueStore Load** – Load previously seen mention IDs
5. **News Fetching** – Query Google News RSS for each search term
6. **Article Parsing** – Extract title, description, source, date, URL
7. **Sentiment Analysis** – Analyze sentiment for each **News Mention**
8. **Entity Extraction** – Extract companies, people, locations
9. **Alert Classification** – Categorize mention types
10. **Deduplication** – Check against seen mentions
11. **New Detection** – Identify new vs. previously seen
12. **Relevance Scoring** – Score mention relevance
13. **Summary Generation** – Build comprehensive summary
14. **Dataset Push** – Push summary and mentions
15. **PPE Charging** – Charge per mention
16. **KeyValueStore Update** – Update seen mention IDs

**Key Benefits:**

- Monitor **News Mention** across multiple dimensions simultaneously
- Detect reputation threats early
- Track competitor activity in real-time
- Understand public perception via sentiment
- Identify key influencers and industry leaders
- Make informed business decisions
- Automate brand monitoring

---

### 📥 Input

The Actor accepts the following input parameters:

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `brands` | array/string | [] | Brands to monitor (comma-separated or array) |
| `products` | array/string | [] | Products to monitor (comma-separated or array) |
| `persons` | array/string | [] | Persons to monitor (comma-separated or array) |
| `keywords` | array/string | [] | Keywords to monitor (comma-separated or array) |
| `maxPerQuery` | integer | `30` | Maximum **News Mention** per search query (1-100) |
| `useApifyProxy` | boolean | `true` | Enable Apify residential proxies |
| `apifyProxyGroups` | array | `["RESIDENTIAL"]` | Proxy group configuration |

**Example Input:**

```json
{
  "brands": ["Apple", "Samsung", "Google"],
  "products": ["iPhone", "Galaxy", "Pixel"],
  "persons": ["Tim Cook", "Satya Nadella"],
  "keywords": ["AI", "machine learning"],
  "maxPerQuery": 30,
  "useApifyProxy": true
}
````

**Brand Monitoring Example:**

```json
{
  "brands": "Tesla, Ford, GM",
  "maxPerQuery": 50
}
```

**Executive Tracking Example:**

```json
{
  "persons": ["Elon Musk", "Bill Gates", "Jeff Bezos"],
  "maxPerQuery": 25
}
```

***

### 📤 Output

The Actor pushes **News Mention** records with the following structure:

**Individual Mention Record:**

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | Search query that found this mention |
| `mention_type` | string | Type of mention (brand/product/person/keyword) |
| `alert_types` | array | Classification tags (e.g., \["brand:Apple", "keyword:AI"]) |
| `title` | string | **News Mention** headline |
| `description` | string | Article summary (400 chars max) |
| `source` | string | News source publication |
| `url` | string | Direct link to article |
| `published` | string | Publication date/time |
| `sentiment` | string | Sentiment (positive/negative/neutral) |
| `sentiment_score` | integer | Quantitative sentiment score |
| `relevance` | integer | Relevance score (1-3) |
| `entities` | object | Extracted companies, people, locations |
| `is_new` | boolean | Whether this is a new mention |
| `id` | string | Unique mention identifier |
| `scraped_at` | string | ISO 8601 scrape timestamp |

**Summary Record:**

Comprehensive analysis including:

- Total and new mention counts
- Sentiment distribution and percentages
- Top news sources
- Alert type breakdown
- Top mentioned companies and people
- Top positive and negative news highlights

**Example Individual Mention:**

```json
{
  "query": "Apple",
  "mention_type": "brand",
  "alert_types": ["brand:Apple", "product:iPhone"],
  "title": "Apple Announces Revolutionary New iPhone Features",
  "description": "Apple introduced groundbreaking features in the latest iPhone release, marking a significant innovation...",
  "source": "Tech News Daily",
  "url": "https://technewsdaily.com/article/...",
  "published": "2025-02-14T08:30:00",
  "sentiment": "positive",
  "sentiment_score": 4,
  "relevance": 3,
  "entities": {
    "companies": ["Apple Inc.", "Samsung Electronics"],
    "people": ["Tim Cook", "Craig Federighi"],
    "locations": ["San Francisco", "Cupertino"]
  },
  "is_new": true,
  "id": "guid-12345...",
  "scraped_at": "2025-02-14T12:00:00"
}
```

**Example Summary:**

```json
{
  "type": "SUMMARY",
  "config": {
    "brands": ["Apple", "Samsung"],
    "products": ["iPhone", "Galaxy"],
    "persons": ["Tim Cook"],
    "keywords": ["AI"]
  },
  "summary": {
    "generated_at": "2025-02-14T12:00:00",
    "total_mentions": 127,
    "new_mentions": 34,
    "sentiment": {
      "positive": 78,
      "negative": 31,
      "neutral": 18,
      "positive_pct": 61.4,
      "negative_pct": 24.4
    },
    "top_sources": [
      {"source": "Tech News Daily", "count": 28},
      {"source": "Business Journal", "count": 19}
    ],
    "alert_type_breakdown": {
      "brand:Apple": 45,
      "product:iPhone": 32,
      "keyword:AI": 28,
      "person:Tim Cook": 15
    },
    "top_companies_mentioned": ["Apple", "Samsung", "Google"],
    "top_people_mentioned": ["Tim Cook", "Craig Federighi"],
    "top_positive_news": [
      {
        "title": "Apple Achieves Record Profits",
        "source": "Financial Times",
        "url": "https://..."
      }
    ],
    "top_negative_news": [
      {
        "title": "Apple Faces New Privacy Lawsuit",
        "source": "Legal News",
        "url": "https://..."
      }
    ]
  }
}
```

***

### 🧰 Technical Stack

- **News Source:** Google News RSS feeds
- **NLP/Sentiment:** Custom word-based sentiment analysis
- **Entity Extraction:** Regex pattern matching
- **Persistence:** Apify KeyValueStore for deduplication
- **Async:** asyncio for non-blocking operations
- **Data Structure:** Collections (Counter) for aggregation
- **Proxy:** Apify Proxy with RESIDENTIAL configuration
- **Logging:** Apify Actor logging system
- **Platform:** Apify Actor serverless environment
- **Billing:** Apify PPE (Pay-Per-Event) system

***

### 📊 Sentiment Analysis

#### **Methodology**

The Actor uses word-based sentiment analysis:

**Positive Words:** growth, profit, success, award, launch, partnership, expansion, innovation, excellent, leading, etc.

**Negative Words:** loss, decline, crash, scandal, lawsuit, fine, bankruptcy, layoff, investigation, fraud, failure, crisis, etc.

**Scoring:**

- Count matches in positive and negative word sets
- If positive > negative: sentiment = "positive", score = difference
- If negative > positive: sentiment = "negative", score = difference
- Otherwise: sentiment = "neutral", score = 0

#### **Examples**

Positive mention:

```
Title: "Apple Announces Record Profits and Expansion Plans"
Positive words: 2 (record, expansion, profits)
Negative words: 0
Sentiment: Positive, Score: 2
```

Negative mention:

```
Title: "Apple Faces Lawsuit Over Data Breach"
Positive words: 0
Negative words: 2 (lawsuit, breach)
Sentiment: Negative, Score: 2
```

***

### 🔍 Entity Extraction

#### **Extracted Entities**

**Companies:** Matches patterns like "Name Corp", "Name Inc", "Name Ltd"

**People:** Matches patterns like "John Smith" or "CEO Jane Doe"

**Locations:** Matches known major cities (New York, London, Silicon Valley, Beijing, etc.)

#### **Deduplication**

Uses KeyValueStore to maintain set of seen mention IDs, enabling:

- Detection of new mentions on subsequent runs
- Avoidance of duplicate processing
- Persistent tracking across Actor invocations

***

### 🎯 Use Cases

- **Brand Reputation Monitoring** – Monitor **News Mention** of your brand in real-time
- **Competitor Intelligence** – Track competitor **News Mention** and activities
- **Executive Tracking** – Monitor mentions of company executives and industry leaders
- **Product Launch Tracking** – Monitor **News Mention** around product launches
- **Crisis Detection** – Identify reputation threats early via sentiment analysis
- **Market Research** – Research industry trends via **News Mention** analysis
- **PR Effectiveness** – Measure PR campaign impact via **News Mention** volume
- **Sentiment Analysis** – Understand public perception via sentiment metrics
- **Entity Discovery** – Identify key companies and people mentioned with your brand
- **News Aggregation** – Aggregate relevant **News Mention** for team review
- **Alert System** – Create automated alerts for important **News Mention**
- **Competitive Positioning** – Understand competitive **News Mention** landscape
- **Investor Relations** – Track investor-relevant **News Mention**
- **Marketing Intelligence** – Inform marketing strategy with **News Mention** data
- **Business Development** – Identify partnership opportunities via **News Mention**

***

### 🚀 Quick Start

#### **1. Prepare Input**

Go to Apify Console and enter:

```json
{
  "brands": ["Apple", "Samsung"],
  "products": ["iPhone", "Galaxy"],
  "persons": "Tim Cook",
  "keywords": ["AI", "machine learning"],
  "maxPerQuery": 30,
  "useApifyProxy": true
}
```

#### **2. Run the Actor**

Click **Start** button. The Actor will:

- Search Google News for all queries
- Analyze sentiment for each **News Mention**
- Extract entities
- Deduplicate against historical mentions
- Generate summary
- Push to Dataset

#### **3. Monitor Progress**

Console shows:

```
Brands=["Apple", "Samsung"] | Products=["iPhone"] | Persons=["Tim Cook"] | Keywords=["AI"]
Proxy active: RESIDENTIAL
[BRAND] 'Apple'
  -> 28 articles found
[BRAND] 'Samsung'
  -> 24 articles found
[PRODUCT] 'iPhone'
  -> 18 articles found
[PERSON] 'Tim Cook'
  -> 12 articles found
[KEYWORD] 'AI'
  -> 45 articles found
✅ [CHARGED] Mention saved | Query: Apple | Sentiment: positive | Total: 1
✅ [CHARGED] Mention saved | Query: Samsung | Sentiment: neutral | Total: 2
...
🎉 Done! Total=127 | New=34 | Total charged=127 | Positive=78 | Negative=31
```

#### **4. View & Download Results**

- **Results Tab**: All **News Mention** records + summary
- **Export**: JSON, CSV, Excel
- **Filter**: By sentiment or mention type
- **Sort**: By date or relevance

***

### ⚙️ Configuration

#### **Search Scope**

Brand focus:

```json
{
  "brands": ["Apple", "Microsoft", "Google"]
}
```

Multi-dimensional:

```json
{
  "brands": ["Tesla"],
  "products": ["Model 3", "Cybertruck"],
  "persons": ["Elon Musk"],
  "keywords": ["electric vehicles"]
}
```

#### **Result Limits**

Quick scan (10 per query):

```json
{
  "maxPerQuery": 10
}
```

Comprehensive (50+ per query):

```json
{
  "maxPerQuery": 50
}
```

***

### 📈 Performance

#### **Processing Speed**

- \~2-3 seconds per query
- \~30-60 seconds total for 10-20 queries
- Summary generation adds ~5-10 seconds

#### **Resource Usage**

- Memory: ~80-150MB
- CPU: ~30-40% during processing
- Network: ~2-4MB per run
- API calls: 1 per search query

***

### 💰 Billing

#### **PPE (Pay-Per-Event) Billing**

- **Event Name:** "scraped-result"
- **Charge:** 1 credit per **News Mention** detected
- **Billing Trigger:** Per mention article processed
- **Typical Cost:** 30-150 credits per run

#### **Cost Examples**

- 5 brands × 30 articles = 150 credits
- 3 brands + 2 products + 2 people + 3 keywords, 20 articles each = 200 credits

***

### ⚠️ Important Notes

#### **Legal & Compliance**

- **Fair Use**: Respects Google News ToS and rate limits
- **Attribution**: Respects news source and author attribution
- **Sentiment**: Algorithmic analysis, not definitive
- **Proxy**: Recommended for reliability
- **Rate Limiting**: Includes appropriate delays

#### **Data Quality**

- **Freshness**: Real-time news data
- **Completeness**: Varies by search term popularity
- **Accuracy**: Sentiment is statistical analysis
- **Entity**: Pattern-based extraction, may have false positives
- **Verification**: Always verify with original sources

#### **Best Practices**

- Use residential proxies
- Monitor sentiment carefully (may be inaccurate)
- Verify important mentions independently
- Set reasonable query limits
- Check results regularly for news monitoring
- Combine with manual review
- Respect news source copyrights
- Follow news outlet guidelines

### 📦 Changelog

**Initial Release:**

- Google News RSS integration
- Multi-dimensional search (brands/products/persons/keywords)
- News article fetching and parsing
- Title and description extraction
- Source and publication date capture
- URL extraction
- Sentiment analysis (positive/negative/neutral)
- Sentiment scoring algorithm
- Entity extraction (companies, people, locations)
- Alert classification by mention type
- Relevance scoring (3 for exact match, 1 for query match)
- Deduplication using KeyValueStore
- New mention detection (vs previously seen)
- Summary generation
- Sentiment distribution calculation
- Top entity extraction
- Top positive/negative news identification
- PPE billing per mention
- Charge limit detection and stopping
- Configurable result limits per query
- Apify proxy support
- Real-time Dataset push
- Detailed progress logging
- Comprehensive error handling
- Asyncio executor support

***

### 🧑‍💻 Support & Feedback

- **Issues:** Submit via Apify console with search terms
- **Documentation:** Check Actor details page
- **Community:** Apify forum discussions
- **Feature Requests:** Suggest improvements or news sources
- **Bug Reports:** Include brands/keywords and error details

### 📄 License & Legal

**Terms of Use:**

- Use for legitimate business and research
- Respect Google News ToS and rate limits
- Respect news source copyrights and attribution
- Don't republish articles without permission
- Comply with applicable laws
- Use data ethically and responsibly

**Disclaimer:**
News Mention Alert Engine is provided as-is for monitoring purposes. Users are responsible for ensuring compliance with Google News ToS and applicable laws. Always verify information with original news sources.

***

### 🎉 Get Started Today

**Deploy now for **News Mention** monitoring!**

Use for:

- 📊 Brand Monitoring
- 🔍 Reputation Management
- 💡 Competitor Intelligence
- 📈 Sentiment Analysis
- 🎯 Crisis Detection

**Perfect for:**

- Brand Managers
- PR Professionals
- Marketing Teams
- Business Development
- Analysts

**Last Updated:** February 2025\
**Version:** 1.0.0\
**Status:** Production Ready\
**Platform:** Apify Actor\
**News Source:** Google News RSS\
**Deduplication:** KeyValueStore-based

***

### 📚 Related Tools

- App Review Intelligence Monitor
- Export Intelligence Monitor
- Business Social Media Finder
- Developer Tools Scraper

### 📰 News Mention Excellence

This Actor is optimized for **News Mention** monitoring with:

- ✅ Multi-dimensional search
- ✅ Google News integration
- ✅ Advanced sentiment analysis
- ✅ Entity extraction
- ✅ Deduplication tracking
- ✅ Summary generation
- ✅ PPE billing support
- ✅ Real-time Dataset push
- ✅ Error recovery
- ✅ Production-ready code

**Monitor news mentions effortlessly!** 💎🚀

# Actor input Schema

## `brands` (type: `array`):

e.g: Apple, Tesla, OpenAI

## `products` (type: `array`):

e.g: iPhone, ChatGPT, Model Y

## `persons` (type: `array`):

e.g: Elon Musk, Sam Altman, Tim Cook

## `keywords` (type: `array`):

e.g: AI regulation, electric vehicle, crypto

## `maxPerQuery` (type: `integer`):

How many articles to fetch per brand/product/person/keyword.

## `useApifyProxy` (type: `boolean`):

Recommended for Google News scraping.

## `apifyProxyGroups` (type: `array`):

RESIDENTIAL works best for Google News.

## Actor input object example

```json
{
  "brands": [],
  "products": [],
  "persons": [],
  "keywords": [],
  "maxPerQuery": 30,
  "useApifyProxy": true,
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ]
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("datapilot/news-mention-alert-engine").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("datapilot/news-mention-alert-engine").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 '{}' |
apify call datapilot/news-mention-alert-engine --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datapilot/news-mention-alert-engine",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "News Mention Alert Engine",
        "description": "A powerful multi-source developer tools scraper that collects packages, repositories, and extensions from PyPI, npm, GitHub, and the VS Code Marketplace. It extracts versions, authors, downloads, licenses, ratings, and metadata to help discover and analyze developer resources efficiently.",
        "version": "0.0",
        "x-build-id": "h83L768fKZxjMsPzr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datapilot~news-mention-alert-engine/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datapilot-news-mention-alert-engine",
                "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/datapilot~news-mention-alert-engine/runs": {
            "post": {
                "operationId": "runs-sync-datapilot-news-mention-alert-engine",
                "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/datapilot~news-mention-alert-engine/run-sync": {
            "post": {
                "operationId": "run-sync-datapilot-news-mention-alert-engine",
                "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": {
                    "brands": {
                        "title": "Brands / Companies to monitor",
                        "type": "array",
                        "description": "e.g: Apple, Tesla, OpenAI",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "products": {
                        "title": "Products to monitor",
                        "type": "array",
                        "description": "e.g: iPhone, ChatGPT, Model Y",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "persons": {
                        "title": "Persons / CEOs to monitor",
                        "type": "array",
                        "description": "e.g: Elon Musk, Sam Altman, Tim Cook",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords / Topics to monitor",
                        "type": "array",
                        "description": "e.g: AI regulation, electric vehicle, crypto",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPerQuery": {
                        "title": "Max news articles per query",
                        "minimum": 5,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many articles to fetch per brand/product/person/keyword.",
                        "default": 30
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Recommended for Google News scraping.",
                        "default": true
                    },
                    "apifyProxyGroups": {
                        "title": "Proxy Groups",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "RESIDENTIAL works best for Google News.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RESIDENTIAL",
                                "DATACENTER",
                                "GOOGLE"
                            ]
                        },
                        "default": [
                            "RESIDENTIAL"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
