# Google News Scraper - Headlines with Real Publisher URLs (`scrapefy/google-news-scraper`) Actor

Search Google News by keyword or topic, country, language and date range. Get headline, source, date and the decoded publisher link, past the 100-result cap. Headlines only.

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

## Pricing

from $2.00 / 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.

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: headlines with real publisher URLs, by keyword, topic, country and date range

Scrape **Google News** by search query or topic and get one clean row per article: **headline, publisher name, publisher site, publication time, the Google News link and the decoded real publisher URL** (reuters.com, nytimes.com... instead of the news.google.com redirect). Pick the country and language edition, set a **start and end date**, and the actor splits the range into day and week windows automatically to get past Google's limit of about 100 results per search. Export to JSON, CSV or Excel, or call it from the API.

Use it for **news monitoring and media tracking, brand and competitor alerts, PR and reputation reports, market and financial research, and datasets for LLM, RAG and sentiment pipelines**. Works with AI agents through the Apify MCP server. It reads Google News' public RSS feeds; no login, no cookies and no proxy are needed.

### Why this one

- **Real publisher URLs.** Each Google News redirect is decoded to the article's own URL (about 98% success in our tests; the rest return `url: null` with a `decodeStatus`). Switch decoding off for a faster run.
- **Gets past the 100-result cap.** With a start date, ranges are split into 7-day windows and any window that comes back full is halved down to single days, newest first.
- **Any country and language edition.** `US/en`, `ES/es`, `DE/de`, `GB/en`, `BR/pt` and so on.
- **Queries and topic feeds.** Several queries per run, Google search operators (`"exact phrase"`, `OR`, `-word`, `intitle:`, `site:`) and the eight topic sections (World, Business, Technology...).
- **Duplicates removed.** The same story found by two queries or two windows is returned once.
- **Cheap and predictable.** $0.002 per article; `Max articles per query` caps every run.
- **Never fails the whole run for one input.** An empty query, bad country, topic or date gets its own row with an `error` message and is **not charged**; the rest continue. A `RUN_SUMMARY` record lists articles, windows, decode results and HTTP statuses.
- **Polite by design.** Paced requests, retries with backoff, honours Retry-After and stops politely if Google keeps answering 429.

### Input

| Field | Meaning |
|---|---|
| Search queries | One or more queries, for example `OpenAI`, `"electric cars" Germany`, `site:reuters.com chips` |
| Topic feed | Optional: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH (about 70 current items) |
| Country / Language | Edition codes, default `US` / `en` |
| Start date / End date | Optional `YYYY-MM-DD` range; enables automatic window splitting. End defaults to today |
| Decode publisher URLs | Default on |
| Max articles per query | Default 100, max 5,000 (above 100 needs a start date) |
| Remove duplicates | Default on |

### Output

**Article row:** `type: "article", title, source, sourceUrl, publishedAt, googleNewsUrl, url, decodeStatus, snippet, query, country, language, window, scrapedAt`.

**Error row:** `type: "error", query, error, scrapedAt`. See `sample-output.json` for real rows.

Notes on the data:

- `url` is the publisher's article URL, or `null` when decoding is off or failed (`decodeStatus` says why: `ok`, `skipped`, `no-url`, `no-params`, `http-NNN`).
- `snippet` is present only when Google's feed carries a description different from the headline (mostly topic feeds).
- `window` shows which date window found the article (for example `2026-10-22..2026-10-22`).
- Google News returns about 100 items per request. A single day that still returns 100 hits for a very busy query may hold more stories than Google exposes; the `RUN_SUMMARY` marks these as `cappedWindows`.
- Without dates you get the most relevant recent items for the query, up to about 100.

### Pricing

Pay per event: **$0.002 per article** ($2.00 per 1,000 articles) plus a $0.00005 start event per run. URL decoding is included. Error rows are not charged. A run returning 100 articles costs about 20 cents. See PRICING.md for the benchmark.

### Public data only

