# Google News Scraper (`mlg14/google-news-scraper`) Actor

Search Google News by keyword, time period, and region to export article headlines, dates, publisher details, and links.

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

## Pricing

$1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Scrape Google News search results for a keyword and export article metadata to CSV, JSON, or Excel. This Google News API alternative lets you choose a rolling time period and a regional edition, then collects public headlines, publication times, publisher details, and article links in a structured dataset.

The actor reads the public news search feed. Each output row represents one feed article, and the same article is saved only once per run. It does not fetch or reproduce publisher article bodies.

### What data can you extract from Google News?

| Field | Description | Example |
| --- | --- | --- |
| `articleId` | Feed identifier used to remove duplicates within the run | `CBMiV0FV...` |
| `title` | Headline with the trailing publisher label removed when it matches the source field | `LIVE: Climate change is here - What happens next is still in our hands` |
| `url` | Article link supplied by the news feed | `https://news.google.com/rss/articles/...` |
| `publishedAt` | Publication time converted to UTC | `2026-09-23T18:02:00Z` |
| `sourceName` | Publisher label from the feed | `UN News` |
| `sourceUrl` | Publisher website from the feed, usually its home page | `https://news.un.org` |
| `keyword` | Search phrase from your input | `climate change` |
| `timeframe` | Requested rolling time period | `1w` |
| `region` | Selected news edition country | `US` |
| `language` | Selected news edition language | `en` |

The `url` field points to the news article link supplied by the feed. The `sourceUrl` field identifies the publisher website; it is not necessarily a link to the particular story. This distinction matters when joining results to another dataset or building a link list. The feed's description field usually repeats a linked headline and publisher name, so the actor does not present it as an article summary. Images, full text, author bylines, and a direct publisher story URL are not reliably available from this source.

Publication times are normalized to the `Z` form of UTC. The feed can show several articles about the same event; they remain separate rows when they have different feed identifiers. Exact duplicate identifiers are removed. The dataset schema documents every output field, and the overview view places the headline, publisher, date, and link first so they are easy to scan after a run.

### How to scrape Google News

1. Enter a keyword or phrase in `keyword`. For example, use `climate change` to retrieve results matching that search.
2. Select a time period: last hour, day, week, 30 days, or 365 days. Pick a period broad enough to contain the number of articles you need.
3. Set `region_language` to a country and language pair, such as `US:en` or `TR:tr`. Set `maxArticles` to the largest number of rows you want saved.
4. Run the actor. When it finishes, open the default dataset to inspect results or download them as JSON, CSV, or Excel.

For a first run, start with a specific phrase and 50 to 100 articles. A phrase that has only a few recent stories cannot fill a high limit. If the result set is too broad, refine the phrase. If it is too narrow, increase the period or simplify the phrase. The number in `maxArticles` is a ceiling, not a promise that the source will return that many matching articles.

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `keyword` | string | required | Search phrase. The actor refuses an empty value. |
| `maxArticles` | integer | `100` | Maximum saved rows. `0` removes the row cap but source and request limits still apply. |
| `timeframe` | string | `1d` | One of `1h`, `1d`, `1w`, `1m`, or `1y`. These mean a rolling hour, day, week, 30 days, or 365 days. |
| `region_language` | string | `US:en` | Country and language in `CC:language` form. The feed controls which combinations return useful results. |
| `proxyConfiguration` | object | platform proxy | Optional connection settings. The standard path starts with datacenter traffic and can escalate after repeated blocks. |

Example input:

```json
{
  "keyword": "climate change",
  "timeframe": "1w",
  "region_language": "US:en",
  "maxArticles": 120
}
```

The example above was used for the golden run. It produced 120 rows. The country code is normalized to uppercase and the language code to lowercase in output. A two-letter country code and a valid language-style code are required syntactically, but a syntactically valid edition is not guaranteed to exist. If an edition returns no articles, try a known pairing such as `US:en` or a country and language combination used by that edition.

The time period labels are input conveniences. Under the hood, the source uses `7d` for a week and `30d` for 30 days. A value such as `1m` is retained in the output as the input label, while the query sent to the source uses the correct 30-day operator. Results are also checked against the rolling cutoff using their publication time. This keeps date-window requests within the period you selected.

### Output example

This complete item came from the successful golden run.

