# Media Mention Monitor for Brand Coverage (`khadinakbar/meltwater-alternative`) Actor

Monitor a brand or competitor watchlist in Google News RSS and trusted public feeds. Returns deduplicated mentions with query, publisher, source URL, dates, and collection-time provenance. Use for bounded press-coverage review, not social listening or PR outreach. $0.01/mention plus $0.00005 start.

- **URL**: https://apify.com/khadinakbar/meltwater-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** News, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 media mention collecteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Media Mention Monitor | Meltwater Alternative

Collect a current, source-linked snapshot of public news coverage for a brand, competitor, or topic. The Actor searches Google News RSS for up to ten watch queries, optionally combines trusted public RSS, Atom, or JSON feeds, removes duplicates, and returns one structured record per retained mention.

This is a focused **media-mention monitoring workflow alternative** for public-news and selected-feed collection. Meltwater serves teams that need social listening, broadcast or podcast monitoring, licensed media databases, sentiment analysis, influencer workflows, media relations, and team dashboards.

### Best fit

Use this Actor when a founder, analyst, or communications team needs a repeatable, API-friendly press-coverage snapshot for a specified watchlist. It is especially useful when the next step is a spreadsheet, alert, report, or internal review that needs article URLs, publishers, dates, source provenance, and the queries that produced each item.

Choose Meltwater or another full media-intelligence suite when you need global licensed coverage, social and broadcast monitoring, sentiment analysis, journalist outreach, collaborative dashboards, historical workspace reporting, or managed enterprise onboarding.

### What you get

Each dataset row represents one public article mention with source-linked collection details.

| Field | Meaning |
| --- | --- |
| `title`, `url`, `snippet`, `publishedAt` | Feed-supplied coverage details |
| `matchedQueries` | Configured Google News searches that yielded the article |
| `publisherName`, `publisherUrl` | Publisher metadata when the feed supplies it |
| `sourceName`, `sourceTags`, `feedUrl`, `sourceUrl`, `feedType` | Source and collection provenance |
| `collectedAt` | Timestamp for this collection run |

Source-supplied publisher and publication-date fields remain null when unavailable, preserving an honest view of available metadata.

### Input

```json
{
  "watchQueries": ["OpenAI", "Anthropic"],
  "trustedSources": [
    {"url": "https://hnrss.org/frontpage", "name": "Hacker News", "tags": ["technology"]}
  ],
  "language": "en-US",
  "country": "US",
  "lookbackDays": 7,
  "maxItems": 100,
  "excludeKeywords": ["sponsored"]
}
```

`maxItems` is a whole-run cap. It bounds the persisted rows and therefore the main event charge. Watch queries feed Google News RSS; trusted sources broaden the collection only with public feeds you choose.

### Pricing and cost boundary

The intended live configuration is Pay per event + platform usage: $0.00005 for Actor start and $0.01 for each persisted media mention. A 100-mention run has a maximum mention-event cost of $1.00, plus the start event and Apify platform usage. Check the live Pricing tab before relying on a price in production.

Event charges apply to persisted mentions. Rejected duplicates, excluded records, and empty results add no mention event. Equal-workload comparison remains the appropriate basis for any future cost comparison with Meltwater.

### Outcome contract

Every terminal path writes both `OUTPUT` and `RUN_SUMMARY`.

```text
COMPLETE        all readable sources completed and retained mentions were written
PARTIAL         useful mentions were written with one or more source or write warnings
VALID_EMPTY     readable sources produced zero mentions for the configured window and exclusions
INVALID_INPUT   update the watchlist, source URLs, or numeric bounds
UPSTREAM_FAILED requested sources yielded zero usable public syndication feeds
```

### Example output

```json
{
  "id": "https://example.com/news/story",
  "title": "Example coverage headline",
  "url": "https://example.com/news/story",
  "matchedQueries": ["OpenAI"],
  "publisherName": "Example News",
  "publisherUrl": "https://example.com",
  "sourceName": "Google News RSS",
  "sourceTags": ["google-news"],
  "snippet": "Feed-provided article summary.",
  "publishedAt": "2026-08-31T12:00:00.000Z",
  "feedUrl": "https://news.google.com/rss/search?...",
  "sourceUrl": "https://news.google.com/rss/search?...",
  "feedType": "rss",
  "collectedAt": "2026-08-31T12:05:00.000Z"
}
```

### API