The actor reads only public Google News RSS feeds and resolves Google's own redirect links to the publishers' URLs. It returns **headlines, sources, dates and links only**; it does **not** open or scrape the publishers' article pages or bodies, does not log in and does not bypass anything. Headlines and articles belong to their publishers: you are responsible for using the data in line with Google's terms, the publishers' terms and copyright law.

### Notes and limits

- Not an official Google product or API; the feed format or the decoding call can change without notice.
- Google may rate-limit heavy use from one network. The actor slows down, retries and stops politely instead of hammering.
- Results are what Google News shows for the chosen edition; ranking differs by country and language.

### FAQ

**How much does it cost?** $0.002 per article plus $0.00005 per run. 1,000 articles = $2.00. Error rows are free.

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

**How do I get more than 100 articles for one query?** Set a start date (and optionally an end date) and a higher `Max articles per query`; the actor splits the range into windows.

**Can I get the article text?** No. This actor returns headlines and links only.

**Which export formats are available?** JSON, CSV, Excel, XML, HTML or RSS from the Console or API, or integrations such as Make, Zapier, n8n and Google Sheets.

**Something broke or a field is missing?** Open an issue on the Actor's Issues tab with the run link.

### Use with AI agents / MCP

Agents can call this Actor through the [Apify MCP server](https://mcp.apify.com). Let the agent find it with the `search-actors` tool ("google news scraper") and call it by name:

- Actor: `santis_hermes/google-news-scraper`
- Example prompt: "Get the latest 50 Google News headlines about OpenAI with the real publisher links."
- Minimal input:

```json
{
  "queries": ["OpenAI"],
  "country": "US",
  "language": "en",
  "maxItemsPerQuery": 50,
  "decodeUrls": true
}
```

# Actor input Schema

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

One or more Google News search queries, for example 'OpenAI' or 'electric cars Germany'. Google operators work: quotes for exact phrases, OR, -word, intitle:, site:example.com. Leave empty when you only want a topic feed.

## `topic` (type: `string`):

Optional Google News topic section to read the latest headlines from, instead of or next to your queries. Topic feeds hold about 70 current items and ignore the date windows except for filtering by publication date.

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

Two-letter country code of the Google News edition, for example US, GB, DE, ES, FR, BR, IN. It decides which local stories and publishers are ranked first.

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

Two-letter language code of the edition, for example en, es, de, fr, pt. Match it to the country (es with ES, de with DE) for the best coverage.

## `startDate` (type: `string`):

Optional first day of the date range, format YYYY-MM-DD, for example 2026-10-01. When set, the actor splits the range into day and week windows automatically to get past Google's 100-result limit per request.

## `endDate` (type: `string`):

Optional last day of the date range, format YYYY-MM-DD. Default is today. Needs a start date.

## `decodeUrls` (type: `boolean`):

Turns each news.google.com redirect link into the real publisher article URL (reuters.com, nytimes.com and so on). Turn it off for a faster run when the Google link is enough; the url field is then null.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of articles returned for each query. You are charged per article returned, so this keeps the cost of a run predictable. Values above 100 only make sense together with a start date, which enables the window splitting.

## `dedupe` (type: `boolean`):

Skips an article that was already returned earlier in the same run, for example when two queries or two date windows find the same story.

## Actor input object example

```json
{
  "queries": [
    "OpenAI"
  ],
  "country": "US",
  "language": "en",
  "decodeUrls": true,
  "maxItemsPerQuery": 100,
  "dedupe": true
}
```

# Actor output Schema

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

All articles as a table with the key columns.

## `links` (type: `string`):

Compact table: date, publisher, headline, publisher URL.

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

Every row with all fields.

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

Articles per query, windows used, decode results, HTTP statuses and charged events.

# 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": [
        "OpenAI"
    ],
    "country": "US",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapefy/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": ["OpenAI"],
    "country": "US",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapefy/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": [
    "OpenAI"
  ],
  "country": "US",
  "language": "en"
}' |
apify call scrapefy/google-news-scraper --silent --output-dataset

```

## MCP server setup

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