```json
{
  "articleId": "CBMiV0FVX3lxTE9fRFV5cFZRakNXREtzRG4za0FLeXd3VnZhWUY4SlVGVzlGc2hTVm9uSUhMVUx5OG1aRlI5SGpfTXZGYVY3WVRiU242SHdIdkRrTU1kb1dZOA",
  "title": "LIVE: Climate change is here - What happens next is still in our hands",
  "url": "https://news.google.com/rss/articles/CBMiV0FVX3lxTE9fRFV5cFZRakNXREtzRG4za0FLeXd3VnZhWUY4SlVGVzlGc2hTVm9uSUhMVUx5OG1aRlI5SGpfTXZGYVY3WVRiU242SHdIdkRrTU1kb1dZOA?oc=5",
  "publishedAt": "2026-09-23T18:02:00Z",
  "sourceName": "UN News",
  "sourceUrl": "https://news.un.org",
  "keyword": "climate change",
  "timeframe": "1w",
  "region": "US",
  "language": "en"
}
```

The example's publisher website is distinct from its article link. Exported rows use the complete values shown in the actual dataset. The article title is a headline supplied by the feed; the actor does not verify the publisher's article page or update its metadata if a publisher later changes the headline. If you run the same input on another day, both the feed order and article set can change as new stories arrive and older stories leave the rolling period.

### Use cases

- **Personal topic watch:** Keep a small daily list of new headlines about a subject, with times and publisher labels in one place.
- **Research reading list:** Gather public links for a literature scan, then open the source articles separately for context and citation checks.
- **Regional comparison:** Run the same phrase against several supported country and language editions to compare which articles appear in each feed.
- **Event timeline:** Export publication timestamps to arrange coverage around a public event or announcement.
- **Publisher inventory:** Group saved rows by `sourceName` or `sourceUrl` to see which publishers the feed associated with a search during a chosen period.
- **Feed change checks:** Schedule a repeated run, compare `articleId` values to an earlier dataset, and identify newly surfaced links.

These examples concern metadata and links. The actor does not determine whether two differently titled articles describe the same underlying story, whether a source is credible, or whether the feed is complete. Human review is appropriate before treating counts as measures of news coverage or public interest. Access and reuse of feed content should also follow the source's stated conditions, described under Limits.

### How much does it cost to scrape Google News?

The actor is configured for pay per result at **$1.00 per 1,000 saved articles**, or $0.001 per dataset row. The platform's included runtime and transfer are part of this event price for the user; no separate per-page fee is added by this actor. A run that finds fewer rows than your cap charges for the rows saved, subject to the platform's billing rules. The actor stops adding rows when the platform reports that the run's event budget has been reached.

| Saved articles | Result charge |
| ---: | ---: |
| 50 | $0.05 |
| 120 | $0.12 |
| 500 | $0.50 |

These are worked examples, not guarantees about available matching articles. A 500-row request may require multiple source queries because a single feed query is capped at about 100 items. That can take longer than a 50-row request. A broad 365-day request can also reach the actor's request-window limit before its requested row count is met. Check the actual dataset item count after each run, especially when using `maxArticles: 0`.

### Tips for best results

Use a phrase that appears in headlines and indexed stories. Very broad single words can produce many results and hit the source's per-query cap quickly. Very specific phrases may produce few results, particularly over one hour or one day. If the feed returns zero rows, first check the spelling, the edition, and the selected period. A supported country and language pairing helps the feed return relevant local results.

Choose the smallest period that fits your question. A short period reduces repeated results and the need for additional date windows. For a one-off recent scan, `1d` with a 50- or 100-row cap is usually a compact request. For a weekly scan, `1w` gives a wider pool. For an archive-style list, `1m` or `1y` can span more dates but may require more source requests and still be incomplete for very common phrases.

When the initial response contains 100 items and the requested cap is higher, the actor queries dated windows, newest first, then removes repeated article IDs. Day windows are used for periods up to 30 days; 30-day windows are used for a 365-day period. It stops at your row cap, after at most 40 extra windows, or after the period is exhausted. Date slicing helps pass the single-query cap, but a busy day or month can still contain more articles than one window returns. The actor does not infer missing articles from a full window.

To compare editions, run each `region_language` value separately and keep the output's `region` and `language` fields. An article may appear in multiple editions. Duplicates are removed inside one run, not across separate runs or datasets. For scheduled checks, compare `articleId` values between runs and retain the timestamp of each run in your own collection if you need a historical record.

### Limits

The public feed returns at most about 100 items for one search query. Date windows can raise the total collected, and the golden test verified 120 distinct results for a one-week keyword search. Still, a single high-volume day can be capped, 365-day searches use broader windows, and the actor makes at most 40 extra dated requests. `maxArticles: 0` means no actor row cap; it does not bypass source or window limits. Search ordering is controlled by the source and is not guaranteed to be strictly newest first.

The search web page returned HTTP 429 during source discovery. The RSS search path responded successfully, so the actor uses that structured path. Connection throttling or regional differences may still affect future runs. The connection layer starts with datacenter traffic by default, rotates its session on repeated failures, and can escalate to residential traffic. Residential traffic may consume a higher platform usage allowance. A source response with no articles is not itself treated as a block.

