# Google News Scraper & Monitor (`lyklo/google-news-scraper`) Actor

Gets Google News articles for your keywords with the original article URLs. Schedule it to monitor brands and competitors: each run returns only articles that are new since the last run, plus a spike signal per keyword.

- **URL**: https://apify.com/lyklo/google-news-scraper.md
- **Developed by:** [Lyklo](https://apify.com/lyklo) (community)
- **Categories:** News, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 articles

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

## Google News Scraper & Monitor

Get Google News articles for any keywords: headline, publisher, publish time and the publisher's own article URL. Switch **What to return** to *New since the last run* and schedule it, and each run returns only the articles you haven't received yet, so a daily brand or competitor watch doesn't charge you again for yesterday's news. Each search term also gets a summary row that tells you when coverage suddenly spikes.

The data comes from the public Google News search. No Google account is needed. This is an independent tool. It is not made, endorsed or sponsored by Google.

### Who it's for

- **PR and communications teams**: watch your company, your products and your executives every morning, and get the new coverage in Slack or a spreadsheet. The spike signal points to the search term that is suddenly in the news.
- **Marketing and competitive intelligence**: follow competitors' launches, funding news and partnerships next to your own coverage.
- **Analysts and researchers**: collect every article about a topic for a period of time, day by day, past the usual 100-article limit.
- **Developers and AI agents**: feed fresh news on a topic into your own pipeline through the API.

### How to use it

1. Enter your search terms, one per line. Google News search syntax works: `"exact phrase"`, `OR`, `-exclude`, `site:reuters.com`, `intitle:word`.
2. Pick the **Edition** (country and language) and the **Time range**, or set **From date** and **To date** for a fixed period.
3. To monitor, set **What to return** to *New since the last run*, save the input as a task and add a daily or hourly schedule in Apify. Connect the task to Slack, Google Sheets, a webhook or Zapier/Make with Apify's integrations.

The first monitoring run returns the articles in the time range. After that you get only the articles that weren't returned before. Use a different **Watch name** for each separate list (for example one per client).

### What you get

#### One row per article

| Field | Meaning |
| --- | --- |
| `title` | The headline, without the publisher name Google News appends |
| `publisher`, `publisherUrl` | Who published it, and their website |
| `url` | The publisher's own article URL (with **Find original article URLs**, on by default). `null` if it couldn't be found |
| `googleNewsUrl` | The Google News link, which opens the same article in a browser |
| `publishedAt` | When it was published |
| `query`, `queries` | The search term that found it. If several of your terms found the same article, it comes once, with all of them in `queries`, and is charged once |
| `change` | `listed` in *All articles* mode, `new` in *New since the last run* mode |
| `articleId`, `edition`, `checkedAt` | The Google News article ID, the edition and when it was checked |

#### One summary row per search term

| Field | Meaning |
| --- | --- |
| `articlesFound` | Articles found in this run's time range |
| `newSinceLastRun` | Articles that are new since the last run (monitoring only) |
| `articlesLast24h` | Articles published in the last 24 hours |
| `avgArticlesPerDayPrev7d`, `spikeRatio` | The usual number of articles per day over the 7 days before, and how many times that the last 24 hours had. A `spikeRatio` of 3 means three times the usual coverage. Available after a week of monitoring |
| `topPublishers` | The publishers with the most articles in this run |
| `capReached` | Google News returns at most 100 articles per search. `true` means some day reached that limit, so a few articles may be missing. Narrow the search term to get them all |

#### Output example

An article row and a summary row from a run on `nike` in the US edition, last 24 hours (shortened):

```json
{
    "type": "article",
    "change": "listed",
    "query": "nike",
    "title": "Adidas' Comeback Against Nike Came Down To Inventory",
    "publisher": "Nett Magazine Online",
    "publisherUrl": "https://www.nett.com.au",
    "url": "https://www.nett.com.au/adidas-nike-comeback-inventory-turnaround/",
    "googleNewsUrl": "https://news.google.com/rss/articles/CBMidEFVX3lx…?oc=5",
    "publishedAt": "2026-10-26T17:31:25.000Z",
    "edition": "US:en"
}
```

```json
{
    "type": "query",
    "query": "nike",
    "edition": "US:en",
    "articlesFound": 100,
    "articlesLast24h": 100,
    "topPublishers": [
        { "publisher": "Sneaker Files", "count": 7 },
        { "publisher": "Hypebeast", "count": 5 }
    ],
    "capReached": true,
    "oldestArticleAt": "2026-10-26T07:04:05.000Z",
    "newestArticleAt": "2026-10-26T17:37:23.000Z"
}
```

Here `capReached` is `true`: "nike" had more than 100 articles in one day, so a narrower term (for example `nike running`) would get all of them.

Article rows and summary rows share one dataset. Each row has `type` (`article` or `query`); filter on it when you export the results or connect them to a spreadsheet.

### Pricing

You pay per event. In monitoring mode you pay only for new articles.

| Event | Price |
| --- | --- |
| Run start | $0.003 per run (with the default memory) |
| Article, including its original URL | $1.50 per 1,000 |
| Summary row, one per search term | $0.002 each |

Prices in the table are for the Free plan. On paid Apify plans an article costs $1.40 per 1,000 on Starter (Bronze discount), $1.30 on Scale (Silver) and $1.20 on Business (Gold) and above, and a summary row costs 10%, 20% and 30% less. The run start is the same on every plan.

For example, watching 10 search terms every morning, with about 20 new articles per term a day, costs about $9.70 a month. Re-downloading the full 100 articles per term every day would cost several times that. Set a maximum cost per run in Apify if you want a hard limit; the run stops cleanly, and the articles it could not return come out first on the next run.

### Good to know

- **"New" means not returned before by this watch.** Each run reads from two days before the previous run, so articles that reach Google News late are still caught, and nothing is returned twice. Articles published before you started the watch are never reported as new. Google News doesn't always return exactly the same articles for the same search, so an article that was published a few hours ago can still come up as new the first time Google returns it.
- **More than 100 articles.** Google News returns at most 100 articles per search. This Actor reads the last 24 hours and last 7 days day by day, and a fixed date range always day by day, so most searches get everything. Very busy terms (a big brand on a big news day) can still reach the limit for a single day; `capReached` tells you.
- **Maximum articles per search** caps one run. In monitoring mode, new articles beyond it are skipped and counted in `newOverMax`, so a busy term can't run up a surprise bill.
- **Original URLs** take two extra requests per article. Turn **Find original article URLs** off for faster and lighter runs if the Google News link is enough.
- **No article text.** You get the headline, publisher, time and links, not the article body.
- **If Google News changes**, the run stops with an error instead of returning wrong or empty results. Rows returned before that point are charged as usual; nothing after it is returned or charged.

# Actor input Schema

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

One search per line. Google News search syntax works: "exact phrase", OR, -exclude, site:reuters.com, intitle:word.

## `mode` (type: `string`):

All articles: every article in the time range, every run. New since the last run: only articles not returned before by a run with the same watch name (the first run returns the time range).

## `timeframe` (type: `string`):

How far back to look. In New since the last run mode this applies to the first run; later runs read from 2 days before the previous run.

## `dateFrom` (type: `string`):

Optional. A fixed start date instead of the time range. The run reads day by day, so a long range can return more than 100 articles.

## `dateTo` (type: `string`):

Optional. The last day to read (today if empty).

## `edition` (type: `string`):

The Google News edition: country and language.

## `maxArticlesPerQuery` (type: `integer`):

The most articles to return for each search term in one run. In New since the last run mode, new articles beyond this number are skipped (and counted in newOverMax).

## `resolveUrls` (type: `boolean`):

Turns each Google News link into the publisher's own article URL. Turn off for faster runs if the Google News link is enough.

## `watchName` (type: `string`):

New since the last run mode only. Keeps the memory of past runs separate for each watch, for example one per client. Letters, numbers and dashes.

## Actor input object example

```json
{
  "queries": [
    "nike"
  ],
  "mode": "all",
  "timeframe": "1d",
  "edition": "US:en",
  "maxArticlesPerQuery": 10,
  "resolveUrls": true,
  "watchName": "default"
}
```

# Actor output Schema

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

One dataset with two kinds of rows, told apart by the type field. Rows with type "article" are articles: title, publisher, publish time, original URL and the search terms that found it. Rows with type "query" are one per search term: articles found, new since the last run, articles in the last 24 hours against the usual daily number, and the top publishers.

# 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": [
        "nike"
    ],
    "timeframe": "1d",
    "maxArticlesPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("lyklo/google-news-scraper").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": ["nike"],
    "timeframe": "1d",
    "maxArticlesPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("lyklo/google-news-scraper").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": [
    "nike"
  ],
  "timeframe": "1d",
  "maxArticlesPerQuery": 10
}' |
apify call lyklo/google-news-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lyklo/google-news-scraper"
        }
    }
}
```

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/1cEJCgXpme8NrtQKO/builds/CjgC4kN2pNqFdbits/openapi.json