Use the Actor endpoint with your own Apify token:

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~meltwater-alternative/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"watchQueries":["OpenAI"],"lookbackDays":7,"maxItems":25}'
```

### Prompt card

> As an AI agent, collect a seven-day public-news coverage snapshot for these brands. Return up to 50 deduplicated mentions with headline, article URL, publisher, publication date, watch query, source provenance, and collection time. Report the terminal outcome and dataset readback path, keep the stated cost cap, and treat the returned sources as the scope of the result.

### Workflow scenario: from watchlist to editorial review

A communications lead starts with two brand names and a seven-day window, then adds a trusted trade feed for context. The Actor combines the public-news and trusted-feed results, merges duplicate article URLs, and keeps every watch query that matched the same story. Next, the lead reviews publisher and collection provenance, exports the dataset to an internal brief, and schedules the same bounded input for the next editorial review.

### How this workflow compares with Meltwater

| Decision point | This Actor | Meltwater |
| --- | --- | --- |
| Bounded job | Current public-news and selected-feed mention collection | Broader media-intelligence environment |
| Input | Up to ten explicit watch queries plus public feeds | Suite-level monitoring configuration |
| Output | Source-linked JSON records with query and collection provenance | Broader monitoring, reporting, and workflow outputs |
| Billing and same-job cost | Intended $0.01 per persisted mention plus platform usage; equal-workload cost evidence is pending | Enterprise custom-quote pricing; equal-workload allocation is not recorded |
| Effective efficiency | Usable-row and elapsed-time evidence will be measured on the final build | No authorized equal-workload timing measurement is recorded |
| API and automation | Rerunnable structured input through Apify API, schedules, and dataset readback | Suite reporting, alert, and integration workflows |
| Better fit | A small, inspectable collection run that feeds another system | Enterprise teams needing broad multi-channel coverage and operations |

Meltwater documents global media monitoring, social listening, sentiment analysis, broadcast and podcast tracking, influencer tools, reporting, and integrations. Those remain outside this Actor’s contract. Meltwater is a trademark of its owner; this independent Actor is not affiliated with, associated with, or endorsed by Meltwater.

### Focused standalone workflow and next step

This Actor is designed as a focused standalone workflow for explicit public-news watchlists. For a one-off keyword search without trusted-feed aggregation or a multi-query monitoring contract, continue with the [Google News Scraper](https://apify.com/khadinakbar/google-news-scraper) and then pass its results into your review or reporting workflow.

### Builder's note

I built this around a transparent monitoring boundary: public syndication data is useful when each retained row clearly names its watch query, article URL, collection source, and collection time. My goal was to make the export step inspectable and composable, while keeping broad media-intelligence needs easy to route to a suite designed for them.

### Responsible use

Collect only public sources you are authorized to monitor and respect publisher terms, copyright rules, and robots directives. Feed text remains limited to what a public feed supplies; the Actor does not bypass paywalls or scrape private accounts.

# Actor input Schema

## `watchQueries` (type: `array`):

One to ten literal news-search queries, such as OpenAI, "Acme Corp", or "Acme Corp" AND security. Each query is sent to Google News RSS and retained rows record the query that produced them. Use plain news-search syntax only; this is not a social-network handle list or a request for sentiment analysis.

## `trustedSources` (type: `array`):

Optional public feeds or publisher homepages to include alongside Google News, for example https://hnrss.org/frontpage. Homepage URLs are inspected only for an advertised public feed. Add tags to retain source provenance. This does not access paywalled, private, authenticated, or local-network sources.

## `language` (type: `string`):

Language used for Google News RSS results. Defaults to English (United States). This controls the Google News request locale, not translation or source language classification.

## `country` (type: `string`):

Country edition used for Google News RSS. Defaults to the United States. It scopes the Google News edition but does not guarantee an article publisher or audience is located there.

## `lookbackDays` (type: `integer`):

Optional Google News search window from 1 to 30 days, for example 7 for weekly coverage review. Trusted feeds are filtered by their supplied publication dates when present. This is a collection window, not a recurring schedule.

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

Whole-run maximum number of normalized mentions persisted, from 1 to 500. The actor stops before this cap, so the $0.01 per-mention event charge cannot exceed it. This is not a per-query or per-source limit.

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

Optional case-insensitive terms that remove matching headlines, snippets, or feed text, such as sponsored. Leave empty to retain all otherwise eligible mentions. These are literal contains checks, not Boolean query syntax or regular expressions.

## Actor input object example

```json
{
  "watchQueries": [
    "OpenAI",
    "Anthropic"
  ],
  "trustedSources": [],
  "language": "en-US",
  "country": "US",
  "lookbackDays": 7,
  "maxItems": 100,
  "excludeKeywords": [
    "sponsored"
  ]
}
```

# Actor output Schema

## `mentions` (type: `string`):

Deduplicated public-news and trusted-feed records with watch-query and source provenance.

## `output` (type: `string`):

Compact terminal outcome and result count.

## `runSummary` (type: `string`):

Detailed source diagnostics and billing counters.

# 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 = {
    "watchQueries": [
        "OpenAI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/meltwater-alternative").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 = { "watchQueries": ["OpenAI"] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/meltwater-alternative").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 '{
  "watchQueries": [
    "OpenAI"
  ]
}' |
apify call khadinakbar/meltwater-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/meltwater-alternative"
        }
    }
}

```

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/poovo0OuxHVdnOuBX/builds/C8OUjUYOuHAZCWtME/openapi.json