The feed supplies metadata, not article text, summaries, image URLs, author names, or a guaranteed direct publisher article URL. `sourceUrl` usually identifies a publisher website rather than the specific story. Headline text and source labels may change. The `publishedAt` time comes from the feed and can differ from a time shown on the publisher site. Results reflect what the feed chose to index and return for that query; absence from a dataset does not prove that no article exists.

The feed's own notice describes it as available for rendering results in a personal feed reader for personal, noncommercial use and states restrictions on other uses. Review those terms and obtain any rights required for your intended use before distributing or commercially reusing feed results. The actor is kept private here; a successful technical run does not resolve usage rights.

### Use with connected assistants

The input and output schemas allow a connected assistant to supply a keyword, period, edition, and result limit, then read the structured dataset. Useful requests include:

> Find up to 50 Google News links about climate change from the last week in the US English edition, then group the headlines by publisher.

> Collect recent news links for my research topic in two regional editions and list article IDs that appear in both result sets.

Review the linked source material before relying on any conclusion. A headline alone may omit context, and publisher websites can update or remove articles after a feed item was created. The actor returns source metadata so a connected workflow can cite where a link came from, while leaving interpretation to the person using the results.

### FAQ

#### Is it legal to use these results?

The actor collects metadata visible in a public feed. The feed notice specifies personal, noncommercial feed-reader use and restricts other uses. Follow its terms, applicable copyright rules, and privacy law; obtain permission where needed. Do not use the dataset to misuse personal information. The actor does not grant rights to republish a publisher's article or headline.

#### Do I need to configure a proxy?

No setting is required for a standard run. The actor starts with a datacenter proxy and can rotate or escalate its connection after repeated blocks. If you provide a proxy configuration with a specific group, that group is used. Network conditions can change, so a successful run does not guarantee identical access later.

#### How fast is a run?

The verified 50-row run completed after startup and one feed fetch; the 120-row run needed additional date-window requests. Duration depends on platform startup, network response, how many windows are needed, and whether a blocked request must be retried. Set a modest result cap when you need a quick reading list.

#### Can I schedule the actor and monitor changes?

Yes. Schedule runs on the platform and compare exported `articleId` values to find new links. A rolling period naturally drops old articles, so store earlier datasets if you need a historical comparison. An article can be added to the feed after its publication time, which can affect repeated runs near the period boundary.

#### Can I export to a spreadsheet?

Yes. The default dataset can be downloaded as CSV or Excel as well as JSON. Dates are serialized as ISO 8601 strings, which can be parsed as timestamps after import. Keep `articleId` as text so long identifiers are not altered by spreadsheet software.

#### Why is a field empty or a requested count not reached?

Publisher metadata depends on the source feed. A narrow query, short time period, edition with little coverage, a full per-query window, or the 40-window safety limit can reduce the result count. Check the input and try a broader period or a more general phrase. Do not treat `sourceUrl` as a missing direct story link; it is a different field by design.

#### Does the actor download the full news article?

No. It retrieves public search-feed entries and stores the headline, time, publisher information, and link. Open the `url` to read the article under the publisher's own access rules. The feed's embedded description commonly duplicates the headline and is intentionally excluded rather than labeled as a summary.

### Integrations

Use the actor's API endpoint to start a run with JSON input, and read its default dataset after completion. Platform scheduling and webhooks can trigger a recurring reading list or notify another system when a run finishes. Export CSV or Excel for spreadsheet work, or use JSON in a personal research database or another permitted workflow. Respect the feed's usage restrictions when moving results into another service.

### Support

Open an issue on the Issues tab; we reply within 24h and add fields on request.

# Actor input Schema

## `keyword` (type: `string`):

Words or a phrase to search in news headlines and indexed articles.

## `maxArticles` (type: `integer`):

Maximum articles to save. Set 0 to collect all accessible results within the date-window limit.

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

Only return articles published within the selected rolling period.

## `region_language` (type: `string`):

News edition as a country and language pair, such as US:en, GB:en, DE:de, or TR:tr.

## `proxyConfiguration` (type: `object`):

Connection settings for the public news feed. The default starts with datacenter proxy traffic.

## Actor input object example

```json
{
  "keyword": "climate change",
  "maxArticles": 100,
  "timeframe": "1d",
  "region_language": "US:en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `articles` (type: `string`):

Structured article metadata in the default dataset.

# 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 = {
    "keyword": "climate change",
    "region_language": "US:en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mlg14/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 = {
    "keyword": "climate change",
    "region_language": "US:en",
}

# Run the Actor and wait for it to finish
run = client.actor("mlg14/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 '{
  "keyword": "climate change",
  "region_language": "US:en"
}' |
apify call mlg14/google-news-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mlg14/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/yopr0qgyDnMBGPbN7/builds/cNfpBdRAN2PZnOi1b/openapi.json