# News & Brand Mention Monitor (RSS & Atom Feeds) (`maniginam/news-brand-mention-monitor`) Actor

Find every news mention of your brand, competitors, or keywords in the publisher RSS and Atom feeds you choose.  Deduplicated by link and title.  Monitor mode delivers only mentions you have not seen before, for PR, SEO, and market alerts.

- **URL**: https://apify.com/maniginam/news-brand-mention-monitor.md
- **Developed by:** [ManiGinaM](https://apify.com/maniginam) (community)
- **Categories:** News, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 mention records

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/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

Every news mention of your brand, your competitors, or any keyword, from the publisher RSS and Atom feeds you choose, in one clean and deduplicated dataset with headline, publisher, link, publish time, summary, and the queries each story matched.  Turn on monitor mode and schedule it to get only the stories you have not seen before, for PR alerts, SEO link building, competitor tracking, and market research.

### Monitor mode

Monitor mode is the way most people use this Actor.  Set `onlyNewMentions` to true and add a schedule, for example every morning at 7 AM or every hour.  The Actor remembers every mention it delivered for your queries in a named key-value store.  The first run delivers every mention it finds, up to `maxResults`, as `new`.  Later runs deliver only stories that were not delivered before.  Mentions already seen are skipped, and you are not charged for them.

Sample monitor input:

```json
{
  "onlyNewMentions": true,
  "queries": ["Apify", "\"web scraping\" OR Crawlee"],
  "feeds": ["https://techcrunch.com/feed/", "https://www.theverge.com/rss/index.xml"],
  "maxAgeDays": 3,
  "excludeKeywords": ["jobs"],
  "maxResults": 500
}
```

A few things are worth knowing before you rely on it:

- A story counts as seen when its link was delivered before, with tracking parameters such as `utm_source` removed, or when the same headline from the same publisher domain, published on the same day in UTC, was delivered before.  A headline the publisher reuses on another day, like a weekly roundup, is a new story.  So the same story in two of your feeds, or republished with a new tracking link, is delivered once.
- The same headline at two different publishers counts as two mentions, because each is a separate piece of coverage.
- History is keyed on `queries`, but not on `feeds`, `maxAgeDays`, `excludeKeywords`, or `maxResults`.  Changing the queries starts a fresh history and reports everything as `new` again.  Adding a feed keeps the history, so stories already delivered from another feed are not repeated from the new one.
- `maxResults` caps what a run delivers.  Mentions past the cap are not remembered, so they are delivered on the next run.
- The history remembers the most recent 100,000 mention keys (two per mention), so about 50,000 mentions.
- If the saved history is ever unreadable, the run fails before charging anything rather than reporting every mention as `new` again.  The error names the record to delete from the `news-brand-mention-monitor-history` store.
- Two schedules running the same queries at the same time share one history, and the run that finishes last wins.

Every run also saves a summary to the `MENTION_SUMMARY` record of the run's key-value store, free of charge.  It has one entry per feed with the number of entries read, how many matched, how many were duplicates, how many records were delivered, and any error.  The run's Output tab links to it.

### What does it do?

For each feed link you add, the Actor reads the publisher's RSS 2.0, RSS 1.0, or Atom feed directly and keeps the entries whose title or summary mentions one of your queries and that were published in the last `maxAgeDays` days.  It turns every story into the same record shape, drops duplicates, and delivers the rest.  There is no browser, no proxy, no login, and no social network involved.

Queries are written the way you would type them into a news search box:

- a brand or word, such as `Apify`,
- a phrase in quotes, such as `"web scraping"`,
- alternatives joined by `OR`, such as `Crawlee OR Scrapy`,
- and words to leave out with a minus, such as `Apify -jobs`.

Each query must appear as whole words in the title or summary, so `Apify` does not match `Apifyer`.  Search engine operators such as `site:` are ignored.  A feed only holds a publisher's latest stories, often the last 10 to 50, so pick feeds that cover your market and schedule the monitor often enough to catch each story while it is in the feed.

### Who is it for?

- PR and communications teams who want a morning list of new press coverage.
- SEO teams who look for unlinked brand mentions and link building chances.
- Marketing and sales teams who track competitors, product launches, and funding news.
- Founders and analysts who follow a market, a technology, or a list of companies.

### How to use

1. Open the Actor in Apify Console and enter your brand names or search queries.
2. Add the publisher RSS or Atom feeds to watch.  The form starts with TechCrunch, The Verge, Ars Technica, and Engadget.
3. Adjust the age and excluded keywords under **Filters** if you need to.
4. Click **Start** and wait for the run to finish.
5. Open the **Output** tab to preview mentions, then export them as JSON, CSV, Excel, or XML.
6. For alerts, turn on monitor mode and add a schedule.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `onlyNewMentions` | true or false | Monitor mode.  Outputs only mentions not delivered before for the same queries. |
| `queries` | list | Search queries, one per line.  Up to 100 queries of up to 200 characters each.  The same query listed twice is matched once. |
| `feeds` | list | Publisher RSS or Atom feed links, at least 1 and up to 200.  A link without `https://` is read over https. |
| `maxAgeDays` | number | Keep only mentions published within this many days.  Entries without a publish date are always kept.  Default 7, maximum 365. |
| `excludeKeywords` | list | Drop mentions whose title or summary contains any of these words or phrases. |
| `maxResults` | number | Most mention records to deliver in one run.  Default 1000, maximum 100,000.  The input form starts at 20 so a first run is quick. |

Feeds are read in the order you list them, so a story found in two feeds keeps the first feed's link and summary.  If one feed is down, the run carries on with the rest and notes the error in the summary.  The run fails only when no source could be read.

Sample input:

```json
{
  "queries": ["OpenAI", "Anthropic", "\"Mistral AI\""],
  "feeds": ["https://techcrunch.com/feed/", "https://www.theverge.com/rss/index.xml"],
  "maxAgeDays": 1,
  "maxResults": 300
}
```

### Output

Each mention is one dataset item.  This is a real record:

```json
{
  "mentionId": "76b2faac219eab20",
  "status": "new",
  "matchedQueries": [
    "OpenAI"
  ],
  "title": "OpenAI reportedly lowers funding target for new round",
  "publisher": "TechCrunch",
  "publisherDomain": "techcrunch.com",
  "url": "https://techcrunch.com/2026/10/31/openai-reportedly-lowers-funding-target-for-new-round/",
  "publishedAt": "2026-10-31T16:12:55Z",
  "summary": "OpenAI’s latest funding round doesn't seem to be living up to expectations.",
  "source": "publisherFeed",
  "feedUrl": "https://techcrunch.com/feed/",
  "detectedAt": "2026-11-01T19:03:07Z"
}
```

You can download results as JSON, CSV, Excel, or XML, or read them through the Apify API.

- `mentionId` is stable across runs for the same cleaned link.
- `status` is `new` in monitor mode and `notTracked` otherwise.
- `matchedQueries` lists every query the story answers, not only the one that found it.
- `url` is the publisher's own link, and `publisher` and `publisherDomain` name the publisher.
- `summary` is the feed's own summary as plain text, up to 500 characters.
- `source` is always `publisherFeed`, and `feedUrl` is the feed the story came from.
- A `title`, `publisher`, or `summary` that starts with `=`, `+`, `-`, or `@` gets a leading apostrophe, so a spreadsheet opening the CSV export shows it as text instead of running it as a formula.

### Pricing

This Actor uses pay-per-event pricing.

- **Mention record:** $5.00 per 1,000 mentions delivered to your dataset ($0.005 each).
- **Actor start:** Apify's standard start event ($0.00005).
- The summary is free, and there is no separate charge per dataset item.

A publisher feed holds its latest 10 to 50 stories, so a first run over 10 feeds reads at most about 500 entries.  Only entries that match a query are delivered, so even that worst case is under $2.50, and a run is usually a few cents.  A daily monitor then delivers only the new stories, often a handful per query per day, so a few cents a day.  Exclude keywords and a short `maxAgeDays` cut the cost further.  You can cap any run with Apify's maximum charge setting.  The Actor stops cleanly at your limit, and you are only charged for mentions that actually reach your dataset.

#### Estimated compute cost

Default memory is 512 MB, and the Actor uses under 100 MB of it.  Each feed is one small request, paced per host, so even 200 feeds finish in a few minutes.  The mention records are almost all of the cost.  If a run times out, resurrect it and it continues after the last source it finished, without charging a mention twice.

### Data sources and freshness

- Any publisher RSS 2.0, RSS 1.0, or Atom feed whose link you give, read directly from the publisher's site.
- Nothing else.  The Actor does not query any news search engine or aggregator.

Every mention is read live at run time, so the data is as fresh as the sources.  Requests are paced and retried with backoff when a site is busy.  Feed links that point at private network addresses, directly or through a redirect, are refused.  If the platform moves a run to another server, it resumes after the last source it finished and never delivers or charges a mention twice.

### Is it legal to use this data?

The Actor reads public RSS and Atom feeds without logging in, and it delivers headlines, links, publisher names, dates, and the short summaries publishers put in their own feeds, not full articles.  Each publisher's feed terms apply to its content, so check them before you republish anything.  The data is provided as is, without any guarantee that it is complete, current, or accurate.  This Actor is an independent tool and is not affiliated with or endorsed by any publisher whose feed it reads.  You are responsible for how you use the results and for following each site's terms that apply to you.

### API and integrations

You can start this Actor and read its results with the [Apify API](https://docs.apify.com/api/v2), the Apify Python and JavaScript clients, or the Apify CLI.  The API returns each run's dataset in the same formats as the Console.

Apify integrations can pass results on when a run finishes, for example to Google Sheets, Slack, Zapier, Make, or your own webhook.  Set them up on the Actor's **Integrations** tab, and pair them with a schedule for a hands-off feed.

### FAQ

**Do I need an account or API key?**  No.  Publisher feeds are public and need no login.

**How do I find a publisher's feed?**  Many sites link it as RSS in the footer, and most WordPress sites have one at `/feed/`.  Paste the feed link, not the home page.  A home page is reported in the summary as not being a feed.

**Why did I get no mentions?**  A feed only holds a publisher's latest stories, so a niche brand may not appear in a given week.  Add feeds that cover your market, such as trade press, your competitors' blogs, or a local paper, and check the summary for feeds that failed.

**Why did a story come back after I changed my queries?**  History is kept per set of queries, so new queries start a new history.

**Can it read Reddit, X, or LinkedIn?**  No.  This Actor covers news only: publisher feeds.

### Related Actors

- [Website Contact Enrichment (Emails, Phones)](https://apify.com/maniginam/website-contact-enrichment): emails, phone numbers, and social links from company websites.
- [Greenhouse, Lever & Workday Jobs Tracker](https://apify.com/maniginam/career-site-jobs-hiring-tracker): open jobs from Greenhouse, Lever, Ashby, and Workday career sites.
- [AI Brand Visibility: ChatGPT, Perplexity, Gemini](https://apify.com/maniginam/ai-brand-visibility-tracker): how ChatGPT, Perplexity, Gemini, and Claude mention your brand.

### Feedback and custom requests

Found a bug, a wrong value, or a source that changed?  Open an issue in the Issues tab on this Actor's page.  Need another field, filter, or source, or a version built for your team?  Describe it in the Issues tab as a custom request.

# Changelog

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

# Actor input Schema

## `onlyNewMentions` (type: `boolean`):

When on, the Actor remembers every mention it delivered for these queries, and outputs only mentions it has not delivered before.  A story counts as seen when its link (with tracking parameters removed) or its title at the same publisher was delivered before.  Mentions already seen are skipped and not charged.  The first run delivers every mention as new.  Use it with a daily or hourly schedule for alerts.

## `queries` (type: `array`):

One query per line: a brand such as OpenAI, a phrase in quotes such as "web scraping", alternatives joined by OR, and words to leave out with a minus such as -jobs.  A feed entry is kept when its title or summary mentions one of the queries.

## `feeds` (type: `array`):

Publisher feed links to read, such as https://techcrunch.com/feed/ or https://www.theverge.com/rss/index.xml.  Add at least one.  Most news sites and blogs publish one, often at /feed or /rss.  Only entries that mention one of the queries are kept.

## `maxAgeDays` (type: `integer`):

Only mentions published in this many days are kept.  Mentions without a date are kept.

## `excludeKeywords` (type: `array`):

Drop mentions whose title or summary contains any of these words or phrases, for example jobs or press release.

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

The run stops once this many mention records are delivered.  Mentions left over are not remembered, so a monitor delivers them next time.  The form starts at 20 so a first run is quick.

## Actor input object example

```json
{
  "onlyNewMentions": false,
  "queries": [
    "OpenAI",
    "Apple OR Microsoft OR Nvidia"
  ],
  "feeds": [
    "https://techcrunch.com/feed/",
    "https://www.theverge.com/rss/index.xml",
    "https://feeds.arstechnica.com/arstechnica/index",
    "https://www.engadget.com/rss.xml"
  ],
  "maxAgeDays": 7,
  "maxResults": 20
}
```

# Actor output Schema

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

No description

## `mentionSummary` (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 = {
    "queries": [
        "OpenAI",
        "Apple OR Microsoft OR Nvidia"
    ],
    "feeds": [
        "https://techcrunch.com/feed/",
        "https://www.theverge.com/rss/index.xml",
        "https://feeds.arstechnica.com/arstechnica/index",
        "https://www.engadget.com/rss.xml"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("maniginam/news-brand-mention-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 = {
    "queries": [
        "OpenAI",
        "Apple OR Microsoft OR Nvidia",
    ],
    "feeds": [
        "https://techcrunch.com/feed/",
        "https://www.theverge.com/rss/index.xml",
        "https://feeds.arstechnica.com/arstechnica/index",
        "https://www.engadget.com/rss.xml",
    ],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("maniginam/news-brand-mention-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 '{
  "queries": [
    "OpenAI",
    "Apple OR Microsoft OR Nvidia"
  ],
  "feeds": [
    "https://techcrunch.com/feed/",
    "https://www.theverge.com/rss/index.xml",
    "https://feeds.arstechnica.com/arstechnica/index",
    "https://www.engadget.com/rss.xml"
  ],
  "maxResults": 20
}' |
apify call maniginam/news-brand-mention-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maniginam/news-brand-mention-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/3gzT6hZrlqfHhcTfo/builds/9RKs9JloIqQEc41hZ/openapi.json