# Google News Scraper — Cheap, Fast, Real Article URLs (`fabrikit/google-news-scraper`) Actor

Google News Scraper for keywords, topics and local feeds: headline, publisher, publish date and the real publisher article URL (decoded from Google's redirect link). Time windows, date ranges, any language/country. Pay per result, no subscription.

- **URL**: https://apify.com/fabrikit/google-news-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** News, SEO tools, AI
- **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 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 — Cheap, Fast, Real Article URLs

Collect news articles from Google News by keyword, topic or local place, in any language and country edition. Every article comes with the headline, publisher name and domain, publish time and (optionally) the **real article URL on the publisher's site** instead of Google's redirect link.

No browser, no login, no API key. Runs on 512 MB and finishes 50 articles with decoded URLs in under 30 seconds.

### What you get

- Search queries with Google operators (`"exact phrase"`, `OR`, `-word`, `site:`, `intitle:`)
- Topic feeds (Top stories, World, Nation, Business, Technology, Entertainment, Sports, Science, Health) and local feeds by city
- Time windows (last hour, 6 h, 12 h, 24 h, 3 d, 7 d, 30 d, 1 y) or exact date ranges
- Beyond the 100-article feed limit: automatic day-by-day slicing, so you can pull hundreds or thousands of articles per query
- Real publisher URLs decoded from the Google News links (add-on, charged only when decoding succeeded)
- Automatic datacenter-to-residential proxy fallback if Google ever blocks the first rung

### Who it is for

- **PR and communications teams** tracking every mention of a brand, executive or product, across countries and languages.
- **Investors and analysts** collecting headlines for a ticker, commodity or sector as a timestamped signal.
- **SEO and link-building teams** finding which publishers cover a topic and linking to the real article URLs.
- **Researchers and data teams** building news datasets for media studies, NLP or LLM pipelines (retrieval, summarisation, classification).
- **Local businesses and newsrooms** watching local feeds for a city or region.

### How to scrape Google News

1. Add **Search queries** (any Google News search, including operators), and/or pick **Topic feeds**, and/or add **Places** for local news.
2. Choose the **language** and **country** edition, for example `es-419` + `CL` for Chile in Spanish or `en-GB` + `GB` for the UK.
3. For queries, pick a **time window** (last hour to last year) or set **dateFrom** / **dateTo**.
4. Set **Max articles per query** (above 100 the actor slices by day automatically) and the overall **Max articles**.
5. Keep **Decode URLs** on to get the publisher's real URL, or turn it off for the cheapest run.
6. Run and export the dataset as JSON, CSV or Excel.

### Input examples

Monitor a brand over the last day:

```json
{ "queries": ["\"Acme Corp\" OR Acme"], "timeWindow": "1d", "maxItemsPerQuery": 100 }
```

Chile headlines in Spanish, cheapest mode (no URL decoding):

```json
{ "topics": ["TOP_STORIES", "BUSINESS"], "language": "es-419", "country": "CL", "decodeUrls": false }
```

Deep historical pull for one query:

```json
{ "queries": ["lithium prices"], "dateFrom": "2026-09-01", "dateTo": "2026-10-01", "maxItemsPerQuery": 1500, "maxItems": 1500 }
```

Local news for two cities:

```json
{ "queries": [], "places": ["Austin", "Denver"], "language": "en-US", "country": "US" }
```

#### Input fields

| Field | What it does |
|---|---|
| `queries` | Google News searches. Supports `"exact phrase"`, `OR`, `-exclude`, `site:reuters.com`, `intitle:`. |
| `topics` | `TOP_STORIES`, `WORLD`, `NATION`, `BUSINESS`, `TECHNOLOGY`, `ENTERTAINMENT`, `SPORTS`, `SCIENCE`, `HEALTH`. |
| `places` | City or region names for local feeds. Best when language/country match the place. |
| `timeWindow` | `any`, `1h`, `6h`, `12h`, `1d`, `3d`, `7d`, `30d`, `1y`. Search queries only. |
| `dateFrom` / `dateTo` | Exact date range (end date exclusive). Overrides the time window. |
| `language` | Edition language: `en-US`, `en-GB`, `es-419`, `es`, `pt-BR`, `fr`, `de`, `ja`, `zh-CN` and more. |
| `country` | Edition country code: `US`, `GB`, `CL`, `MX`, `DE`, `IN`, `BR`... |
| `maxItemsPerQuery` | Articles per query (default 50). Above 100, slicing by day kicks in. |
| `maxItems` | Hard cap for the whole run (default 500). |
| `decodeUrls` | Resolve Google's redirect links to the publisher URL (default on). |
| `proxyConfiguration` | Datacenter first, residential automatically if Google blocks. |

Note: `queries` defaults to `["artificial intelligence"]`; pass `"queries": []` when you only want topics or places.

### Output example

```json
{
  "id": "CBMiekFVX3lx...",
  "title": "OpenAI Makes Progress in Preventing AI-Driven ChatGPT Delusions",
  "publisher": "WSJ",
  "publisherDomain": "wsj.com",
  "publisherUrl": "https://www.wsj.com",
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMiekFVX3lx...?oc=5",
  "articleUrl": "https://www.wsj.com/tech/ai/chatgpt-gpt5-sycophancy-delusions-9b3506bf",
  "urlDecoded": true,
  "publishedAt": "2026-10-13T10:31:32.000Z",
  "sourceType": "query",
  "query": "openai",
  "language": "en-US",
  "country": "US",
  "snippet": null,
  "relatedCount": 0,
  "scrapedAt": "2026-10-13T11:54:23.694Z"
}
```

`relatedCount` is the number of other outlets Google grouped under the same story. `snippet` is filled only when the feed carries a text excerpt (most items do not).

#### Output fields

| Field | Description |
|---|---|
| `id` | Google News article id; used to remove duplicates across feeds. |
| `title` | Headline. |
| `publisher` / `publisherDomain` / `publisherUrl` | The outlet, its domain and home page. |
| `googleNewsUrl` | Google's link to the article (always opens in a browser). |
| `articleUrl` | Real URL on the publisher's site, when decoded. |
| `urlDecoded` | `true` when `articleUrl` was resolved (and charged). |
| `publishedAt` | Publish time, ISO 8601. |
| `sourceType` | `query`, `topic` or `geo` (local feed). |
| `query` | The query, topic or place that found the article. |
| `language` / `country` | Edition used. |
| `snippet` | Text excerpt, rarely present. |
| `relatedCount` | Other outlets grouped under the same story. |
| `scrapedAt` | When the article was collected. |

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

| Event | When it is charged |
|---|---|
| `news-article` | One article saved |
| `url-decoded` | One real publisher URL resolved (optional add-on) |
| `apify-actor-start` | Once per run (a fraction of a cent) |

From 30 October 2026, 1,000 articles cost US$3 on the Apify Free plan; paid Apify plans pay less per article — see the **Pricing** tab. URL decoding adds US$1 per 1,000 decoded URLs on every plan; turn `decodeUrls` off to skip it. Failed decodes are not charged. Set a maximum cost per run on Apify and the Actor stops cleanly when it is reached.

### FAQ

**How many articles per query?** A single feed returns up to 100. If you ask for more, the Actor splits the query by day (using the time window or date range; default last 30 days) and merges the results without duplicates.

**Do topic feeds support time windows?** No, Google serves them as current front pages (about 35–70 articles).

**Why is `articleUrl` null?** You turned decoding off, or Google did not resolve that item. `googleNewsUrl` always works as a link in a browser.

**Does it fetch the article body?** No. It returns the metadata Google News publishes, plus the real URL, so you can feed the URLs to your own extractor.

**Is there a limit on how far back I can go?** Day-by-day slicing covers up to 120 days per query in one run. A single day with more than 100 matching articles is capped at 100, so narrow the query (for example with `site:` or `intitle:`) for very busy topics.

**What if nothing matches?** The run finishes with an empty dataset and a status message saying no articles were found. If Google refused every request, the run fails with the error instead, so scheduled monitors do not silently report "no news".

**Can I get alerts for new articles?** Yes. Schedule a task with `timeWindow: "1h"` or `"1d"` and connect a webhook, Slack, email or n8n/Make/Zapier flow to the finished run.

**Which language and country should I use?** Use the edition your audience reads. Google News ranks and selects articles per edition, so `en-US`/`US` and `en-GB`/`GB` can return different stories for the same query.

### Use cases

Brand and competitor monitoring, PR and media tracking, financial news signals, SEO and link-building research, datasets for AI/LLM pipelines, local news alerts.

### Is it legal to scrape Google News?

It reads the public Google News feeds and returns headlines and links only. It does not log in, and it does not copy article bodies. Headlines and articles belong to their publishers, so respect copyright when you reuse them, and respect Google's terms of service. Articles can mention people by name; if you store or analyse that, data-protection laws such as the EU GDPR, Chile's Ley 21.719 or the California CCPA may apply, and you are responsible for a lawful purpose. This is general information, not legal advice.

### Integrations

Run the Google News Scraper from the Apify API or the JavaScript and Python clients, send new articles to other tools with webhooks, or schedule hourly or daily runs in Apify Console. It works with n8n, Make and Zapier, and with LangChain and LlamaIndex through their Apify integrations, which makes it easy to feed fresh news into a RAG pipeline. AI agents in Claude, ChatGPT, Cursor and other MCP clients can find and run it through Apify's MCP server. Export as JSON, CSV or Excel, or read from the dataset API.

### Use with AI agents

Use this actor to get recent news articles from Google News for a keyword, topic or city, with headline, publisher, publish time and the real article URL.

```json
{ "queries": ["semiconductor tariffs"], "timeWindow": "7d", "maxItemsPerQuery": 30 }
```

Main output fields: `title`, `publisher`, `publisherDomain`, `articleUrl`, `googleNewsUrl`, `publishedAt`, `query`, `relatedCount`. It is pay-per-event: an agent pays a small start fee plus a fixed price per article (and per decoded URL if decoding is on), not for compute time.

### Related actors

- [Google Trends Scraper](https://apify.com/fabrikit/google-trends-scraper) — search interest over time for the same topics.
- [YouTube Scraper](https://apify.com/fabrikit/youtube-videos-scraper) — video coverage of a story or brand.
- [Google Ads Transparency Scraper](https://apify.com/fabrikit/google-ads-transparency-scraper) — the ads a company runs alongside its press coverage.
- [Google Maps Scraper](https://apify.com/fabrikit/google-maps-places-scraper) — local businesses mentioned in local news.

#### Ready-made examples

- [AI news from the last 24 hours](https://apify.com/fabrikit/google-news-scraper/examples/ai-news-last-24-hours)
- [Noticias de economía en Chile](https://apify.com/fabrikit/google-news-scraper/examples/noticias-economia-chile)

### Changelog

- **2026-10-16** — README expanded: how-to, input field reference, output field table, FAQ, legal notes, integrations and example tasks.
- **2026-10-15** — Build 0.1.2: README included in the build; published on the Apify Store. Tiered pricing announced, effective 2026-10-30 (lower per-article price on paid Apify plans).
- **2026-10-13** — Build 0.1.1: initial release with search queries, topic and local feeds, day-by-day slicing beyond 100 articles, URL decoding and residential proxy fallback.

### En español

Scraper de Google News por palabra clave, tema o ciudad, en cualquier idioma y país. Devuelve titular, medio, dominio, fecha y la URL real del artículo (decodificada). Ventanas de tiempo (1 h a 1 año) o rango de fechas, y paginación automática por día para superar el límite de 100 artículos. Se cobra por artículo guardado; la decodificación de URL reales es un extra opcional. Precios vigentes en la pestaña Pricing. Ejemplo: `{"topics":["TOP_STORIES"],"language":"es-419","country":"CL"}`.

# Actor input Schema

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

Keywords to search in Google News. Supports Google operators such as `"exact phrase"`, `OR`, `-exclude`, `site:reuters.com`, `intitle:`. Leave empty if you only use topics or places.

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

Google News section feeds for the chosen language/country. The time window does not apply to topic feeds.

## `places` (type: `array`):

City or region names for Google News local feeds, e.g. `Santiago`, `Austin`, `London`. Best results when language/country match the place.

## `timeWindow` (type: `string`):

Only return articles published within this window (applies to search queries). Ignored when a start or end date is set.

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

Optional start date. Overrides the time window.

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

Optional end date (exclusive). Overrides the time window.

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

Interface/results language of the Google News edition.

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

Two-letter country code of the edition, e.g. `US`, `GB`, `CL`, `MX`, `DE`, `IN`, `BR`.

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

A single Google News feed holds up to 100 articles. For more, the Actor automatically slices the query by day (needs a time window or dates; defaults to the last 30 days).

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

Hard cap for the whole run across all queries, topics and places.

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

Google News links are redirect wrappers. When on, each link is resolved to the real article URL on the publisher's site (charged as a separate, low-cost add-on event only for URLs that were actually resolved). Turn off for the cheapest run.

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

Datacenter proxy is tried first. If Google blocks it, the Actor automatically switches to residential proxy for the rest of the run.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence"
  ],
  "topics": [],
  "places": [],
  "timeWindow": "any",
  "language": "en-US",
  "country": "US",
  "maxItemsPerQuery": 50,
  "maxItems": 500,
  "decodeUrls": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All articles collected during the 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": [
        "artificial intelligence"
    ],
    "country": "US",
    "maxItemsPerQuery": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/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": ["artificial intelligence"],
    "country": "US",
    "maxItemsPerQuery": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/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": [
    "artificial intelligence"
  ],
  "country": "US",
  "maxItemsPerQuery": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/google-news-scraper --silent --output-dataset

```

## MCP server setup

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