# Google News Scraper & API: Real Publisher URLs (`brainfoods_studio/google-news-scraper`) Actor

Google News past the 100-result cap, with the publisher's real link instead of Google's redirect, and coverage grouped into stories. Any keyword, topic or country. No login. $1.50 per 1,000 articles, less on paid plans. For brand monitoring, PR and AI agents.

- **URL**: https://apify.com/brainfoods_studio/google-news-scraper.md
- **Developed by:** [Brainfoods Studio](https://apify.com/brainfoods_studio) (community)
- **Categories:** News, Integrations, Agents
- **Security:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.60 / 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

> **We showed up late, so we read the fine print first.** Google News stops at 100 articles per search and hides every link behind its own redirect. We fixed both before we opened the doors.

**Google News Scraper** is a Google News API for news monitoring, brand tracking, PR and AI agents. Search any keyword, topic or top stories, in any country and language. Go **past Google's 100-result cap** and get the **real publisher URL** for every article, as JSON, CSV or Excel.

**No login · No API key · $1.50 per 1,000 articles, less on paid plans · Independent tool, not affiliated with Google**

### What does Google News Scraper do?

- **Searches Google News** with full operators: exact phrases, `site:`, `when:`, `after:` and `before:`.
- **Topic feeds and top stories**: World, Business, Technology and more, for any country.
- **Goes past the 100-article cap** by running one search per day across your date range, with duplicates removed.
- **Real publisher URLs** instead of `news.google.com` redirect links.
- **A free summary per query**: article count, unique sources, top 5 sources, first and last published, and a flag that tells you when the cap was hit.
- **Premium stories**: articles grouped across outlets, with who broke the news and how fast it spread.

### Who is it for?

- **PR and comms teams** tracking every mention of a brand, a CEO or a launch.
- **Market and investment researchers** following a company, a sector or a policy, day by day.
- **Media analysts** measuring who covers what, and who covers it first.
- **AI agents and RAG pipelines** that need fresh news with real links they can open.

### Use cases

| You want to | What to set |
| --- | --- |
| Catch every brand mention this week | `queries` with your brand names, and `timeRange` set to `7d` |
| Build a month of coverage for one company | `dateFrom`, `dateTo` and `splitByDay` |
| Read one publisher's take on a topic | An exact phrase plus `site:ft.com` |
| Follow a country's headlines in its own language | `includeTopStories`, `country` and `language` |
| See who broke a story and who followed | `clusterStories` |
| Get a Slack ping for new articles only | `monitorKey` and `deliveryWebhookUrl`, on a schedule |

### Get more than 100 articles per search

Google News returns at most 100 articles for one search. For a busy topic over a month, that's a fraction of what was published.

Turn on `splitByDay` with a date range and the actor runs one search per day, oldest first, then removes duplicates across days. A month becomes 30 searches of up to 100 each.

You'll know when you need it: every query gets a free summary row, and `hitCap` is `true` when a search came back with the full 100.

### Real publisher URLs

Google News links point to Google's own redirect pages, not to the article. Turn on `resolvePublisherUrls` and each article also gets `articleUrl`, the publisher's real address, for example `https://openai.com/index/introducing-gpt-6-1-terra/`. If a URL can't be resolved, the article still arrives with `resolveError` set, at the plain article price.

### What we measured

Live runs on Apify Proxy, 1 November 2026:

| Check | Result |
| --- | --- |
| "tesla", September 2026, one search per day | 1,262 unique articles from 277 sources in 51 seconds, against 100 for a single search |
| Publisher URLs, 3 searches with 10 articles each | 30 of 30 decoded |
| Duplicates across the 30 daily searches | none in the output (1,262 rows, 1,262 unique article IDs) |

Busy days can still hit Google's 100-article cap even when split by day. The summary row's `hitCap` tells you when that happened.

### Built to finish the run

- Every request runs in a warmed-up session with its own cookies and proxy address, and requests are paced.
- Rate limits and block pages get up to 4 attempts, with a growing pause. A session that stops working is replaced.
- On Apify Proxy, datacenter addresses are used first. After repeated rate limits, the actor moves to residential addresses if your plan has them.
- **A failed search never fails the run.** It gets an error row, and every other query still finishes.
- A `STATS` record shows the requests, rate limits, retries and session changes of every run.

### How to use the Google News scraper

1. Click **Try for free**.
2. Enter up to 50 **queries**, pick **topics**, or switch on **top stories**.
3. Set the **country** and **language**, for example `US` and `en`, or `DE` and `de`.
4. Pick a **time range**, or set `dateFrom` and `dateTo`. Switch on `splitByDay` for long ranges.
5. Click **Start**, then download the dataset as JSON, CSV or Excel, or run the actor from the [Apify API](https://docs.apify.com/api/v2) or on a schedule.

#### Input example

```json
{
  "queries": ["openai", "\"electric vehicles\" site:reuters.com"],
  "country": "US",
  "language": "en",
  "dateFrom": "2026-10-01",
  "dateTo": "2026-10-31",
  "splitByDay": true,
  "maxArticlesPerQuery": 2000,
  "resolvePublisherUrls": true
}
```

#### More ready-to-run inputs

| Use case | Input |
| --- | --- |
| Brand mentions, past 7 days | `{"queries": ["nike", "adidas"], "timeRange": "7d"}` |
| Technology headlines in the UK | `{"topics": ["TECHNOLOGY"], "country": "GB", "language": "en"}` |
| Top stories in Germany, in German | `{"includeTopStories": true, "country": "DE", "language": "de"}` |
| One publisher, exact phrase | `{"queries": ["\"interest rates\" site:ft.com"], "timeRange": "1y"}` |

Search operators work as they do on Google News: quotes for exact phrases, `site:` for one publisher, `when:`, `after:` and `before:`. `timeRange` is `any`, `1h`, `1d`, `7d` or `1y`; `dateFrom` and `dateTo` replace it. `splitByDay` covers up to 366 days.

#### Use it from an AI agent

Add the actor to any MCP client (Claude, Cursor, VS Code and others) through Apify's hosted MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=brainfoods_studio/google-news-scraper"
    }
  }
}
```

Then ask in plain words: *"Find this week's Google News coverage of OpenAI in the US, with the real article links, and list the sources that wrote about it most."* See [Apify's MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Integrations

Everything runs on Apify, so it plugs into the tools you already use:

- **Apify API and SDKs** (JavaScript, Python) to start runs and read results from your own code.
- **Schedules** to run hourly or daily. Monitor mode then returns only new articles.
- **Make, Zapier and n8n** to send articles to Google Sheets, Notion, a CRM or a database without writing code.
- **Webhooks and Slack** to get a message when new coverage turns up.
- **MCP** for Claude, Cursor and other AI agents, as shown above.

See [Apify integrations](https://docs.apify.com/platform/integrations).

### What you get

| Row type | One row per | Main columns |
| --- | --- | --- |
| `article` | article | `rank`, `title`, `sourceName`, `sourceUrl`, `publishedAt`, `articleUrl`, `googleNewsUrl`, `window` |
| `summary` | query, topic or top stories (free) | `articles`, `uniqueSources`, `topSources`, `firstPublishedAt`, `lastPublishedAt`, `hitCap` |
| `error` | failed search | `stage`, `errorKind`, `message`, `attempts`, `window` |

One `article` row:

```json
{
  "type": "article",
  "source": "openai",
  "feedType": "search",
  "country": "US",
  "language": "en",
  "rank": 1,
  "title": "Introducing GPT-6.1 Terra",
  "sourceName": "OpenAI",
  "sourceUrl": "https://openai.com",
  "publishedAt": "2026-10-26T18:05:36.000Z",
  "articleUrl": "https://openai.com/index/introducing-gpt-6-1-terra/",
  "resolveError": "",
  "window": ""
}
```

Every article also carries `googleNewsUrl`, `articleId` and `fetchedAt`. Titles come without the trailing " - Source" that Google adds. `window` is the day an article came from when you split by day.

### Premium features

#### Stories: how big is this news, and who broke it?

Set `clusterStories: true` and articles about the same story are grouped across outlets. Each `story` row has the headline, the number of articles and outlets, who published first and when, how many outlets picked it up within 24 hours, and how many hours it took to spread. Only stories of 2 or more articles are returned.

On "openai", past 7 days (1 November 2026), 100 articles formed 5 stories. The largest, "OpenAI, a longtime Nvidia customer, plans to buy Google's AI chips", was broken by The Information and covered by 3 outlets within 1.4 hours.

#### Monitor mode: only what's new

Set `monitorKey` to any name and run the actor on a schedule. Each run remembers what it returned, and the next run with the same name returns only articles you haven't seen yet, so you pay only for new results. Add `deliveryWebhookUrl` (a Slack incoming-webhook URL or any HTTPS endpoint) and a short alert with a link to the results is posted whenever something new turns up. The first run only builds the memory and never alerts. Use one `monitorKey` per schedule.

### Pricing

You pay per article delivered. Summary rows and error rows are free.

| Result | Free plan | Bronze | Silver | Gold and up |
| --- | --- | --- | --- | --- |
| Article | $0.0015 | $0.001 | $0.0008 | $0.0006 |
| Article with its publisher URL | $0.0025 | $0.0017 | $0.0013 | $0.001 |
| Story (premium) | $0.005 | $0.004 | $0.0035 | $0.003 |
| Monitor alert, per alert sent | $0.01 | $0.01 | $0.01 | $0.01 |

- **Charged only after your results are saved.** Never for error rows or summaries.
- **Never past your spending limit.** When the limit is reached, the actor stops starting new searches, and the run still succeeds.
- **No extra start fee.** Only Apify's standard run start charge of $0.00005 applies.
- An article whose publisher URL couldn't be resolved is charged at the plain article price.

What typical runs cost, before the start charge:

| Run | Free plan | Bronze |
| --- | --- | --- |
| 1 query, 100 articles | $0.15 | $0.10 |
| 1 query, 100 articles with publisher URLs | $0.25 | $0.17 |
| 1 query split over a month, 1,000 articles | $1.50 | $1.00 |
| 10 queries, 100 articles each | $1.50 | $1.00 |

### FAQ

#### Do I need a Google account or an API key?

No. You only need an Apify account. Click **Try for free**, enter a search and start.

#### Why does Google News stop at 100 articles?

Google returns at most 100 articles for one search. Split the range by day to get up to 100 per day. If `hitCap` is still `true` with `splitByDay` on, narrow the query, for example with `site:` or an exact phrase.

#### Which countries and languages work?

Any 2-letter country code and 2-letter language code that Google News offers, for example `US`/`en`, `GB`/`en`, `IN`/`hi` or `DE`/`de`.

#### Why are some publisher URLs missing?

Google decides how each link is resolved. When it can't be, the article arrives with `resolveError` set and costs the plain article price.

#### Can I monitor a topic over time?

Yes. Schedule the actor with `timeRange` set to `1d` and the same queries every day, and each run gives you that day's articles.

### Legal note

This actor reads Google News' public feeds. It does not solve captchas and does not try to get around anti-bot checks. It respects Google's rate limits by waiting and backing off. Use the data in line with Google's terms, the publishers' rights and the laws where you live.

### More from Brainfoods Studio

- [Google Trends Scraper](https://apify.com/brainfoods_studio/google-trends-scraper): interest over time for up to 100 keywords on one 0–100 scale, plus regions, related queries and trending now.
- [Google Ads Transparency Scraper](https://apify.com/brainfoods_studio/google-ads-transparency-scraper): every ad a brand runs on Google, by name, ID or website, with dates, countries and ad text.
- [Google Play Scraper](https://apify.com/brainfoods_studio/google-play-scraper): app details and reviews, plus an App health report that shows which release hurt the rating.

### Support

We're the new kids on this Store, so every issue gets an answer from the people who wrote the code. Found a problem, or need a field we don't return yet? Open an issue in the **Issues** tab. And if this actor saved you an afternoon, a review helps the next person find it.

Built and maintained by Brainfoods Studio.

# Changelog

This Actor's version history is a separate document: https://apify.com/brainfoods_studio/google-news-scraper/changelog.md

# Actor input Schema

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

News searches, up to 50. Google search operators work, for example "exact phrase", site:bbc.com or OR. Each query is one source in the results.

## `topics` (type: `array`):

Google News topic feeds to fetch: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH.

## `includeTopStories` (type: `boolean`):

Also fetch the Google News top stories feed for the chosen country and language.

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

Two-letter country code that sets the Google News edition, for example US, GB or IN.

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

Two-letter language code, for example en, de or fr.

## `timeRange` (type: `string`):

How far back to search. Applies to search queries only; topics and top stories are always current. Ignored when Date from and Date to are set.

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

First day to include, as YYYY-MM-DD. Give both Date from and Date to, or neither. Replaces the time range.

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

Last day to include, as YYYY-MM-DD. It cannot be in the future.

## `splitByDay` (type: `boolean`):

Run one search per day between Date from and Date to (at most 366 days). Google returns at most 100 articles per search, so this gets past that limit.

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

Stop collecting articles for a query, topic or top stories once this many are found. Charged per article.

## `resolvePublisherUrls` (type: `boolean`):

Look up the real publisher link of each article instead of only the Google News link. Charged as a separate, higher-priced event for each article that is resolved.

## `clusterStories` (type: `boolean`):

Groups articles about the same story across outlets. Adds one story row per story of 2 or more articles, with who published first, how many outlets covered it and how fast it spread. Charged per story row.

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

Parallel requests, 1 to 8. The default of 2 is the safest; higher is faster but more likely to be rate-limited by Google.

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

Apify Proxy is strongly recommended. Datacenter is tried first; residential is used automatically after repeated 429s if your plan has it.

## `monitorKey` (type: `string`):

Turns on monitor mode. Results are remembered under this name, and later runs with the same name return only what is new. Use one name per schedule.

## `deliveryWebhookUrl` (type: `string`):

Optional. A Slack incoming-webhook URL or any HTTPS endpoint. When a monitored run finds something new, it posts a short alert with a link to the results. Charged as one alert per run that sends one. Stored encrypted and hidden from logs, because a webhook URL works like a password.

## Actor input object example

```json
{
  "queries": [
    "openai"
  ],
  "includeTopStories": false,
  "country": "US",
  "language": "en",
  "timeRange": "7d",
  "splitByDay": false,
  "maxArticlesPerQuery": 20,
  "resolvePublisherUrls": false,
  "clusterStories": false,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All rows: news articles, a free summary row per query, topic or top stories, and error rows for any feed that failed.

## `stats` (type: `string`):

Requests, successes, rate limits, retries, session changes and a summary of rows and charges for this run.

# 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"
    ],
    "timeRange": "7d",
    "maxArticlesPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("brainfoods_studio/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"],
    "timeRange": "7d",
    "maxArticlesPerQuery": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("brainfoods_studio/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"
  ],
  "timeRange": "7d",
  "maxArticlesPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call brainfoods_studio/google-news-scraper --silent --output-dataset

```

## MCP server setup

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