# News Mention Alerts: New Articles from Bing News and GDELT (`accountable_eel/news-mention-alert-composite`) Actor

News mention alerts for a brand, product, company or domain. One row per article from Bing News and GDELT, de-duplicated by URL: headline, publisher, publish time, snippet, language. Schedule it and only new mentions are returned and billed.

- **URL**: https://apify.com/accountable_eel/news-mention-alert-composite.md
- **Developed by:** [Adriana Voss](https://apify.com/accountable_eel) (community)
- **Categories:** News, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 news mention returneds

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

## News Mention Alerts: New Articles from Bing News and GDELT

Give it a brand, a product, a company name or a domain and get one row for every **news article
that mentions it**: headline, article URL, publisher, publish time and snippet, read from Bing News
and, if you want worldwide coverage, from GDELT as well. An article both indexes list comes back
once. Run it on a schedule and it returns only the articles it has not given you before, so a new
mention reaches you the day it is published. No API key, no account, no proxy.

### Who it's for

- **PR and communications teams** who want every new article about their brand or a product launch
  in a sheet or a Slack channel, without a media-monitoring subscription.
- **Founders and marketers** watching their own name and two or three competitors.
- **Agencies** who keep one watchlist per client and send a weekly coverage report.
- **Sales and research teams** who use a news mention of an account as a reason to reach out.
- **Developers and AI agents** who need fresh, de-duplicated news rows for a keyword as plain JSON.

### What you get

One flat row per article:

| What | Columns |
| --- | --- |
| The article | `title`, `url`, `publisher`, `domain`, `publishedAt`, `snippet`, `imageUrl` |
| From GDELT | `seenAt`, `language`, `sourceCountry` |
| The alert | `isNew`, `firstSeenAt` |
| Provenance | `query`, `foundIn`, `sourceUrl`, `scrapedAt` |

Two example rows, shortened. They are real mentions of `tesla`, read on 2026-10-11:

| query | title | publisher | domain | publishedAt | foundIn |
| --- | --- | --- | --- | --- | --- |
| tesla | Tesla has lined up about 90% of the power from a 450 MW solar farm rising in Arizona | Morning Overview on MSN | msn.com | 2026-10-11T10:45:00.000Z | bing |
| tesla | Tesla renames Full Self-Driving in Europe: Assisted Driving appears on EU sites | Softonic | en.softonic.com | 2026-10-11T07:28:00.000Z | bing |

Rows come newest first. `url` is the article's own address at the publisher, with the news index's
click-through redirect removed.

#### The two news indexes

| | Bing News | GDELT |
| --- | --- | --- |
| Speed | about a second per query | one request every 6 seconds, and it can refuse a run |
| Coverage | the articles Bing News ranks for the query, roughly 10 to 25 | outlets worldwide in 65 languages |
| Columns it fills | `publisher`, `publishedAt`, `snippet`, `imageUrl` | `seenAt`, `language`, `sourceCountry`, `imageUrl` |
| Default | on | off |

A value an index does not carry is empty on that row, never a guess.

### How the alerts work

- **A plain run** (the default) returns every article found. Nothing is remembered.
- **Turn on "Only return mentions that are new"** and the run remembers what it returned. The first
  run returns the articles already out there, so you start with the current picture. From then on a
  run returns only articles it has not returned before. A run with nothing new returns nothing and
  charges nothing beyond the start fee.
- **Give the watchlist a name** to keep two watches apart, or to track while still getting every
  article back on every run, with `isNew` and `firstSeenAt` filled.

Three rules keep the alerts honest:

1. **Filters come before the memory.** An article left out by "Published in the last N days", by
   "Only rows containing" or by "Skip rows containing" is not remembered.
2. **Only what you received is remembered.** A row cut by "Mentions per query", by the result limit
   or by your spending limit is returned on the next run.
3. **A failed read changes nothing.** If an index could not be read, the memory is left as it was
   and the next run compares against the same baseline.

### How to use News Mention Alerts

1. **In the Apify Console.** Open the actor page and click **Start** — the `queries` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~news-mention-alert-composite/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"queries":["tesla"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "queries": [
    "tesla"
  ]
}
```

One per line. Each line is searched as typed in the news indexes you select, and every article that mentions it comes back as one row. Put a name of several words in double quotes to match it as an exact phrase. Meant for brands, products, organisations and domains, not for private individuals. Accepted formats: tesla, "Novo Nordisk", apify.com.

### Output

One row per article, for example:

| query | found | status | title | url | sourceUrl | publisher | domain | publishedAt | seenAt | snippet | imageUrl | language | sourceCountry | foundIn | isNew | firstSeenAt | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| tesla | true | OK | <headline> | <article url> | <source url> | <publisher> | <publisher domain> | <published at> | <first seen by gdelt> | <snippet> | <image> | <language> | <publisher country> | <found in> | <new since last run> | <first returned> | 1970-01-01T00:00:00.000Z |

A query with no article, and a query whose news index could not be read, come back as one row with
`"found": false` and a `message` that says which. It is never charged.

### Example runs

Three inputs that need no credentials of any kind and return rows as they stand. Paste one into the
Input tab and press Start.

**1. What is the news saying about this brand right now?**

```json
{
  "queries": ["tesla"],
  "sources": "bing",
  "maxItems": 20
}
```

**2. A daily alert that only returns articles you have not seen**

Save this as a task and put it on a daily schedule. The first run returns the current articles;
later runs return an article only the first time it is seen.

```json
{
  "queries": ["\"Novo Nordisk\"", "wegovy"],
  "sources": "bing",
  "onlyNewSinceLastRun": true,
  "deltaName": "brand-press"
}
```

**3. Worldwide coverage of a product in the last three days, both indexes**

```json
{
  "queries": ["iphone"],
  "sources": "both",
  "sinceDays": 3,
  "maxItems": 50
}
```

### Pricing

Pay-per-event. A flat per-run fee covers session/proxy warmup; each independent
source is billed under its own event, only when that source actually returns
data — see `.actor/pay_per_event.json` for exact prices. A miss is never
charged.

You pay once per article returned, and nothing else:

- A query with no article is free.
- A query whose news index could not be read is free.
- An article listed by both indexes is one row and one charge.
- With "Only return mentions that are new" on, an article you were already given is not returned
  and is free. A quiet day costs the start fee and nothing more.
- Use "Mentions per query" and "Stop after this many results" to put a ceiling on a run.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~news-mention-alert-composite/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"queries":["tesla"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~news-mention-alert-composite/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"queries":["tesla"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~news-mention-alert-composite/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"queries":["{{news mention}}"]}`, mapping the row's news mention into the `queries` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "news mention alerts" — the agent will find and run this actor.

### Where the data comes from

- **Bing News** publishes its search results as an RSS feed. The actor reads that feed, newest
  first, and tops the list up from Bing's default ranking when the newest-first pages run short.
- **GDELT** is an open index of world news. The actor reads its article list for your query,
  newest first, limited to the days you asked for.

Google News is not read.

### Limits, stated plainly

- **This is a sample of the news, not all of it.** Bing News lists the articles it ranks for a
  query, roughly 10 to 25 at a time. Run it daily and the watch accumulates; a single run is not an
  archive search.
- **GDELT is slow and sometimes closed.** It allows one request every few seconds for everyone on
  the same address. When it refuses, the run says so in the log, returns the Bing News rows and
  tries GDELT again on the next run. With GDELT as the only index, a refused query is a free
  `found: false` row.
- **GDELT rows have no publisher name, publish time or snippet.** They carry the time GDELT first
  saw the article, its language and the outlet's country.
- **GDELT headlines are machine-normalised**, with spaces around punctuation.
- **De-duplication is by article address.** The same wire story republished by two outlets is two
  rows, because it is two articles. A mobile or AMP address of the same article can also come back
  as a second row.
- **A domain is searched as a word.** `apify.com` finds articles in which that text appears.
- **Results are in the language and market the index picks for the query.** There is no country or
  language setting in this version.
- **No article body.** The row carries headline and snippet, not the full text.
- **Not for watching private individuals.** It is built for brands, products, organisations and
  domains, and returns no author or contact details.

### Data & privacy

Everything returned is what two public news indexes list about published articles: headline,
address, outlet, time. No author, reader or contact data is read. The memory the actor keeps
between runs is a list of article addresses per query, stored in a key-value store in your own
Apify account under the watchlist name you chose.

### FAQ

**Why did a run return fewer rows than "Mentions per query"?**
That number is a ceiling. Bing News lists a limited set of recent articles per query; turn GDELT on
for more, or widen "Published in the last N days".

**Why did my scheduled run return nothing?**
Nothing new was published since the last run, so nothing was returned or charged.

**Why is `publisher` empty on some rows?**
The article was found in GDELT only, and GDELT lists the outlet's domain and country, not its name.
`domain` is always filled.

**Can I watch several brands in one run?**
Yes, one per line. Each query keeps its own memory, so adding one later does not reset the others.

**How often should I run it?**
Daily suits most brands. Hourly makes sense during a launch or a crisis.

**Do I need a proxy or an API key?**
No.

### Related actors

- **Google News Lookup** for a one-off Google News search.
- **Hacker News Mentions Monitor** for mentions in stories and comments on Hacker News.
- **Bluesky Mentions Monitor** for mentions in Bluesky posts.

# Actor input Schema

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

One per line. Each line is searched as typed in the news indexes you select, and every article that mentions it comes back as one row. Put a name of several words in double quotes to match it as an exact phrase. Meant for brands, products, organisations and domains, not for private individuals. Accepted formats: tesla, "Novo Nordisk", apify.com. You're only charged for the ones we actually find — a miss costs nothing.

## `sources` (type: `string`):

Bing News answers in about a second and carries publisher, snippet and publish time. GDELT covers outlets in 65 languages but allows one request every few seconds, so it adds about 6 seconds per query and can refuse a run altogether. An article listed by both is returned and charged once.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

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

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

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

The most rows returned for one query in one run, newest first. Bing News lists roughly 10 to 25 recent articles for a query, so a higher number mostly matters with GDELT on.

## `sinceDays` (type: `integer`):

Older articles are left out and never charged. An article with no date at all is kept.

## `onlyNewSinceLastRun` (type: `boolean`):

Turn this on for a scheduled run. An article that was already returned to this watchlist is not returned and not charged again, so a run with nothing new costs the start fee only.

## `deltaName` (type: `string`):

Optional. Name your watchlist, for example "brand-press". Each name keeps its own memory, so two schedules with different names never mix. Giving a name also switches tracking on while still returning every mention on every run, with the New since last run column filled.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

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

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## Actor input object example

```json
{
  "queries": [
    "tesla"
  ],
  "sources": "bing",
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "maxItems": 20,
  "sinceDays": 7,
  "onlyNewSinceLastRun": false,
  "deltaName": "",
  "columns": [
    "title",
    "url",
    "sourceUrl",
    "publisher",
    "domain",
    "publishedAt",
    "seenAt",
    "snippet",
    "imageUrl",
    "language",
    "sourceCountry",
    "foundIn",
    "isNew",
    "firstSeenAt"
  ],
  "maxConcurrency": 3
}
```

# Actor output Schema

## `results` (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": [
        "tesla"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/news-mention-alert-composite").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": ["tesla"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/news-mention-alert-composite").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": [
    "tesla"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/news-mention-alert-composite --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/news-mention-alert-composite"
        }
    }
}
```

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/KdhcpO15uhmjNtmzz/builds/RaZ86jzYBObjpZN0u/openapi.json
