# Brand Mention Monitor: News, Reddit, HN & Telegram (`scrapemint/brand-mention-monitor`) Actor

Track any brand, product or name across Google News, Reddit, Hacker News and Telegram channels in one run. Scheduled runs remember what they saw and emit only NEW mentions: a pay-per-mention alert feed. Quiet days cost nothing. No API keys, no subscription.

- **URL**: https://apify.com/scrapemint/brand-mention-monitor.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Marketing, News
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Brand Mention Monitor: News, Reddit, HN & Telegram

Who is talking about your brand right now? This actor sweeps Google News, Reddit, Hacker News and any public Telegram channels you watch, in one run, and returns one row per mention. Run it on a schedule with the alert feed on and it remembers everything it has seen: each run emits **only new mentions**, so a quiet day pushes nothing and costs nothing. No login, no API keys, no subscription.

Mention monitoring tools charge $79 to $199 a month. A daily scheduled run here typically costs a few cents a day, and you only pay when there is actually something new.

### What you get

One row per new mention:

| Field | Description |
|---|---|
| `keyword` | Which of your keywords matched |
| `source` | `google-news`, `reddit`, `hackernews`, or `telegram` |
| `title` | Headline or post title (where the source has one) |
| `snippet` | Text excerpt for comments and messages |
| `url` | Direct link to the mention |
| `author` | Poster or commenter (where available) |
| `community` | Publisher, subreddit, story/comment, or channel |
| `publishedAt`, `foundAt` | When it was posted and when this run found it |

### Sources

- **Google News**: worldwide press coverage, any Google News language and country edition.
- **Reddit**: newest posts mentioning your phrase across all subreddits. Reddit occasionally rate-limits anonymous feeds; when that happens the source logs a warning and the other sources still deliver.
- **Hacker News**: stories and comments, via the Algolia search API. If your buyers are developers, this is where the sharpest opinions appear first.
- **Telegram channels**: public channels you choose to watch (competitors' channels, industry channels, niche news). Telegram has no public global search, so you supply the watchlist.

### Input

- **Keywords**: brand, product, founder name, competitor, ticker — each searched as an exact phrase.
- **Sources**: any combination of the four.
- **Telegram channels**: handles to watch when the Telegram source is on.
- **News language / country**: any Google News edition (e.g. `de` / `DE` for German coverage).
- **Only new mentions**: the alert-feed switch, on by default. Turn off for a one-time backfill.

### Pricing

Pay per result: **$0.005 per new mention**. First 2 rows of every run are free. With dedupe on you are never charged twice for the same mention, and runs that find nothing new cost nothing.

### Typical uses

- **Founders and SMBs**: know when your product gets covered, posted, or complained about, without a $99/month seat.
- **Agencies**: one scheduled run per client name, rows to a Google Sheet, done.
- **Devtool companies**: HN and Reddit mentions reach your Slack via a webhook minutes after they appear.
- **PR teams**: press pickup tracking across every Google News edition you care about.
- **Competitor watch**: put competitor names in the keyword list and their announcement channels in the Telegram watchlist.

### Scheduling

Schedule it hourly or daily with the alert feed on. Seen-mention memory lives in a named key-value store and survives between runs. Wire new rows to Slack, email, or Sheets with Apify integrations, or poll the dataset via API.

### Data notes

All sources are public pages and feeds; no accounts are used. Coverage begins when you start running the monitor (each source returns its most recent items, typically the last 25 to 100 per keyword).

# Actor input Schema

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

Brand names, product names, people or phrases to watch. Each is searched as an exact phrase.
## `sources` (type: `array`):

Where to look. Telegram needs a channel list below (it has no public global search).
## `telegramChannels` (type: `array`):

Public channel handles to watch for your keywords, e.g. durov or t.me/durov.
## `newsLanguage` (type: `string`):

Google News interface language, e.g. en-US, de, pt-BR.
## `newsCountry` (type: `string`):

Google News edition country code, e.g. US, GB, DE, BR, IN.
## `maxPerKeywordPerSource` (type: `integer`):

Scan depth per sweep (newest first).
## `maxRows` (type: `integer`):

Cap on mention rows returned. Controls total cost.
## `dedupe` (type: `boolean`):

Remember seen mentions across runs and emit only new ones. Keep on with a schedule; turn off for a one-time backfill sweep.

## Actor input object example

```json
{
  "keywords": [
    "OpenAI"
  ],
  "sources": [
    "google-news",
    "reddit",
    "hackernews"
  ],
  "telegramChannels": [],
  "newsLanguage": "en-US",
  "newsCountry": "US",
  "maxPerKeywordPerSource": 25,
  "maxRows": 200,
  "dedupe": true
}
````

# 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 = {
    "keywords": [
        "OpenAI"
    ],
    "sources": [
        "google-news",
        "reddit",
        "hackernews"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/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 = {
    "keywords": ["OpenAI"],
    "sources": [
        "google-news",
        "reddit",
        "hackernews",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/brand-mention-monitor").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 '{
  "keywords": [
    "OpenAI"
  ],
  "sources": [
    "google-news",
    "reddit",
    "hackernews"
  ]
}' |
apify call scrapemint/brand-mention-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Brand Mention Monitor: News, Reddit, HN & Telegram",
        "description": "Track any brand, product or name across Google News, Reddit, Hacker News and Telegram channels in one run. Scheduled runs remember what they saw and emit only NEW mentions: a pay-per-mention alert feed. Quiet days cost nothing. No API keys, no subscription.",
        "version": "0.1",
        "x-build-id": "8f2pPmjDfjaQmu7F1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~brand-mention-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-brand-mention-monitor",
                "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/scrapemint~brand-mention-monitor/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-brand-mention-monitor",
                "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/scrapemint~brand-mention-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-brand-mention-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Brand names, product names, people or phrases to watch. Each is searched as an exact phrase.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Where to look. Telegram needs a channel list below (it has no public global search).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "google-news",
                                "reddit",
                                "hackernews",
                                "telegram"
                            ],
                            "enumTitles": [
                                "Google News",
                                "Reddit",
                                "Hacker News",
                                "Telegram channels"
                            ]
                        },
                        "default": [
                            "google-news",
                            "reddit",
                            "hackernews"
                        ]
                    },
                    "telegramChannels": {
                        "title": "Telegram channels (for the telegram source)",
                        "type": "array",
                        "description": "Public channel handles to watch for your keywords, e.g. durov or t.me/durov.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "newsLanguage": {
                        "title": "News language",
                        "type": "string",
                        "description": "Google News interface language, e.g. en-US, de, pt-BR.",
                        "default": "en-US"
                    },
                    "newsCountry": {
                        "title": "News country",
                        "type": "string",
                        "description": "Google News edition country code, e.g. US, GB, DE, BR, IN.",
                        "default": "US"
                    },
                    "maxPerKeywordPerSource": {
                        "title": "Max mentions per keyword per source",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Scan depth per sweep (newest first).",
                        "default": 25
                    },
                    "maxRows": {
                        "title": "Max rows per run",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Cap on mention rows returned. Controls total cost.",
                        "default": 200
                    },
                    "dedupe": {
                        "title": "Only new mentions (alert feed)",
                        "type": "boolean",
                        "description": "Remember seen mentions across runs and emit only new ones. Keep on with a schedule; turn off for a one-time backfill sweep.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
